element.cc

// Copyright 2010-2024 Google LLC
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <algorithm>
#include <cstdint>
#include <functional>
#include <limits>
#include <memory>
#include <numeric>
#include <string>
#include <utility>
#include <vector>

#include "absl/strings/str_format.h"
#include "absl/strings/str_join.h"
#include "ortools/base/logging.h"
#include "ortools/base/types.h"
#include "ortools/constraint_solver/constraint_solver.h"
#include "ortools/constraint_solver/constraint_solveri.h"
#include "ortools/util/range_minimum_query.h"
#include "ortools/util/string_array.h"

ABSL_FLAG(bool, cp_disable_element_cache, true,
          "If true, caching for IntElement is disabled.");

namespace operations_research {

// ----- IntExprElement -----
void LinkVarExpr(Solver* s, IntExpr* expr, IntVar* var);

namespace {

template <class T>
class VectorLess {
 public:
  explicit VectorLess(const std::vector<T>* values) : values_(values) {}
  bool operator()(const T& x, const T& y) const {
    return (*values_)[x] < (*values_)[y];
  }

 private:
  const std::vector<T>* values_;
};

template <class T>
class VectorGreater {
 public:
  explicit VectorGreater(const std::vector<T>* values) : values_(values) {}
  bool operator()(const T& x, const T& y) const {
    return (*values_)[x] > (*values_)[y];
  }

 private:
  const std::vector<T>* values_;
};

// ----- BaseIntExprElement -----

class BaseIntExprElement : public BaseIntExpr {
 public:
  BaseIntExprElement(Solver* s, IntVar* e);
  ~BaseIntExprElement() override {}
  int64_t Min() const override;
  int64_t Max() const override;
  void Range(int64_t* mi, int64_t* ma) override;
  void SetMin(int64_t m) override;
  void SetMax(int64_t m) override;
  void SetRange(int64_t mi, int64_t ma) override;
  bool Bound() const override { return (expr_->Bound()); }
  // TODO(user) : improve me, the previous test is not always true
  void WhenRange(Demon* d) override { expr_->WhenRange(d); }

 protected:
  virtual int64_t ElementValue(int index) const = 0;
  virtual int64_t ExprMin() const = 0;
  virtual int64_t ExprMax() const = 0;

  IntVar* const expr_;

 private:
  void UpdateSupports() const;
  template <typename T>
  void UpdateElementIndexBounds(T check_value) {
    const int64_t emin = ExprMin();
    const int64_t emax = ExprMax();
    int64_t nmin = emin;
    int64_t value = ElementValue(nmin);
    while (nmin < emax && check_value(value)) {
      nmin++;
      value = ElementValue(nmin);
    }
    if (nmin == emax && check_value(value)) {
      solver()->Fail();
    }
    int64_t nmax = emax;
    value = ElementValue(nmax);
    while (nmax >= nmin && check_value(value)) {
      nmax--;
      value = ElementValue(nmax);
    }
    expr_->SetRange(nmin, nmax);
  }

  mutable int64_t min_;
  mutable int min_support_;
  mutable int64_t max_;
  mutable int max_support_;
  mutable bool initial_update_;
  IntVarIterator* const expr_iterator_;
};

BaseIntExprElement::BaseIntExprElement(Solver* const s, IntVar* const e)
    : BaseIntExpr(s),
      expr_(e),
      min_(0),
      min_support_(-1),
      max_(0),
      max_support_(-1),
      initial_update_(true),
      expr_iterator_(expr_->MakeDomainIterator(true)) {
  CHECK(s != nullptr);
  CHECK(e != nullptr);
}

int64_t BaseIntExprElement::Min() const {
  UpdateSupports();
  return min_;
}

int64_t BaseIntExprElement::Max() const {
  UpdateSupports();
  return max_;
}

void BaseIntExprElement::Range(int64_t* mi, int64_t* ma) {
  UpdateSupports();
  *mi = min_;
  *ma = max_;
}

void BaseIntExprElement::SetMin(int64_t m) {
  UpdateElementIndexBounds([m](int64_t value) { return value < m; });
}

void BaseIntExprElement::SetMax(int64_t m) {
  UpdateElementIndexBounds([m](int64_t value) { return value > m; });
}

void BaseIntExprElement::SetRange(int64_t mi, int64_t ma) {
  if (mi > ma) {
    solver()->Fail();
  }
  UpdateElementIndexBounds(
      [mi, ma](int64_t value) { return value < mi || value > ma; });
}

void BaseIntExprElement::UpdateSupports() const {
  if (initial_update_ || !expr_->Contains(min_support_) ||
      !expr_->Contains(max_support_)) {
    const int64_t emin = ExprMin();
    const int64_t emax = ExprMax();
    int64_t min_value = ElementValue(emax);
    int64_t max_value = min_value;
    int min_support = emax;
    int max_support = emax;
    const uint64_t expr_size = expr_->Size();
    if (expr_size > 1) {
      if (expr_size == emax - emin + 1) {
        // Value(emax) already stored in min_value, max_value.
        for (int64_t index = emin; index < emax; ++index) {
          const int64_t value = ElementValue(index);
          if (value > max_value) {
            max_value = value;
            max_support = index;
          } else if (value < min_value) {
            min_value = value;
            min_support = index;
          }
        }
      } else {
        for (const int64_t index : InitAndGetValues(expr_iterator_)) {
          if (index >= emin && index <= emax) {
            const int64_t value = ElementValue(index);
            if (value > max_value) {
              max_value = value;
              max_support = index;
            } else if (value < min_value) {
              min_value = value;
              min_support = index;
            }
          }
        }
      }
    }
    Solver* s = solver();
    s->SaveAndSetValue(&min_, min_value);
    s->SaveAndSetValue(&min_support_, min_support);
    s->SaveAndSetValue(&max_, max_value);
    s->SaveAndSetValue(&max_support_, max_support);
    s->SaveAndSetValue(&initial_update_, false);
  }
}

// ----- IntElementConstraint -----

// This constraint implements 'elem' == 'values'['index'].
// It scans the bounds of 'elem' to propagate on the domain of 'index'.
// It scans the domain of 'index' to compute the new bounds of 'elem'.
class IntElementConstraint : public CastConstraint {
 public:
  IntElementConstraint(Solver* const s, const std::vector<int64_t>& values,
                       IntVar* const index, IntVar* const elem)
      : CastConstraint(s, elem),
        values_(values),
        index_(index),
        index_iterator_(index_->MakeDomainIterator(true)) {
    CHECK(index != nullptr);
  }

  void Post() override {
    Demon* const d =
        solver()->MakeDelayedConstraintInitialPropagateCallback(this);
    index_->WhenDomain(d);
    target_var_->WhenRange(d);
  }

  void InitialPropagate() override {
    index_->SetRange(0, values_.size() - 1);
    const int64_t target_var_min = target_var_->Min();
    const int64_t target_var_max = target_var_->Max();
    int64_t new_min = target_var_max;
    int64_t new_max = target_var_min;
    to_remove_.clear();
    for (const int64_t index : InitAndGetValues(index_iterator_)) {
      const int64_t value = values_[index];
      if (value < target_var_min || value > target_var_max) {
        to_remove_.push_back(index);
      } else {
        if (value < new_min) {
          new_min = value;
        }
        if (value > new_max) {
          new_max = value;
        }
      }
    }
    target_var_->SetRange(new_min, new_max);
    if (!to_remove_.empty()) {
      index_->RemoveValues(to_remove_);
    }
  }

  std::string DebugString() const override {
    return absl::StrFormat("IntElementConstraint(%s, %s, %s)",
                           absl::StrJoin(values_, ", "), index_->DebugString(),
                           target_var_->DebugString());
  }

  void Accept(ModelVisitor* const visitor) const override {
    visitor->BeginVisitConstraint(ModelVisitor::kElementEqual, this);
    visitor->VisitIntegerArrayArgument(ModelVisitor::kValuesArgument, values_);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument,
                                            index_);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kTargetArgument,
                                            target_var_);
    visitor->EndVisitConstraint(ModelVisitor::kElementEqual, this);
  }

