gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/int/view/int.icc

@@ -0,0 +1,221 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Int {
+
+  /*
+   * Constructors and initialization
+   *
+   */
+  forceinline
+  IntView::IntView(void) {}
+  forceinline
+  IntView::IntView(const IntVar& x)
+    : VariableViewBase<IntVarImp>(x.variable()) {}
+
+
+  /*
+   * Value access
+   *
+   */
+  forceinline int
+  IntView::min(void) const {
+    return var->min();
+  }
+  forceinline int
+  IntView::max(void) const {
+    return var->max();
+  }
+  forceinline int
+  IntView::med(void) const {
+    return var->med();
+  }
+  forceinline int
+  IntView::val(void) const {
+    return var->val();
+  }
+
+  forceinline unsigned int
+  IntView::size(void) const {
+    return var->size();
+  }
+  forceinline unsigned int
+  IntView::width(void) const {
+    return var->width();
+  }
+  forceinline unsigned int
+  IntView::regret_min(void) const {
+    return var->regret_min();
+  }
+  forceinline unsigned int
+  IntView::regret_max(void) const {
+    return var->regret_max();
+  }
+
+
+  /*
+   * Domain tests
+   *
+   */
+  forceinline bool
+  IntView::range(void) const {
+    return var->range();
+  }
+  forceinline bool
+  IntView::assigned(void) const {
+    return var->assigned();
+  }
+
+  forceinline bool
+  IntView::in(int n) const {
+    return var->in(n);
+  }
+  forceinline bool
+  IntView::in(double n) const {
+    return var->in(n);
+  }
+
+
+  /*
+   * Domain update by value
+   *
+   */
+  forceinline ModEvent
+  IntView::lq(Space* home, int n) {
+    return var->lq(home,n);
+  }
+  forceinline ModEvent
+  IntView::lq(Space* home, double n) {
+    return var->lq(home,n);
+  }
+
+  forceinline ModEvent
+  IntView::le(Space* home, int n) {
+    return var->lq(home,n-1);
+  }
+  forceinline ModEvent
+  IntView::le(Space* home, double n) {
+    return lq(home,n-1.0);
+  }
+
+  forceinline ModEvent
+  IntView::gq(Space* home, int n) {
+    return var->gq(home,n);
+  }
+  forceinline ModEvent
+  IntView::gq(Space* home, double n) {
+    return var->gq(home,n);
+  }
+
+  forceinline ModEvent
+  IntView::gr(Space* home, int n) {
+    return var->gq(home,n+1);
+  }
+  forceinline ModEvent
+  IntView::gr(Space* home, double n) {
+    return gq(home,n+1.0);
+  }
+
+  forceinline ModEvent
+  IntView::nq(Space* home, int n) {
+    return var->nq(home,n);
+  }
+  forceinline ModEvent
+  IntView::nq(Space* home, double n) {
+    return var->nq(home,n);
+  }
+
+  forceinline ModEvent
+  IntView::eq(Space* home, int n) {
+    return var->eq(home,n);
+  }
+  forceinline ModEvent
+  IntView::eq(Space* home, double n) {
+    return var->eq(home,n);
+  }
+
+
+  /*
+   * Domain update by range iterator
+   *
+   */
+  template <class I>
+  forceinline ModEvent
+  IntView::narrow(Space* home, I& i) {
+    return var->narrow(home,i);
+  }
+  template <class I>
+  forceinline ModEvent
+  IntView::inter(Space* home, I& i) {
+    return var->inter(home,i);
+  }
+  template <class I>
+  forceinline ModEvent
+  IntView::minus(Space* home, I& i) {
+    return var->minus(home,i);
+  }
+
+
+  /*
+   * Cloning
+   *
+   */
+  forceinline void
+  IntView::update(Space* home, bool share, IntView& x) {
+    var = x.var->copy(home,share);
+  }
+
+
+
+  /**
+   * \brief %Range iterator for integer variable views
+   * \ingroup TaskActorIntView
+   */
+  template <>
+  class ViewRanges<IntView> : public IntVarImpFwd {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    ViewRanges(void);
+    /// Initialize with ranges for view \a x
+    ViewRanges(const IntView& x);
+    /// Initialize with ranges for view \a x
+    void init(const IntView& x);
+    //@}
+  };
+
+  forceinline
+  ViewRanges<IntView>::ViewRanges(void) {}
+
+  forceinline
+  ViewRanges<IntView>::ViewRanges(const IntView& x)
+    : IntVarImpFwd(x.variable()) {}
+
+  forceinline void
+  ViewRanges<IntView>::init(const IntView& x) {
+    IntVarImpFwd::init(x.variable());
+  }
+
+}}
+
+// STATISTICS: int-var
+

data/ext/gecode-1.3.1/gecode/int/view/iter.icc

@@ -0,0 +1,49 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Int {
+
+  template <class View>
+  forceinline
+  ViewValues<View>::ViewValues(void) {}
+
+  template <class View>
+  forceinline
+  ViewValues<View>::ViewValues(const View& x) {
+    ViewRanges<View> r(x);
+    Iter::Ranges::ToValues<ViewRanges<View> >::init(r);
+  }
+
+  template <class View>
+  forceinline void
+  ViewValues<View>::init(const View& x) {
+    ViewRanges<View> r(x);
+    Iter::Ranges::ToValues<ViewRanges<View> >::init(r);
+  }
+
+}}
+
+// STATISTICS: int-var
+

data/ext/gecode-1.3.1/gecode/int/view/minus.icc