 private:
  const std::vector<int64_t> values_;
  IntVar* const index_;
  IntVarIterator* const index_iterator_;
  std::vector<int64_t> to_remove_;
};

// ----- IntExprElement

IntVar* BuildDomainIntVar(Solver* solver, std::vector<int64_t>* values);

class IntExprElement : public BaseIntExprElement {
 public:
  IntExprElement(Solver* const s, const std::vector<int64_t>& vals,
                 IntVar* const expr)
      : BaseIntExprElement(s, expr), values_(vals) {}

  ~IntExprElement() override {}

  std::string name() const override {
    const int size = values_.size();
    if (size > 10) {
      return absl::StrFormat("IntElement(array of size %d, %s)", size,
                             expr_->name());
    } else {
      return absl::StrFormat("IntElement(%s, %s)", absl::StrJoin(values_, ", "),
                             expr_->name());
    }
  }

  std::string DebugString() const override {
    const int size = values_.size();
    if (size > 10) {
      return absl::StrFormat("IntElement(array of size %d, %s)", size,
                             expr_->DebugString());
    } else {
      return absl::StrFormat("IntElement(%s, %s)", absl::StrJoin(values_, ", "),
                             expr_->DebugString());
    }
  }

  IntVar* CastToVar() override {
    Solver* const s = solver();
    IntVar* const var = s->MakeIntVar(values_);
    s->AddCastConstraint(
        s->RevAlloc(new IntElementConstraint(s, values_, expr_, var)), var,
        this);
    return var;
  }

  void Accept(ModelVisitor* const visitor) const override {
    visitor->BeginVisitIntegerExpression(ModelVisitor::kElement, this);
    visitor->VisitIntegerArrayArgument(ModelVisitor::kValuesArgument, values_);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument,
                                            expr_);
    visitor->EndVisitIntegerExpression(ModelVisitor::kElement, this);
  }

 protected:
  int64_t ElementValue(int index) const override {
    DCHECK_LT(index, values_.size());
    return values_[index];
  }
  int64_t ExprMin() const override {
    return std::max<int64_t>(0, expr_->Min());
  }
  int64_t ExprMax() const override {
    return values_.empty()
               ? 0
               : std::min<int64_t>(values_.size() - 1, expr_->Max());
  }

 private:
  const std::vector<int64_t> values_;
};

// ----- Range Minimum Query-based Element -----

class RangeMinimumQueryExprElement : public BaseIntExpr {
 public:
  RangeMinimumQueryExprElement(Solver* solver,
                               const std::vector<int64_t>& values,
                               IntVar* index);
  ~RangeMinimumQueryExprElement() override {}
  int64_t Min() const override;
  int64_t Max() const override;
  void Range(int64_t* mi, int64_t* ma) override;
  void SetMin(int64_t m) override;
  void SetMax(int64_t m) override;
  void SetRange(int64_t mi, int64_t ma) override;
  bool Bound() const override { return (index_->Bound()); }
  // TODO(user) : improve me, the previous test is not always true
  void WhenRange(Demon* d) override { index_->WhenRange(d); }
  IntVar* CastToVar() override {
    // TODO(user): Should we try to make holes in the domain of index_, as we
    // do here, or should we only propagate bounds as we do in
    // IncreasingIntExprElement ?
    IntVar* const var = solver()->MakeIntVar(min_rmq_.array());
    solver()->AddCastConstraint(solver()->RevAlloc(new IntElementConstraint(
                                    solver(), min_rmq_.array(), index_, var)),
                                var, this);
    return var;
  }
  void Accept(ModelVisitor* const visitor) const override {
    visitor->BeginVisitIntegerExpression(ModelVisitor::kElement, this);
    visitor->VisitIntegerArrayArgument(ModelVisitor::kValuesArgument,
                                       min_rmq_.array());
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument,
                                            index_);
    visitor->EndVisitIntegerExpression(ModelVisitor::kElement, this);
  }

 private:
  int64_t IndexMin() const { return std::max<int64_t>(0, index_->Min()); }
  int64_t IndexMax() const {
    return std::min<int64_t>(min_rmq_.array().size() - 1, index_->Max());
  }

  IntVar* const index_;
  const RangeMinimumQuery<int64_t, std::less<int64_t>> min_rmq_;
  const RangeMinimumQuery<int64_t, std::greater<int64_t>> max_rmq_;
};

RangeMinimumQueryExprElement::RangeMinimumQueryExprElement(
    Solver* solver, const std::vector<int64_t>& values, IntVar* index)
    : BaseIntExpr(solver), index_(index), min_rmq_(values), max_rmq_(values) {
  CHECK(solver != nullptr);
  CHECK(index != nullptr);
}

int64_t RangeMinimumQueryExprElement::Min() const {
  return min_rmq_.GetMinimumFromRange(IndexMin(), IndexMax() + 1);
}

int64_t RangeMinimumQueryExprElement::Max() const {
  return max_rmq_.GetMinimumFromRange(IndexMin(), IndexMax() + 1);
}

void RangeMinimumQueryExprElement::Range(int64_t* mi, int64_t* ma) {
  const int64_t range_min = IndexMin();
  const int64_t range_max = IndexMax() + 1;
  *mi = min_rmq_.GetMinimumFromRange(range_min, range_max);
  *ma = max_rmq_.GetMinimumFromRange(range_min, range_max);
}

#define UPDATE_RMQ_BASE_ELEMENT_INDEX_BOUNDS(test)       \
  const std::vector<int64_t>& values = min_rmq_.array(); \
  int64_t index_min = IndexMin();                        \
  int64_t index_max = IndexMax();                        \
  int64_t value = values[index_min];                     \
  while (index_min < index_max && (test)) {              \
    index_min++;                                         \
    value = values[index_min];                           \
  }                                                      \
  if (index_min == index_max && (test)) {                \
    solver()->Fail();                                    \
  }                                                      \
  value = values[index_max];                             \
  while (index_max >= index_min && (test)) {             \
    index_max--;                                         \
    value = values[index_max];                           \
  }                                                      \
  index_->SetRange(index_min, index_max);

void RangeMinimumQueryExprElement::SetMin(int64_t m) {
  UPDATE_RMQ_BASE_ELEMENT_INDEX_BOUNDS(value < m);
}

void RangeMinimumQueryExprElement::SetMax(int64_t m) {
  UPDATE_RMQ_BASE_ELEMENT_INDEX_BOUNDS(value > m);
}

void RangeMinimumQueryExprElement::SetRange(int64_t mi, int64_t ma) {
  if (mi > ma) {
    solver()->Fail();
  }
  UPDATE_RMQ_BASE_ELEMENT_INDEX_BOUNDS(value < mi || value > ma);
}

#undef UPDATE_RMQ_BASE_ELEMENT_INDEX_BOUNDS

// ----- Increasing Element -----

class IncreasingIntExprElement : public BaseIntExpr {
 public:
  IncreasingIntExprElement(Solver* s, const std::vector<int64_t>& values,
                           IntVar* index);
  ~IncreasingIntExprElement() override {}

  int64_t Min() const override;
  void SetMin(int64_t m) override;
  int64_t Max() const override;
  void SetMax(int64_t m) override;
  void SetRange(int64_t mi, int64_t ma) override;
  bool Bound() const override { return (index_->Bound()); }
  // TODO(user) : improve me, the previous test is not always true
  std::string name() const override {
    return absl::StrFormat("IntElement(%s, %s)", absl::StrJoin(values_, ", "),
                           index_->name());
  }
  std::string DebugString() const override {
    return absl::StrFormat("IntElement(%s, %s)", absl::StrJoin(values_, ", "),
                           index_->DebugString());
  }

  void Accept(ModelVisitor* const visitor) const override {
    visitor->BeginVisitIntegerExpression(ModelVisitor::kElement, this);
    visitor->VisitIntegerArrayArgument(ModelVisitor::kValuesArgument, values_);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument,
                                            index_);
    visitor->EndVisitIntegerExpression(ModelVisitor::kElement, this);
  }

  void WhenRange(Demon* d) override { index_->WhenRange(d); }

  IntVar* CastToVar() override {
    Solver* const s = solver();
    IntVar* const var = s->MakeIntVar(values_);
    LinkVarExpr(s, this, var);
    return var;
  }

 private:
  const std::vector<int64_t> values_;
  IntVar* const index_;
};

IncreasingIntExprElement::IncreasingIntExprElement(
    Solver* const s, const std::vector<int64_t>& values, IntVar* const index)
    : BaseIntExpr(s), values_(values), index_(index) {
  DCHECK(index);
  DCHECK(s);
}

int64_t IncreasingIntExprElement::Min() const {
  const int64_t expression_min = std::max<int64_t>(0, index_->Min());
  return (expression_min < values_.size()
              ? values_[expression_min]
              : std::numeric_limits<int64_t>::max());
}

void IncreasingIntExprElement::SetMin(int64_t m) {
  const int64_t index_min = std::max<int64_t>(0, index_->Min());
  const int64_t index_max =
      std::min<int64_t>(values_.size() - 1, index_->Max());

  if (index_min > index_max || m > values_[index_max]) {
    solver()->Fail();
  }

  const std::vector<int64_t>::const_iterator first =
      std::lower_bound(values_.begin(), values_.end(), m);
  const int64_t new_index_min = first - values_.begin();
  index_->SetMin(new_index_min);
}

int64_t IncreasingIntExprElement::Max() const {
  const int64_t expression_max =
      std::min<int64_t>(values_.size() - 1, index_->Max());
  return (expression_max >= 0 ? values_[expression_max]
                              : std::numeric_limits<int64_t>::max());
}

void IncreasingIntExprElement::SetMax(int64_t m) {
  int64_t index_min = std::max<int64_t>(0, index_->Min());
  if (m < values_[index_min]) {
    solver()->Fail();
  }

  const std::vector<int64_t>::const_iterator last_after =
      std::upper_bound(values_.begin(), values_.end(), m);
  const int64_t new_index_max = (last_after - values_.begin()) - 1;
  index_->SetRange(0, new_index_max);
}

void IncreasingIntExprElement::SetRange(int64_t mi, int64_t ma) {
  if (mi > ma) {
    solver()->Fail();
  }
  const int64_t index_min = std::max<int64_t>(0, index_->Min());
  const int64_t index_max =
      std::min<int64_t>(values_.size() - 1, index_->Max());

  if (mi > ma || ma < values_[index_min] || mi > values_[index_max]) {
    solver()->Fail();
  }

  const std::vector<int64_t>::const_iterator first =
      std::lower_bound(values_.begin(), values_.end(), mi);
  const int64_t new_index_min = first - values_.begin();

  const std::vector<int64_t>::const_iterator last_after =
      std::upper_bound(first, values_.end(), ma);
  const int64_t new_index_max = (last_after - values_.begin()) - 1;

  // Assign.
  index_->SetRange(new_index_min, new_index_max);
}

// ----- Solver::MakeElement(int array, int var) -----
IntExpr* BuildElement(Solver* const solver, const std::vector<int64_t>& values,
                      IntVar* const index) {
  // Various checks.
  // Is array constant?
  if (IsArrayConstant(values, values[0])) {
    solver->AddConstraint(solver->MakeBetweenCt(index, 0, values.size() - 1));
    return solver->MakeIntConst(values[0]);
  }
  // Is array built with booleans only?
  // TODO(user): We could maintain the index of the first one.
  if (IsArrayBoolean(values)) {
    std::vector<int64_t> ones;
    int first_zero = -1;
    for (int i = 0; i < values.size(); ++i) {
      if (values[i] == 1) {
        ones.push_back(i);
      } else {
        first_zero = i;
      }
    }
    if (ones.size() == 1) {
      DCHECK_EQ(int64_t{1}, values[ones.back()]);
      solver->AddConstraint(solver->MakeBetweenCt(index, 0, values.size() - 1));
      return solver->MakeIsEqualCstVar(index, ones.back());
    } else if (ones.size() == values.size() - 1) {
      solver->AddConstraint(solver->MakeBetweenCt(index, 0, values.size() - 1));
      return solver->MakeIsDifferentCstVar(index, first_zero);
    } else if (ones.size() == ones.back() - ones.front() + 1) {  // contiguous.
      solver->AddConstraint(solver->MakeBetweenCt(index, 0, values.size() - 1));
      IntVar* const b = solver->MakeBoolVar("ContiguousBooleanElementVar");
      solver->AddConstraint(
          solver->MakeIsBetweenCt(index, ones.front(), ones.back(), b));
      return b;
    } else {
      IntVar* const b = solver->MakeBoolVar("NonContiguousBooleanElementVar");
      solver->AddConstraint(solver->MakeBetweenCt(index, 0, values.size() - 1));
      solver->AddConstraint(solver->MakeIsMemberCt(index, ones, b));
      return b;
    }
  }
  IntExpr* cache = nullptr;
  if (!absl::GetFlag(FLAGS_cp_disable_element_cache)) {
    cache = solver->Cache()->FindVarConstantArrayExpression(
        index, values, ModelCache::VAR_CONSTANT_ARRAY_ELEMENT);
  }
  if (cache != nullptr) {
    return cache;
  } else {
    IntExpr* result = nullptr;
    if (values.size() >= 2 && index->Min() == 0 && index->Max() == 1) {
      result = solver->MakeSum(solver->MakeProd(index, values[1] - values[0]),
                               values[0]);
    } else if (values.size() == 2 && index->Contains(0) && index->Contains(1)) {
      solver->AddConstraint(solver->MakeBetweenCt(index, 0, 1));
      result = solver->MakeSum(solver->MakeProd(index, values[1] - values[0]),
                               values[0]);
    } else if (IsIncreasingContiguous(values)) {
      result = solver->MakeSum(index, values[0]);
    } else if (IsIncreasing(values)) {
      result = solver->RegisterIntExpr(solver->RevAlloc(
          new IncreasingIntExprElement(solver, values, index)));
    } else {
      if (solver->parameters().use_element_rmq()) {
        result = solver->RegisterIntExpr(solver->RevAlloc(
            new RangeMinimumQueryExprElement(solver, values, index)));
      } else {
        result = solver->RegisterIntExpr(
            solver->RevAlloc(new IntExprElement(solver, values, index)));
      }
    }
    if (!absl::GetFlag(FLAGS_cp_disable_element_cache)) {
      solver->Cache()->InsertVarConstantArrayExpression(
          result, index, values, ModelCache::VAR_CONSTANT_ARRAY_ELEMENT);
    }
    return result;
  }
}
}  // namespace

IntExpr* Solver::MakeElement(const std::vector<int64_t>& values,
                             IntVar* const index) {
  DCHECK(index);
  DCHECK_EQ(this, index->solver());
  if (index->Bound()) {
    return MakeIntConst(values[index->Min()]);
  }
  return BuildElement(this, values, index);
}

IntExpr* Solver::MakeElement(const std::vector<int>& values,
                             IntVar* const index) {
  DCHECK(index);
  DCHECK_EQ(this, index->solver());
  if (index->Bound()) {
    return MakeIntConst(values[index->Min()]);
  }
  return BuildElement(this, ToInt64Vector(values), index);
}

// ----- IntExprFunctionElement -----

namespace {
class IntExprFunctionElement : public BaseIntExprElement {
 public:
  IntExprFunctionElement(Solver* s, Solver::IndexEvaluator1 values, IntVar* e);
  ~IntExprFunctionElement() override;

  std::string name() const override {
    return absl::StrFormat("IntFunctionElement(%s)", expr_->name());
  }

  std::string DebugString() const override {
    return absl::StrFormat("IntFunctionElement(%s)", expr_->DebugString());
  }