@@ -0,0 +1,285 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-24 11:25:05 +0200 (Thu, 24 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3559 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode {
+
+  namespace Int {
+
+    /*
+     * Constructors and initialization
+     *
+     */
+    forceinline
+    MinusView::MinusView(void) {}
+    forceinline
+    MinusView::MinusView(const IntView& x)
+      : DerivedViewBase<IntView>(x) {}
+    forceinline void
+    MinusView::init(const IntView& x) {
+      view = x;
+    }
+
+
+
+    /*
+     * Value access
+     *
+     */
+    forceinline int
+    MinusView::min(void) const {
+      return -view.max();
+    }
+    forceinline int
+    MinusView::max(void) const {
+      return -view.min();
+    }
+    forceinline int
+    MinusView::med(void) const {
+      return -view.med();
+    }
+    forceinline int
+    MinusView::val(void) const {
+      return -view.val();
+    }
+
+    forceinline unsigned int
+    MinusView::width(void) const {
+      return view.width();
+    }
+    forceinline unsigned int
+    MinusView::size(void) const {
+      return view.size();
+    }
+    forceinline unsigned int
+    MinusView::regret_min(void) const {
+      return view.regret_max();
+    }
+    forceinline unsigned int
+    MinusView::regret_max(void) const {
+      return view.regret_min();
+    }
+
+
+    /*
+     * Domain tests
+     *
+     */
+    forceinline bool
+    MinusView::range(void) const {
+      return view.range();
+    }
+    forceinline bool
+    MinusView::assigned(void) const {
+      return view.assigned();
+    }
+    forceinline bool
+    MinusView::in(int n) const {
+      return view.in(-n);
+    }
+    forceinline bool
+    MinusView::in(double n) const {
+      return view.in(-n);
+    }
+
+
+    /*
+     * Domain update by value
+     *
+     */
+    forceinline ModEvent
+    MinusView::lq(Space* home, int n) {
+      return view.gq(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::lq(Space* home, double n) {
+      return view.gq(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::le(Space* home, int n) {
+      return view.gr(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::le(Space* home, double n) {
+      return view.gr(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::gq(Space* home, int n) {
+      return view.lq(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::gq(Space* home, double n) {
+      return view.lq(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::gr(Space* home, int n) {
+      return view.le(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::gr(Space* home, double n) {
+      return view.le(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::nq(Space* home, int n) {
+      return view.nq(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::nq(Space* home, double n) {
+      return view.nq(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::eq(Space* home, int n) {
+      return view.eq(home,-n);
+    }
+    forceinline ModEvent
+    MinusView::eq(Space* home, double n) {
+      return view.eq(home,-n);
+    }
+
+
+
+    /*
+     * Domain update by range iterator
+     *
+     */
+    template <class I>
+    ModEvent
+    MinusView::narrow(Space* home, I& i) {
+      Iter::Ranges::Minus<I> mi(i); return view.narrow(home,mi);
+    }
+    template <class I>
+    ModEvent
+    MinusView::inter(Space* home, I& i) {
+      Iter::Ranges::Minus<I> mi(i); return view.inter(home,mi);
+    }
+    template <class I>
+    ModEvent
+    MinusView::minus(Space* home, I& i) {
+      Iter::Ranges::Minus<I> mi(i); return view.minus(home,mi);
+    }
+
+
+    /*
+     * Propagator modification events
+     *
+     */
+    forceinline ModEvent
+    MinusView::pme(const Propagator* p) {
+      return IntView::pme(p);
+    }
+    forceinline PropModEvent
+    MinusView::pme(ModEvent me) {
+      return IntView::pme(me);
+    }
+
+
+    /*
+     * Dependencies
+     *
+     */
+    forceinline void
+    MinusView::subscribe(Space* home, Propagator* p, PropCond pc, 
+			 bool process) {
+      view.subscribe(home,p,pc,process);
+    }
+    forceinline void
+    MinusView::cancel(Space* home, Propagator* p, PropCond pc) {
+      view.cancel(home,p,pc);
+    }
+
+
+    /*
+     * Cloning
+     *
+     */
+
+    forceinline void
+    MinusView::update(Space* home, bool share, MinusView& x) {
+      view.update(home,share,x.view);
+    }
+
+
+    /**
+     * \brief %Range iterator for minus integer views
+     * \ingroup TaskActorIntView
+     */
+    template <>
+    class ViewRanges<MinusView> : public IntVarImpBwd {
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      ViewRanges(void);
+      /// Initialize with ranges for view \a x
+      ViewRanges(const MinusView& x);
+      /// Initialize with ranges for view \a x
+      void init(const MinusView& x);
+      //@}
+
+      /// \name Range access
+      //@{
+      /// Return smallest value of range
+      int min(void) const;
+      /// Return largest value of range
+      int max(void) const;
+      //@}
+    };
+
+    forceinline
+    ViewRanges<MinusView>::ViewRanges(void) {}
+
+    forceinline
+    ViewRanges<MinusView>::ViewRanges(const MinusView& x)
+      : IntVarImpBwd(x.base().variable()) {}
+
+    forceinline void
+    ViewRanges<MinusView>::init(const MinusView& x) {
+      IntVarImpBwd::init(x.base().variable());
+    }
+
+    forceinline int
+    ViewRanges<MinusView>::min(void) const {
+      return -IntVarImpBwd::max();
+    }
+    forceinline int
+    ViewRanges<MinusView>::max(void) const {
+      return -IntVarImpBwd::min();
+    }
+
+  }
+
+
+  /*
+   * View comparison
+   *
+   */
+  forceinline bool
+  same(const Int::MinusView& x, const Int::MinusView& y) {
+    return same(x.base(),y.base());
+  }
+  forceinline bool
+  before(const Int::MinusView& x, const Int::MinusView& y) {
+    return before(x.base(),y.base());
+  }
+
+}
+
+// STATISTICS: int-var
+