  void Accept(ModelVisitor* const visitor) const override {
    // Warning: This will expand all values into a vector.
    visitor->BeginVisitIntegerExpression(ModelVisitor::kElement, this);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument,
                                            expr_);
    visitor->VisitInt64ToInt64Extension(values_, expr_->Min(), expr_->Max());
    visitor->EndVisitIntegerExpression(ModelVisitor::kElement, this);
  }

 protected:
  int64_t ElementValue(int index) const override { return values_(index); }
  int64_t ExprMin() const override { return expr_->Min(); }
  int64_t ExprMax() const override { return expr_->Max(); }

 private:
  Solver::IndexEvaluator1 values_;
};

IntExprFunctionElement::IntExprFunctionElement(Solver* const s,
                                               Solver::IndexEvaluator1 values,
                                               IntVar* const e)
    : BaseIntExprElement(s, e), values_(std::move(values)) {
  CHECK(values_ != nullptr);
}

IntExprFunctionElement::~IntExprFunctionElement() {}

// ----- Increasing Element -----

class IncreasingIntExprFunctionElement : public BaseIntExpr {
 public:
  IncreasingIntExprFunctionElement(Solver* const s,
                                   Solver::IndexEvaluator1 values,
                                   IntVar* const index)
      : BaseIntExpr(s), values_(std::move(values)), index_(index) {
    DCHECK(values_ != nullptr);
    DCHECK(index);
    DCHECK(s);
  }

  ~IncreasingIntExprFunctionElement() override {}

  int64_t Min() const override { return values_(index_->Min()); }

  void SetMin(int64_t m) override {
    const int64_t index_min = index_->Min();
    const int64_t index_max = index_->Max();
    if (m > values_(index_max)) {
      solver()->Fail();
    }
    const int64_t new_index_min = FindNewIndexMin(index_min, index_max, m);
    index_->SetMin(new_index_min);
  }

  int64_t Max() const override { return values_(index_->Max()); }

  void SetMax(int64_t m) override {
    int64_t index_min = index_->Min();
    int64_t index_max = index_->Max();
    if (m < values_(index_min)) {
      solver()->Fail();
    }
    const int64_t new_index_max = FindNewIndexMax(index_min, index_max, m);
    index_->SetMax(new_index_max);
  }

  void SetRange(int64_t mi, int64_t ma) override {
    const int64_t index_min = index_->Min();
    const int64_t index_max = index_->Max();
    const int64_t value_min = values_(index_min);
    const int64_t value_max = values_(index_max);
    if (mi > ma || ma < value_min || mi > value_max) {
      solver()->Fail();
    }
    if (mi <= value_min && ma >= value_max) {
      // Nothing to do.
      return;
    }

    const int64_t new_index_min = FindNewIndexMin(index_min, index_max, mi);
    const int64_t new_index_max = FindNewIndexMax(new_index_min, index_max, ma);
    // Assign.
    index_->SetRange(new_index_min, new_index_max);
  }

  std::string name() const override {
    return absl::StrFormat("IncreasingIntExprFunctionElement(values, %s)",
                           index_->name());
  }

  std::string DebugString() const override {
    return absl::StrFormat("IncreasingIntExprFunctionElement(values, %s)",
                           index_->DebugString());
  }

  void WhenRange(Demon* d) override { index_->WhenRange(d); }

  void Accept(ModelVisitor* const visitor) const override {
    // Warning: This will expand all values into a vector.
    visitor->BeginVisitIntegerExpression(ModelVisitor::kElement, this);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument,
                                            index_);
    if (index_->Min() == 0) {
      visitor->VisitInt64ToInt64AsArray(values_, ModelVisitor::kValuesArgument,
                                        index_->Max());
    } else {
      visitor->VisitInt64ToInt64Extension(values_, index_->Min(),
                                          index_->Max());
    }
    visitor->EndVisitIntegerExpression(ModelVisitor::kElement, this);
  }

 private:
  int64_t FindNewIndexMin(int64_t index_min, int64_t index_max, int64_t m) {
    if (m <= values_(index_min)) {
      return index_min;
    }

    DCHECK_LT(values_(index_min), m);
    DCHECK_GE(values_(index_max), m);

    int64_t index_lower_bound = index_min;
    int64_t index_upper_bound = index_max;
    while (index_upper_bound - index_lower_bound > 1) {
      DCHECK_LT(values_(index_lower_bound), m);
      DCHECK_GE(values_(index_upper_bound), m);
      const int64_t pivot = (index_lower_bound + index_upper_bound) / 2;
      const int64_t pivot_value = values_(pivot);
      if (pivot_value < m) {
        index_lower_bound = pivot;
      } else {
        index_upper_bound = pivot;
      }
    }
    DCHECK(values_(index_upper_bound) >= m);
    return index_upper_bound;
  }

  int64_t FindNewIndexMax(int64_t index_min, int64_t index_max, int64_t m) {
    if (m >= values_(index_max)) {
      return index_max;
    }

    DCHECK_LE(values_(index_min), m);
    DCHECK_GT(values_(index_max), m);

    int64_t index_lower_bound = index_min;
    int64_t index_upper_bound = index_max;
    while (index_upper_bound - index_lower_bound > 1) {
      DCHECK_LE(values_(index_lower_bound), m);
      DCHECK_GT(values_(index_upper_bound), m);
      const int64_t pivot = (index_lower_bound + index_upper_bound) / 2;
      const int64_t pivot_value = values_(pivot);
      if (pivot_value > m) {
        index_upper_bound = pivot;
      } else {
        index_lower_bound = pivot;
      }
    }
    DCHECK(values_(index_lower_bound) <= m);
    return index_lower_bound;
  }

  Solver::IndexEvaluator1 values_;
  IntVar* const index_;
};
}  // namespace

IntExpr* Solver::MakeElement(Solver::IndexEvaluator1 values,
                             IntVar* const index) {
  CHECK_EQ(this, index->solver());
  return RegisterIntExpr(
      RevAlloc(new IntExprFunctionElement(this, std::move(values), index)));
}

IntExpr* Solver::MakeMonotonicElement(Solver::IndexEvaluator1 values,
                                      bool increasing, IntVar* const index) {
  CHECK_EQ(this, index->solver());
  if (increasing) {
    return RegisterIntExpr(
        RevAlloc(new IncreasingIntExprFunctionElement(this, values, index)));
  } else {
    // You need to pass by copy such that opposite_value does not include a
    // dandling reference when leaving this scope.
    Solver::IndexEvaluator1 opposite_values = [values](int64_t i) {
      return -values(i);
    };
    return RegisterIntExpr(MakeOpposite(RevAlloc(
        new IncreasingIntExprFunctionElement(this, opposite_values, index))));
  }
}

// ----- IntIntExprFunctionElement -----

namespace {
class IntIntExprFunctionElement : public BaseIntExpr {
 public:
  IntIntExprFunctionElement(Solver* s, Solver::IndexEvaluator2 values,
                            IntVar* expr1, IntVar* expr2);
  ~IntIntExprFunctionElement() override;
  std::string DebugString() const override {
    return absl::StrFormat("IntIntFunctionElement(%s,%s)",
                           expr1_->DebugString(), expr2_->DebugString());
  }
  int64_t Min() const override;
  int64_t Max() const override;
  void Range(int64_t* lower_bound, int64_t* upper_bound) override;
  void SetMin(int64_t lower_bound) override;
  void SetMax(int64_t upper_bound) override;
  void SetRange(int64_t lower_bound, int64_t upper_bound) override;
  bool Bound() const override { return expr1_->Bound() && expr2_->Bound(); }
  // TODO(user) : improve me, the previous test is not always true
  void WhenRange(Demon* d) override {
    expr1_->WhenRange(d);
    expr2_->WhenRange(d);
  }

  void Accept(ModelVisitor* const visitor) const override {
    visitor->BeginVisitIntegerExpression(ModelVisitor::kElement, this);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument,
                                            expr1_);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndex2Argument,
                                            expr2_);
    // Warning: This will expand all values into a vector.
    const int64_t expr1_min = expr1_->Min();
    const int64_t expr1_max = expr1_->Max();
    visitor->VisitIntegerArgument(ModelVisitor::kMinArgument, expr1_min);
    visitor->VisitIntegerArgument(ModelVisitor::kMaxArgument, expr1_max);
    for (int i = expr1_min; i <= expr1_max; ++i) {
      visitor->VisitInt64ToInt64Extension(
          [this, i](int64_t j) { return values_(i, j); }, expr2_->Min(),
          expr2_->Max());
    }
    visitor->EndVisitIntegerExpression(ModelVisitor::kElement, this);
  }

 private:
  int64_t ElementValue(int index1, int index2) const {
    return values_(index1, index2);
  }
  void UpdateSupports() const;

  IntVar* const expr1_;
  IntVar* const expr2_;
  mutable int64_t min_;
  mutable int min_support1_;
  mutable int min_support2_;
  mutable int64_t max_;
  mutable int max_support1_;
  mutable int max_support2_;
  mutable bool initial_update_;
  Solver::IndexEvaluator2 values_;
  IntVarIterator* const expr1_iterator_;
  IntVarIterator* const expr2_iterator_;
};

IntIntExprFunctionElement::IntIntExprFunctionElement(
    Solver* const s, Solver::IndexEvaluator2 values, IntVar* const expr1,
    IntVar* const expr2)
    : BaseIntExpr(s),
      expr1_(expr1),
      expr2_(expr2),
      min_(0),
      min_support1_(-1),
      min_support2_(-1),
      max_(0),
      max_support1_(-1),
      max_support2_(-1),
      initial_update_(true),
      values_(std::move(values)),
      expr1_iterator_(expr1_->MakeDomainIterator(true)),
      expr2_iterator_(expr2_->MakeDomainIterator(true)) {
  CHECK(values_ != nullptr);
}

IntIntExprFunctionElement::~IntIntExprFunctionElement() {}

int64_t IntIntExprFunctionElement::Min() const {
  UpdateSupports();
  return min_;
}

int64_t IntIntExprFunctionElement::Max() const {
  UpdateSupports();
  return max_;
}

void IntIntExprFunctionElement::Range(int64_t* lower_bound,
                                      int64_t* upper_bound) {
  UpdateSupports();
  *lower_bound = min_;
  *upper_bound = max_;
}

#define UPDATE_ELEMENT_INDEX_BOUNDS(test)     \
  const int64_t emin1 = expr1_->Min();        \
  const int64_t emax1 = expr1_->Max();        \
  const int64_t emin2 = expr2_->Min();        \
  const int64_t emax2 = expr2_->Max();        \
  int64_t nmin1 = emin1;                      \
  bool found = false;                         \
  while (nmin1 <= emax1 && !found) {          \
    for (int i = emin2; i <= emax2; ++i) {    \
      int64_t value = ElementValue(nmin1, i); \
      if (test) {                             \
        found = true;                         \
        break;                                \
      }                                       \
    }                                         \
    if (!found) {                             \
      nmin1++;                                \
    }                                         \
  }                                           \
  if (nmin1 > emax1) {                        \
    solver()->Fail();                         \
  }                                           \
  int64_t nmin2 = emin2;                      \
  found = false;                              \
  while (nmin2 <= emax2 && !found) {          \
    for (int i = emin1; i <= emax1; ++i) {    \
      int64_t value = ElementValue(i, nmin2); \
      if (test) {                             \
        found = true;                         \
        break;                                \
      }                                       \
    }                                         \
    if (!found) {                             \
      nmin2++;                                \
    }                                         \
  }                                           \
  if (nmin2 > emax2) {                        \
    solver()->Fail();                         \
  }                                           \
  int64_t nmax1 = emax1;                      \
  found = false;                              \
  while (nmax1 >= nmin1 && !found) {          \
    for (int i = emin2; i <= emax2; ++i) {    \
      int64_t value = ElementValue(nmax1, i); \
      if (test) {                             \
        found = true;                         \
        break;                                \
      }                                       \
    }                                         \
    if (!found) {                             \
      nmax1--;                                \
    }                                         \
  }                                           \
  int64_t nmax2 = emax2;                      \
  found = false;                              \
  while (nmax2 >= nmin2 && !found) {          \
    for (int i = emin1; i <= emax1; ++i) {    \
      int64_t value = ElementValue(i, nmax2); \
      if (test) {                             \
        found = true;                         \
        break;                                \
      }                                       \
    }                                         \
    if (!found) {                             \
      nmax2--;                                \
    }                                         \
  }                                           \
  expr1_->SetRange(nmin1, nmax1);             \
  expr2_->SetRange(nmin2, nmax2);

void IntIntExprFunctionElement::SetMin(int64_t lower_bound) {
  UPDATE_ELEMENT_INDEX_BOUNDS(value >= lower_bound);
}

void IntIntExprFunctionElement::SetMax(int64_t upper_bound) {
  UPDATE_ELEMENT_INDEX_BOUNDS(value <= upper_bound);
}

void IntIntExprFunctionElement::SetRange(int64_t lower_bound,
                                         int64_t upper_bound) {
  if (lower_bound > upper_bound) {
    solver()->Fail();
  }
  UPDATE_ELEMENT_INDEX_BOUNDS(value >= lower_bound && value <= upper_bound);
}

#undef UPDATE_ELEMENT_INDEX_BOUNDS

void IntIntExprFunctionElement::UpdateSupports() const {
  if (initial_update_ || !expr1_->Contains(min_support1_) ||
      !expr1_->Contains(max_support1_) || !expr2_->Contains(min_support2_) ||
      !expr2_->Contains(max_support2_)) {
    const int64_t emax1 = expr1_->Max();
    const int64_t emax2 = expr2_->Max();
    int64_t min_value = ElementValue(emax1, emax2);
    int64_t max_value = min_value;
    int min_support1 = emax1;
    int max_support1 = emax1;
    int min_support2 = emax2;
    int max_support2 = emax2;
    for (const int64_t index1 : InitAndGetValues(expr1_iterator_)) {
      for (const int64_t index2 : InitAndGetValues(expr2_iterator_)) {
        const int64_t value = ElementValue(index1, index2);
        if (value > max_value) {
          max_value = value;
          max_support1 = index1;
          max_support2 = index2;
        } else if (value < min_value) {
          min_value = value;
          min_support1 = index1;
          min_support2 = index2;
        }
      }
    }
    Solver* s = solver();
    s->SaveAndSetValue(&min_, min_value);
    s->SaveAndSetValue(&min_support1_, min_support1);
    s->SaveAndSetValue(&min_support2_, min_support2);
    s->SaveAndSetValue(&max_, max_value);
    s->SaveAndSetValue(&max_support1_, max_support1);
    s->SaveAndSetValue(&max_support2_, max_support2);
    s->SaveAndSetValue(&initial_update_, false);
  }
}
}  // namespace

IntExpr* Solver::MakeElement(Solver::IndexEvaluator2 values,
                             IntVar* const index1, IntVar* const index2) {
  CHECK_EQ(this, index1->solver());
  CHECK_EQ(this, index2->solver());
  return RegisterIntExpr(RevAlloc(
      new IntIntExprFunctionElement(this, std::move(values), index1, index2)));
}

// ---------- Generalized element ----------

// ----- IfThenElseCt -----

class IfThenElseCt : public CastConstraint {
 public:
  IfThenElseCt(Solver* const solver, IntVar* const condition,
               IntExpr* const one, IntExpr* const zero, IntVar* const target)
      : CastConstraint(solver, target),
        condition_(condition),
        zero_(zero),
        one_(one) {}

  ~IfThenElseCt() override {}

  void Post() override {
    Demon* const demon = solver()->MakeConstraintInitialPropagateCallback(this);
    condition_->WhenBound(demon);
    one_->WhenRange(demon);
    zero_->WhenRange(demon);
    target_var_->WhenRange(demon);
  }

  void InitialPropagate() override {
    condition_->SetRange(0, 1);
    const int64_t target_var_min = target_var_->Min();
    const int64_t target_var_max = target_var_->Max();
    int64_t new_min = std::numeric_limits<int64_t>::min();
    int64_t new_max = std::numeric_limits<int64_t>::max();
    if (condition_->Max() == 0) {
      zero_->SetRange(target_var_min, target_var_max);
      zero_->Range(&new_min, &new_max);
    } else if (condition_->Min() == 1) {
      one_->SetRange(target_var_min, target_var_max);
      one_->Range(&new_min, &new_max);
    } else {
      if (target_var_max < zero_->Min() || target_var_min > zero_->Max()) {
        condition_->SetValue(1);
        one_->SetRange(target_var_min, target_var_max);
        one_->Range(&new_min, &new_max);
      } else if (target_var_max < one_->Min() || target_var_min > one_->Max()) {
        condition_->SetValue(0);
        zero_->SetRange(target_var_min, target_var_max);
        zero_->Range(&new_min, &new_max);
      } else {
        int64_t zl = 0;
        int64_t zu = 0;
        int64_t ol = 0;
        int64_t ou = 0;
        zero_->Range(&zl, &zu);
        one_->Range(&ol, &ou);
        new_min = std::min(zl, ol);
        new_max = std::max(zu, ou);
      }
    }
    target_var_->SetRange(new_min, new_max);
  }

  std::string DebugString() const override {
    return absl::StrFormat("(%s ? %s : %s) == %s", condition_->DebugString(),
                           one_->DebugString(), zero_->DebugString(),
                           target_var_->DebugString());
  }

  void Accept(ModelVisitor* const visitor) const override {}

 private:
  IntVar* const condition_;
  IntExpr* const zero_;
  IntExpr* const one_;
};

// ----- IntExprEvaluatorElementCt -----

// This constraint implements evaluator(index) == var. It is delayed such
// that propagation only occurs when all variables have been touched.
// The range of the evaluator is [range_start, range_end).

namespace {
class IntExprEvaluatorElementCt : public CastConstraint {
 public:
  IntExprEvaluatorElementCt(Solver* s, Solver::Int64ToIntVar evaluator,
                            int64_t range_start, int64_t range_end,
                            IntVar* index, IntVar* target_var);
  ~IntExprEvaluatorElementCt() override {}

  void Post() override;
  void InitialPropagate() override;

  void Propagate();
  void Update(int index);
  void UpdateExpr();

  std::string DebugString() const override;
  void Accept(ModelVisitor* visitor) const override;

 protected:
  IntVar* const index_;

 private:
  const Solver::Int64ToIntVar evaluator_;
  const int64_t range_start_;
  const int64_t range_end_;
  int min_support_;
  int max_support_;
};

IntExprEvaluatorElementCt::IntExprEvaluatorElementCt(
    Solver* const s, Solver::Int64ToIntVar evaluator, int64_t range_start,
    int64_t range_end, IntVar* const index, IntVar* const target_var)
    : CastConstraint(s, target_var),
      index_(index),
      evaluator_(std::move(evaluator)),
      range_start_(range_start),
      range_end_(range_end),
      min_support_(-1),
      max_support_(-1) {}

void IntExprEvaluatorElementCt::Post() {
  Demon* const delayed_propagate_demon = MakeDelayedConstraintDemon0(
      solver(), this, &IntExprEvaluatorElementCt::Propagate, "Propagate");
  for (int i = range_start_; i < range_end_; ++i) {
    IntVar* const current_var = evaluator_(i);
    current_var->WhenRange(delayed_propagate_demon);
    Demon* const update_demon = MakeConstraintDemon1(
        solver(), this, &IntExprEvaluatorElementCt::Update, "Update", i);
    current_var->WhenRange(update_demon);
  }
  index_->WhenRange(delayed_propagate_demon);
  Demon* const update_expr_demon = MakeConstraintDemon0(
      solver(), this, &IntExprEvaluatorElementCt::UpdateExpr, "UpdateExpr");
  index_->WhenRange(update_expr_demon);
  Demon* const update_var_demon = MakeConstraintDemon0(
      solver(), this, &IntExprEvaluatorElementCt::Propagate, "UpdateVar");

  target_var_->WhenRange(update_var_demon);
}

void IntExprEvaluatorElementCt::InitialPropagate() { Propagate(); }

void IntExprEvaluatorElementCt::Propagate() {
  const int64_t emin = std::max(range_start_, index_->Min());
  const int64_t emax = std::min<int64_t>(range_end_ - 1, index_->Max());
  const int64_t vmin = target_var_->Min();
  const int64_t vmax = target_var_->Max();
  if (emin == emax) {
    index_->SetValue(emin);  // in case it was reduced by the above min/max.
    evaluator_(emin)->SetRange(vmin, vmax);
  } else {
    int64_t nmin = emin;
    for (; nmin <= emax; nmin++) {
      // break if the intersection of
      // [evaluator_(nmin)->Min(), evaluator_(nmin)->Max()] and [vmin, vmax]
      // is non-empty.
      IntVar* const nmin_var = evaluator_(nmin);
      if (nmin_var->Min() <= vmax && nmin_var->Max() >= vmin) break;
    }
    int64_t nmax = emax;
    for (; nmin <= nmax; nmax--) {
      // break if the intersection of
      // [evaluator_(nmin)->Min(), evaluator_(nmin)->Max()] and [vmin, vmax]
      // is non-empty.
      IntExpr* const nmax_var = evaluator_(nmax);
      if (nmax_var->Min() <= vmax && nmax_var->Max() >= vmin) break;
    }
    index_->SetRange(nmin, nmax);
    if (nmin == nmax) {
      evaluator_(nmin)->SetRange(vmin, vmax);
    }
  }
  if (min_support_ == -1 || max_support_ == -1) {
    int min_support = -1;
    int max_support = -1;
    int64_t gmin = std::numeric_limits<int64_t>::max();
    int64_t gmax = std::numeric_limits<int64_t>::min();
    for (int i = index_->Min(); i <= index_->Max(); ++i) {
      IntExpr* const var_i = evaluator_(i);
      const int64_t vmin = var_i->Min();
      if (vmin < gmin) {
        gmin = vmin;
      }
      const int64_t vmax = var_i->Max();
      if (vmax > gmax) {
        gmax = vmax;
      }
    }
    solver()->SaveAndSetValue(&min_support_, min_support);
    solver()->SaveAndSetValue(&max_support_, max_support);
    target_var_->SetRange(gmin, gmax);
  }
}

void IntExprEvaluatorElementCt::Update(int index) {
  if (index == min_support_ || index == max_support_) {
    solver()->SaveAndSetValue(&min_support_, -1);
    solver()->SaveAndSetValue(&max_support_, -1);
  }
}

void IntExprEvaluatorElementCt::UpdateExpr() {
  if (!index_->Contains(min_support_) || !index_->Contains(max_support_)) {
    solver()->SaveAndSetValue(&min_support_, -1);
    solver()->SaveAndSetValue(&max_support_, -1);
  }
}

namespace {
std::string StringifyEvaluatorBare(const Solver::Int64ToIntVar& evaluator,
                                   int64_t range_start, int64_t range_end) {
  std::string out;
  for (int64_t i = range_start; i < range_end; ++i) {
    if (i != range_start) {
      out += ", ";
    }
    out += absl::StrFormat("%d -> %s", i, evaluator(i)->DebugString());
  }
  return out;
}

std::string StringifyInt64ToIntVar(const Solver::Int64ToIntVar& evaluator,
                                   int64_t range_begin, int64_t range_end) {
  std::string out;
  if (range_end - range_begin > 10) {
    out = absl::StrFormat(
        "IntToIntVar(%s, ...%s)",
        StringifyEvaluatorBare(evaluator, range_begin, range_begin + 5),
        StringifyEvaluatorBare(evaluator, range_end - 5, range_end));
  } else {
    out = absl::StrFormat(
        "IntToIntVar(%s)",
        StringifyEvaluatorBare(evaluator, range_begin, range_end));
  }
  return out;
}
}  // namespace

std::string IntExprEvaluatorElementCt::DebugString() const {
  return StringifyInt64ToIntVar(evaluator_, range_start_, range_end_);
}

void IntExprEvaluatorElementCt::Accept(ModelVisitor* const visitor) const {
  visitor->BeginVisitConstraint(ModelVisitor::kElementEqual, this);
  visitor->VisitIntegerVariableEvaluatorArgument(
      ModelVisitor::kEvaluatorArgument, evaluator_);
  visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument, index_);
  visitor->VisitIntegerExpressionArgument(ModelVisitor::kTargetArgument,
                                          target_var_);
  visitor->EndVisitConstraint(ModelVisitor::kElementEqual, this);
}

// ----- IntExprArrayElementCt -----

// This constraint implements vars[index] == var. It is delayed such
// that propagation only occurs when all variables have been touched.

class IntExprArrayElementCt : public IntExprEvaluatorElementCt {
 public:
  IntExprArrayElementCt(Solver* s, std::vector<IntVar*> vars, IntVar* index,
                        IntVar* target_var);

  std::string DebugString() const override;
  void Accept(ModelVisitor* visitor) const override;

 private:
  const std::vector<IntVar*> vars_;
};

IntExprArrayElementCt::IntExprArrayElementCt(Solver* const s,
                                             std::vector<IntVar*> vars,
                                             IntVar* const index,
                                             IntVar* const target_var)
    : IntExprEvaluatorElementCt(
          s, [this](int64_t idx) { return vars_[idx]; }, 0, vars.size(), index,
          target_var),
      vars_(std::move(vars)) {}

std::string IntExprArrayElementCt::DebugString() const {
  int64_t size = vars_.size();
  if (size > 10) {
    return absl::StrFormat(
        "IntExprArrayElement(var array of size %d, %s) == %s", size,
        index_->DebugString(), target_var_->DebugString());
  } else {
    return absl::StrFormat("IntExprArrayElement([%s], %s) == %s",
                           JoinDebugStringPtr(vars_, ", "),
                           index_->DebugString(), target_var_->DebugString());
  }
}

void IntExprArrayElementCt::Accept(ModelVisitor* const visitor) const {
  visitor->BeginVisitConstraint(ModelVisitor::kElementEqual, this);
  visitor->VisitIntegerVariableArrayArgument(ModelVisitor::kVarsArgument,
                                             vars_);
  visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument, index_);
  visitor->VisitIntegerExpressionArgument(ModelVisitor::kTargetArgument,
                                          target_var_);
  visitor->EndVisitConstraint(ModelVisitor::kElementEqual, this);
}

// ----- IntExprArrayElementCstCt -----

// This constraint implements vars[index] == constant.

class IntExprArrayElementCstCt : public Constraint {
 public:
  IntExprArrayElementCstCt(Solver* const s, const std::vector<IntVar*>& vars,
                           IntVar* const index, int64_t target)
      : Constraint(s),
        vars_(vars),
        index_(index),
        target_(target),
        demons_(vars.size()) {}

  ~IntExprArrayElementCstCt() override {}

  void Post() override {
    for (int i = 0; i < vars_.size(); ++i) {
      demons_[i] = MakeConstraintDemon1(
          solver(), this, &IntExprArrayElementCstCt::Propagate, "Propagate", i);
      vars_[i]->WhenDomain(demons_[i]);
    }
    Demon* const index_demon = MakeConstraintDemon0(
        solver(), this, &IntExprArrayElementCstCt::PropagateIndex,
        "PropagateIndex");
    index_->WhenBound(index_demon);
  }

  void InitialPropagate() override {
    for (int i = 0; i < vars_.size(); ++i) {
      Propagate(i);
    }
    PropagateIndex();
  }

  void Propagate(int index) {
    if (!vars_[index]->Contains(target_)) {
      index_->RemoveValue(index);
      demons_[index]->inhibit(solver());
    }
  }

  void PropagateIndex() {
    if (index_->Bound()) {
      vars_[index_->Min()]->SetValue(target_);
    }
  }

  std::string DebugString() const override {
    return absl::StrFormat("IntExprArrayElement([%s], %s) == %d",
                           JoinDebugStringPtr(vars_, ", "),
                           index_->DebugString(), target_);
  }

  void Accept(ModelVisitor* const visitor) const override {
    visitor->BeginVisitConstraint(ModelVisitor::kElementEqual, this);
    visitor->VisitIntegerVariableArrayArgument(ModelVisitor::kVarsArgument,
                                               vars_);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument,
                                            index_);
    visitor->VisitIntegerArgument(ModelVisitor::kTargetArgument, target_);
    visitor->EndVisitConstraint(ModelVisitor::kElementEqual, this);
  }

 private:
  const std::vector<IntVar*> vars_;
  IntVar* const index_;
  const int64_t target_;
  std::vector<Demon*> demons_;
};

// This constraint implements index == position(constant in vars).

class IntExprIndexOfCt : public Constraint {
 public:
  IntExprIndexOfCt(Solver* const s, const std::vector<IntVar*>& vars,
                   IntVar* const index, int64_t target)
      : Constraint(s),
        vars_(vars),
        index_(index),
        target_(target),
        demons_(vars_.size()),
        index_iterator_(index->MakeHoleIterator(true)) {}

  ~IntExprIndexOfCt() override {}

  void Post() override {
    for (int i = 0; i < vars_.size(); ++i) {
      demons_[i] = MakeConstraintDemon1(
          solver(), this, &IntExprIndexOfCt::Propagate, "Propagate", i);
      vars_[i]->WhenDomain(demons_[i]);
    }
    Demon* const index_demon = MakeConstraintDemon0(
        solver(), this, &IntExprIndexOfCt::PropagateIndex, "PropagateIndex");
    index_->WhenDomain(index_demon);
  }

  void InitialPropagate() override {
    for (int i = 0; i < vars_.size(); ++i) {
      if (!index_->Contains(i)) {
        vars_[i]->RemoveValue(target_);
      } else if (!vars_[i]->Contains(target_)) {
        index_->RemoveValue(i);
        demons_[i]->inhibit(solver());
      } else if (vars_[i]->Bound()) {
        index_->SetValue(i);
        demons_[i]->inhibit(solver());
      }
    }
  }

  void Propagate(int index) {
    if (!vars_[index]->Contains(target_)) {
      index_->RemoveValue(index);
      demons_[index]->inhibit(solver());
    } else if (vars_[index]->Bound()) {
      index_->SetValue(index);
    }
  }

  void PropagateIndex() {
    const int64_t oldmax = index_->OldMax();
    const int64_t vmin = index_->Min();
    const int64_t vmax = index_->Max();
    for (int64_t value = index_->OldMin(); value < vmin; ++value) {
      vars_[value]->RemoveValue(target_);
      demons_[value]->inhibit(solver());
    }
    for (const int64_t value : InitAndGetValues(index_iterator_)) {
      vars_[value]->RemoveValue(target_);
      demons_[value]->inhibit(solver());
    }
    for (int64_t value = vmax + 1; value <= oldmax; ++value) {
      vars_[value]->RemoveValue(target_);
      demons_[value]->inhibit(solver());
    }
    if (index_->Bound()) {
      vars_[index_->Min()]->SetValue(target_);
    }
  }

  std::string DebugString() const override {
    return absl::StrFormat("IntExprIndexOf([%s], %s) == %d",
                           JoinDebugStringPtr(vars_, ", "),
                           index_->DebugString(), target_);
  }

  void Accept(ModelVisitor* const visitor) const override {
    visitor->BeginVisitConstraint(ModelVisitor::kIndexOf, this);
    visitor->VisitIntegerVariableArrayArgument(ModelVisitor::kVarsArgument,
                                               vars_);
    visitor->VisitIntegerExpressionArgument(ModelVisitor::kIndexArgument,
                                            index_);
    visitor->VisitIntegerArgument(ModelVisitor::kTargetArgument, target_);
    visitor->EndVisitConstraint(ModelVisitor::kIndexOf, this);
  }

 private:
  const std::vector<IntVar*> vars_;
  IntVar* const index_;
  const int64_t target_;
  std::vector<Demon*> demons_;
  IntVarIterator* const index_iterator_;
};

// Factory helper.

Constraint* MakeElementEqualityFunc(Solver* const solver,
                                    const std::vector<int64_t>& vals,
                                    IntVar* const index, IntVar* const target) {
  if (index->Bound()) {
    const int64_t val = index->Min();
    if (val < 0 || val >= vals.size()) {
      return solver->MakeFalseConstraint();
    } else {
      return solver->MakeEquality(target, vals[val]);
    }
  } else {
    if (IsIncreasingContiguous(vals)) {
      return solver->MakeEquality(target, solver->MakeSum(index, vals[0]));
    } else {
      return solver->RevAlloc(
          new IntElementConstraint(solver, vals, index, target));
    }
  }
}
}  // namespace

Constraint* Solver::MakeIfThenElseCt(IntVar* const condition,
                                     IntExpr* const then_expr,
                                     IntExpr* const else_expr,
                                     IntVar* const target_var) {
  return RevAlloc(
      new IfThenElseCt(this, condition, then_expr, else_expr, target_var));
}

IntExpr* Solver::MakeElement(const std::vector<IntVar*>& vars,
                             IntVar* const index) {
  if (index->Bound()) {
    return vars[index->Min()];
  }
  const int size = vars.size();
  if (AreAllBound(vars)) {
    std::vector<int64_t> values(size);
    for (int i = 0; i < size; ++i) {
      values[i] = vars[i]->Value();
    }
    return MakeElement(values, index);
  }
  if (index->Size() == 2 && index->Min() + 1 == index->Max() &&
      index->Min() >= 0 && index->Max() < vars.size()) {
    // Let's get the index between 0 and 1.
    IntVar* const scaled_index = MakeSum(index, -index->Min())->Var();
    IntVar* const zero = vars[index->Min()];
    IntVar* const one = vars[index->Max()];
    const std::string name = absl::StrFormat(
        "ElementVar([%s], %s)", JoinNamePtr(vars, ", "), index->name());
    IntVar* const target = MakeIntVar(std::min(zero->Min(), one->Min()),
                                      std::max(zero->Max(), one->Max()), name);
    AddConstraint(
        RevAlloc(new IfThenElseCt(this, scaled_index, one, zero, target)));
    return target;
  }
  int64_t emin = std::numeric_limits<int64_t>::max();
  int64_t emax = std::numeric_limits<int64_t>::min();
  std::unique_ptr<IntVarIterator> iterator(index->MakeDomainIterator(false));
  for (const int64_t index_value : InitAndGetValues(iterator.get())) {
    if (index_value >= 0 && index_value < size) {
      emin = std::min(emin, vars[index_value]->Min());
      emax = std::max(emax, vars[index_value]->Max());
    }
  }
  const std::string vname =
      size > 10 ? absl::StrFormat("ElementVar(var array of size %d, %s)", size,
                                  index->DebugString())
                : absl::StrFormat("ElementVar([%s], %s)",
                                  JoinNamePtr(vars, ", "), index->name());
  IntVar* const element_var = MakeIntVar(emin, emax, vname);
  AddConstraint(
      RevAlloc(new IntExprArrayElementCt(this, vars, index, element_var)));
  return element_var;
}

IntExpr* Solver::MakeElement(Int64ToIntVar vars, int64_t range_start,
                             int64_t range_end, IntVar* argument) {
  const std::string index_name =
      !argument->name().empty() ? argument->name() : argument->DebugString();
  const std::string vname = absl::StrFormat(
      "ElementVar(%s, %s)",
      StringifyInt64ToIntVar(vars, range_start, range_end), index_name);
  IntVar* const element_var =
      MakeIntVar(std::numeric_limits<int64_t>::min(),
                 std::numeric_limits<int64_t>::max(), vname);
  IntExprEvaluatorElementCt* evaluation_ct = new IntExprEvaluatorElementCt(
      this, std::move(vars), range_start, range_end, argument, element_var);
  AddConstraint(RevAlloc(evaluation_ct));
  evaluation_ct->Propagate();
  return element_var;
}

Constraint* Solver::MakeElementEquality(const std::vector<int64_t>& vals,
                                        IntVar* const index,
                                        IntVar* const target) {
  return MakeElementEqualityFunc(this, vals, index, target);
}

Constraint* Solver::MakeElementEquality(const std::vector<int>& vals,
                                        IntVar* const index,
                                        IntVar* const target) {
  return MakeElementEqualityFunc(this, ToInt64Vector(vals), index, target);
}

Constraint* Solver::MakeElementEquality(const std::vector<IntVar*>& vars,
                                        IntVar* const index,
                                        IntVar* const target) {
  if (AreAllBound(vars)) {
    std::vector<int64_t> values(vars.size());
    for (int i = 0; i < vars.size(); ++i) {
      values[i] = vars[i]->Value();
    }
    return MakeElementEquality(values, index, target);
  }
  if (index->Bound()) {
    const int64_t val = index->Min();
    if (val < 0 || val >= vars.size()) {
      return MakeFalseConstraint();
    } else {
      return MakeEquality(target, vars[val]);
    }
  } else {
    if (target->Bound()) {
      return RevAlloc(
          new IntExprArrayElementCstCt(this, vars, index, target->Min()));
    } else {
      return RevAlloc(new IntExprArrayElementCt(this, vars, index, target));
    }
  }
}

Constraint* Solver::MakeElementEquality(const std::vector<IntVar*>& vars,
                                        IntVar* const index, int64_t target) {
  if (AreAllBound(vars)) {
    std::vector<int> valid_indices;
    for (int i = 0; i < vars.size(); ++i) {
      if (vars[i]->Value() == target) {
        valid_indices.push_back(i);
      }
    }
    return MakeMemberCt(index, valid_indices);
  }
  if (index->Bound()) {
    const int64_t pos = index->Min();
    if (pos >= 0 && pos < vars.size()) {
      IntVar* const var = vars[pos];
      return MakeEquality(var, target);
    } else {
      return MakeFalseConstraint();
    }
  } else {
    return RevAlloc(new IntExprArrayElementCstCt(this, vars, index, target));
  }
}

Constraint* Solver::MakeIndexOfConstraint(const std::vector<IntVar*>& vars,
                                          IntVar* const index, int64_t target) {
  if (index->Bound()) {
    const int64_t pos = index->Min();
    if (pos >= 0 && pos < vars.size()) {
      IntVar* const var = vars[pos];
      return MakeEquality(var, target);
    } else {
      return MakeFalseConstraint();
    }
  } else {
    return RevAlloc(new IntExprIndexOfCt(this, vars, index, target));
  }
}

IntExpr* Solver::MakeIndexExpression(const std::vector<IntVar*>& vars,
                                     int64_t value) {
  IntExpr* const cache = model_cache_->FindVarArrayConstantExpression(
      vars, value, ModelCache::VAR_ARRAY_CONSTANT_INDEX);
  if (cache != nullptr) {
    return cache->Var();
  } else {
    const std::string name =
        absl::StrFormat("Index(%s, %d)", JoinNamePtr(vars, ", "), value);
    IntVar* const index = MakeIntVar(0, vars.size() - 1, name);
    AddConstraint(MakeIndexOfConstraint(vars, index, value));
    model_cache_->InsertVarArrayConstantExpression(
        index, vars, value, ModelCache::VAR_ARRAY_CONSTANT_INDEX);
    return index;
  }
}
}  // namespace operations_research