gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.1.1/gecode/int/arithmetic/mult.icc

@@ -1,522 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-/*
- *  Main authors:
- *     Christian Schulte <schulte@gecode.org>
- *
- *  Copyright:
- *     Christian Schulte, 2004
- *
- *  Last modified:
- *     $Date: 2008-02-25 00:16:01 +0100 (Mon, 25 Feb 2008) $ by $Author: schulte $
- *     $Revision: 6288 $
- *
- *  This file is part of Gecode, the generic constraint
- *  development environment:
- *     http://www.gecode.org
- *
- *  Permission is hereby granted, free of charge, to any person obtaining
- *  a copy of this software and associated documentation files (the
- *  "Software"), to deal in the Software without restriction, including
- *  without limitation the rights to use, copy, modify, merge, publish,
- *  distribute, sublicense, and/or sell copies of the Software, and to
- *  permit persons to whom the Software is furnished to do so, subject to
- *  the following conditions:
- *
- *  The above copyright notice and this permission notice shall be
- *  included in all copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-
-#include <cmath>
-#include <climits>
-
-namespace Gecode { namespace Int { namespace Arithmetic {
-
-  /*
-   * Arithmetic help functions
-   *
-   */
-
-  /// Multiply \a x and \a y as type \a Val
-  template<class Val>
-  Val m(int x, int y);
-
-  template<>
-  forceinline double
-  m(int x, int y) {
-    return static_cast<double>(x)*static_cast<double>(y);
-  }
-
-  template<>
-  forceinline int
-  m(int x, int y) {
-    return x*y;
-  }
-
-  /// Compute \f$\lceil x/y\rceil\f$ where \a x and \a y are non-negative
-  template<class Val>
-  int c_d_p(int x, int y);
-  /// Compute \f$\lfloor x/y\rfloor\f$ where \a x and \a y are non-negative
-  template<class Val>
-  int f_d_p(int x, int y);
-
-  template <>
-  forceinline int
-  c_d_p<int>(int x, int y) {
-    assert((x >= 0) && (y >= 0));
-    return (x+y-1)/y;
-  }
-  template <>
-  forceinline int
-  c_d_p<double>(int x, int y) {
-    assert((x >= 0) && (y >= 0));
-    return static_cast<int>(ceil(static_cast<double>(x) /
-                                 static_cast<double>(y)));
-  }
-  template <>
-  forceinline int
-  f_d_p<int>(int x, int y) {
-    assert((x >= 0) && (y >= 0));
-    return x/y;
-  }
-  template <>
-  forceinline int
-  f_d_p<double>(int x, int y) {
-    assert((x >= 0) && (y >= 0));
-    return static_cast<int>(floor(static_cast<double>(x) /
-                                  static_cast<double>(y)));
-  }
-
-
-  /// Compute \f$\lfloor x/y\rfloor\f$
-  forceinline int
-  f_d(int x, int y) {
-    return static_cast<int>(floor(static_cast<double>(x) /
-                                  static_cast<double>(y)));
-  }
-
-  /// Compute \f$\lceil x/y\rceil\f$
-  forceinline int
-  c_d(int x, int y) {
-    return static_cast<int>(ceil(static_cast<double>(x) /
-                                 static_cast<double>(y)));
-  }
-
-  /// Test whether \a x is postive
-  template <class View>
-  forceinline bool
-  p(const View& x) {
-    return x.min() > 0;
-  }
-  /// Test whether \a x is negative
-  template <class View>
-  forceinline bool
-  n(const View& x) {
-    return x.max() < 0;
-  }
-  /// Test whether \a x is neither positive nor negative
-  template <class View>
-  forceinline bool
-  x(const View& x) {
-    return (x.min() <= 0) && (x.max() >= 0);
-  }
-
-
-  /*
-   * Propagator for x * y = x
-   *
-   */
-
-  template <class View>
-  forceinline
-  MultZeroOne<View>::MultZeroOne(Space* home, View x0, View x1)
-    : BinaryPropagator<View,PC_INT_BND>(home,x0,x1) {}
-
-  template <class View>
-  forceinline ExecStatus
-  MultZeroOne<View>::post(Space* home, View x0, View x1) {
-    switch (rtest_eq_bnd(x0,0)) {
-    case RT_FALSE:
-      GECODE_ME_CHECK(x1.eq(home,1)); 
-      break;
-    case RT_TRUE:
-      break;
-    case RT_MAYBE:
-      switch (rtest_eq_bnd(x1,1)) {
-      case RT_FALSE:
-        GECODE_ME_CHECK(x0.eq(home,0)); 
-        break;
-      case RT_TRUE:
-        break;
-      case RT_MAYBE:
-        (void) new (home) MultZeroOne<View>(home,x0,x1); 
-        break;
-      default: GECODE_NEVER;
-      }
-      break;
-    default: GECODE_NEVER;
-    }
-    return ES_OK;
-  }
-
-  template <class View>
-  forceinline void
-  MultZeroOne<View>::post(Space* home, Reflection::VarMap& vars,
-                     const Reflection::ActorSpec& spec) {
-     spec.checkArity(2);
-     View x0(home, vars, spec[0]);
-     View x1(home, vars, spec[1]);
-     (void) new (home) MultZeroOne<View>(home,x0,x1);
-  }
-
-  template <class View>
-  forceinline
-  MultZeroOne<View>::MultZeroOne(Space* home, bool share, MultZeroOne<View>& p)
-    : BinaryPropagator<View,PC_INT_BND>(home,share,p) {}
-
-  template <class View>
-  Actor*
-  MultZeroOne<View>::copy(Space* home, bool share) {
-    return new (home) MultZeroOne<View>(home,share,*this);
-  }
-
-  template <class View>
-  ExecStatus
-  MultZeroOne<View>::propagate(Space* home, ModEventDelta) {
-    switch (rtest_eq_bnd(x0,0)) {
-    case RT_FALSE:
-      GECODE_ME_CHECK(x1.eq(home,1)); 
-      break;
-    case RT_TRUE:
-      break;
-    case RT_MAYBE:
-      switch (rtest_eq_bnd(x1,1)) {
-      case RT_FALSE:
-        GECODE_ME_CHECK(x0.eq(home,0)); 
-        break;
-      case RT_TRUE:
-        break;
-      case RT_MAYBE:
-        return ES_FIX;
-      default: GECODE_NEVER;
-      }
-      break;
-    default: GECODE_NEVER;
-    }
-    return ES_SUBSUMED(this,home);
-  }
-
-  template <class View>
-  Support::Symbol
-  MultZeroOne<View>::ati(void) {
-    return Reflection::mangle<View>("Gecode::Int::Arithmetic::MultZeroOne");
-  }
-
-  template <class View>
-  Reflection::ActorSpec
-  MultZeroOne<View>::spec(const Space* home, Reflection::VarMap& m) const {
-    return BinaryPropagator<View,PC_INT_BND>::spec(home, m, ati());
-  }
-
-
-  /*
-   * Positive bounds-consistent multiplication
-   *
-   */
-  template <class Val, class VA, class VB, class VC>
-  forceinline
-  MultPlus<Val,VA,VB,VC>::MultPlus(Space* home, VA x0, VB x1, VC x2)
-    : MixTernaryPropagator<VA,PC_INT_BND,VB,PC_INT_BND,VC,PC_INT_BND>
-  (home,x0,x1,x2) {}
-
-  template <class Val, class VA, class VB, class VC>
-  forceinline
-  MultPlus<Val,VA,VB,VC>::MultPlus(Space* home, bool share, 
-                                   MultPlus<Val,VA,VB,VC>& p)
-    : MixTernaryPropagator<VA,PC_INT_BND,VB,PC_INT_BND,VC,PC_INT_BND>
-  (home,share,p) {}
-
-  template <class Val, class VA, class VB, class VC>
-  Actor*
-  MultPlus<Val,VA,VB,VC>::copy(Space* home, bool share) {
-    return new (home) MultPlus<Val,VA,VB,VC>(home,share,*this);
-  }
-
-  template <class Val, class VA, class VB, class VC>
-  ExecStatus
-  MultPlus<Val,VA,VB,VC>::propagate(Space* home, ModEventDelta) {
-    assert(p(x0) && p(x1) && p(x2));
-    bool mod;
-    do {
-      mod = false;
-      {
-        ModEvent me = x2.lq(home,m<Val>(x0.max(),x1.max()));
-        if (me_failed(me)) return ES_FAILED;
-        mod |= me_modified(me);
-      }
-      {
-        ModEvent me = x2.gq(home,m<Val>(x0.min(),x1.min()));
-        if (me_failed(me)) return ES_FAILED;
-        mod |= me_modified(me);
-      }
-      {
-        ModEvent me = x0.lq(home,f_d_p<Val>(x2.max(),x1.min()));
-        if (me_failed(me)) return ES_FAILED;
-        mod |= me_modified(me);
-      }
-      {
-        ModEvent me = x0.gq(home,c_d_p<Val>(x2.min(),x1.max()));
-        if (me_failed(me)) return ES_FAILED;
-        mod |= me_modified(me);
-      }
-      {
-        ModEvent me = x1.lq(home,f_d_p<Val>(x2.max(),x0.min()));
-        if (me_failed(me)) return ES_FAILED;
-        mod |= me_modified(me);
-      }
-      {
-        ModEvent me = x1.gq(home,c_d_p<Val>(x2.min(),x0.max()));
-        if (me_failed(me)) return ES_FAILED;
-        mod |= me_modified(me);
-      }
-    } while (mod);
-    return x0.assigned() && x1.assigned() ? 
-      ES_SUBSUMED(this,sizeof(*this)) : ES_FIX;
-  }
-
-  template <class Val, class VA, class VB, class VC>
-  forceinline ExecStatus
-  MultPlus<Val,VA,VB,VC>::post(Space* home, VA x0, VB x1, VC x2) {
-    GECODE_ME_CHECK(x0.gr(home,0));
-    GECODE_ME_CHECK(x1.gr(home,0));
-    GECODE_ME_CHECK(x2.gr(home,0));
-    double l = static_cast<double>(x0.max()) * static_cast<double>(x1.max());
-    if (l > INT_MAX) {
-      (void) new (home) MultPlus<double,VA,VB,VC>(home,x0,x1,x2);
-    } else {
-      (void) new (home) MultPlus<int,VA,VB,VC>(home,x0,x1,x2);
-    }
-    return ES_OK;
-  }
-
-  template <class Val, class VA, class VB, class VC>
-  forceinline void
-  MultPlus<Val,VA,VB,VC>::post(Space* home, Reflection::VarMap& vars,
-                               const Reflection::ActorSpec& spec) {
-     spec.checkArity(3);
-     VA x0(home, vars, spec[0]);
-     VB x1(home, vars, spec[1]);
-     VC x2(home, vars, spec[2]);
-     (void) new (home) MultPlus<Val,VA,VB,VC>(home,x0,x1,x2);
-  }
-
-  template <class Val, class VA, class VB, class VC>
-  Support::Symbol
-  MultPlus<Val,VA,VB,VC>::ati(void) {
-    return Reflection::mangle<VA,VB,VC,Val>("Gecode::Int::Arithmetic::MultPlus");
-  }
-
-  template <class Val, class VA, class VB, class VC>
-  Reflection::ActorSpec
-  MultPlus<Val,VA,VB,VC>::spec(const Space* home,
-                               Reflection::VarMap& m) const {
-    return MixTernaryPropagator<VA,PC_INT_BND,VB,PC_INT_BND,VC,PC_INT_BND>
-      ::spec(home, m, ati());
-  }
-
-  /*
-   * Bounds-consistent multiplication
-   *
-   */
-
-  template <class View>
-  forceinline
-  Mult<View>::Mult(Space* home, View x0, View x1, View x2)
-    : TernaryPropagator<View,PC_INT_BND>(home,x0,x1,x2) {}
-
-  template <class View>
-  forceinline
-  Mult<View>::Mult(Space* home, bool share, Mult<View>& p)
-    : TernaryPropagator<View,PC_INT_BND>(home,share,p) {}
-
-  template <class View>
-  Actor*
-  Mult<View>::copy(Space* home, bool share) {
-    return new (home) Mult<View>(home,share,*this);
-  }
-
-  template <class View>
-  PropCost
-  Mult<View>::cost(ModEventDelta) const {
-    return PC_TERNARY_HI;
-  }
-
-  template <class View>
-  ExecStatus
-  Mult<View>::propagate(Space* home, ModEventDelta) {
-    if (p(x0)) {
-      if (p(x1) || p(x2)) goto rewrite_ppp;
-      if (n(x1) || n(x2)) goto rewrite_pnn;
-      goto prop_pxx;
-    }
-    if (n(x0)) {
-      if (n(x1) || p(x2)) goto rewrite_nnp;
-      if (p(x1) || n(x2)) goto rewrite_npn;
-      goto prop_nxx;
-    }
-    if (p(x1)) {
-      if (p(x2)) goto rewrite_ppp;
-      if (n(x2)) goto rewrite_npn;
-      goto prop_xpx;
-    }
-    if (n(x1)) {
-      if (p(x2)) goto rewrite_nnp;
-      if (n(x2)) goto rewrite_pnn;
-      goto prop_xnx;
-    }
-
-    assert(x(x0) && x(x1));
-    GECODE_ME_CHECK(x2.lq(home,std::max(m<double>(x0.max(),x1.max()),
-                                        m<double>(x0.min(),x1.min()))));
-    GECODE_ME_CHECK(x2.gq(home,std::min(m<double>(x0.min(),x1.max()),
-                                        m<double>(x0.max(),x1.min()))));
-
-    if (x0.assigned()) {
-      assert((x0.val() == 0) && (x2.val() == 0));
-      return ES_SUBSUMED(this,home);
-    }
-
-    if (x1.assigned()) {
-      assert((x1.val() == 0) && (x2.val() == 0));
-      return ES_SUBSUMED(this,home);
-    }
-
-    return ES_NOFIX;
-
-  prop_xpx:
-    std::swap(x0,x1);
-  prop_pxx:
-    assert(p(x0) && x(x1) && x(x2));
-
-    GECODE_ME_CHECK(x2.lq(home,m<double>(x0.max(),x1.max())));
-    GECODE_ME_CHECK(x2.gq(home,m<double>(x0.max(),x1.min())));
-
-    if (p(x2)) goto rewrite_ppp;
-    if (n(x2)) goto rewrite_pnn;
-
-    GECODE_ME_CHECK(x1.lq(home,f_d(x2.max(),x0.min())));
-    GECODE_ME_CHECK(x1.gq(home,c_d(x2.min(),x0.min())));
-
-    if (x0.assigned() && x1.assigned()) {
-      GECODE_ME_CHECK(x2.eq(home,m<double>(x0.val(),x1.val())));
-      return ES_SUBSUMED(this,sizeof(*this));
-    }
-
-    return ES_NOFIX;
-
-  prop_xnx:
-    std::swap(x0,x1);
-  prop_nxx:
-    assert(n(x0) && x(x1) && x(x2));
-
-    GECODE_ME_CHECK(x2.lq(home,m<double>(x0.min(),x1.min())));
-    GECODE_ME_CHECK(x2.gq(home,m<double>(x0.min(),x1.max())));
-
-    if (p(x2)) goto rewrite_nnp;
-    if (n(x2)) goto rewrite_npn;
-
-    GECODE_ME_CHECK(x1.lq(home,f_d(x2.min(),x0.max())));
-    GECODE_ME_CHECK(x1.gq(home,c_d(x2.max(),x0.max())));
-
-    if (x0.assigned() && x1.assigned()) {
-      GECODE_ME_CHECK(x2.eq(home,m<double>(x0.val(),x1.val())));
-      return ES_SUBSUMED(this,sizeof(*this));
-    }
-
-    return ES_NOFIX;
-
-  rewrite_ppp:
-    GECODE_REWRITE(this,(MultPlus<double,IntView,IntView,IntView>
-                         ::post(home,x0,x1,x2)));
-
-  rewrite_nnp:
-    GECODE_REWRITE(this,(MultPlus<double,MinusView,MinusView,IntView>
-                         ::post(home,x0,x1,x2)));
-
-  rewrite_pnn:
-    std::swap(x0,x1);
-  rewrite_npn:
-    GECODE_REWRITE(this,(MultPlus<double,MinusView,IntView,MinusView>
-                         ::post(home,x0,x1,x2)));
-  }
-
-  template <class View>
-  ExecStatus
-  Mult<View>::post(Space* home, View x0, View x1, View x2) {
-    if (same(x0,x1))
-      return Sqr<View>::post(home,x0,x2);
-    if (same(x0,x2))
-      return MultZeroOne<View>::post(home,x0,x1);
-    if (same(x1,x2))
-      return MultZeroOne<View>::post(home,x1,x0);
-    if (p(x0)) {
-      if (p(x1) || p(x2)) goto post_ppp;
-      if (n(x1) || n(x2)) goto post_pnn;
-    } else if (n(x0)) {
-      if (n(x1) || p(x2)) goto post_nnp;
-      if (p(x1) || n(x2)) goto post_npn;
-    } else if (p(x1)) {
-      if (p(x2)) goto post_ppp;
-      if (n(x2)) goto post_npn;
-    } else if (n(x1)) {
-      if (p(x2)) goto post_nnp;
-      if (n(x2)) goto post_pnn;
-    }
-    (void) new (home) Mult<View>(home,x0,x1,x2);
-    return ES_OK;
-
-  post_ppp:
-    return MultPlus<double,IntView,IntView,IntView>::post(home,x0,x1,x2);
-  post_nnp:
-    return MultPlus<double,MinusView,MinusView,IntView>::post(home,x0,x1,x2);
-  post_pnn:
-    std::swap(x0,x1);
-  post_npn:
-    return MultPlus<double,MinusView,IntView,MinusView>::post(home,x0,x1,x2);
-  }
-
-  template <class View>
-  forceinline void
-  Mult<View>::post(Space* home, Reflection::VarMap& vars,
-                   const Reflection::ActorSpec& spec) {
-     spec.checkArity(3);
-     View x0(home, vars, spec[0]);
-     View x1(home, vars, spec[1]);
-     View x2(home, vars, spec[2]);
-     (void) new (home) Mult<View>(home,x0,x1,x2);
-  }
-
-  template <class View>
-  Support::Symbol
-  Mult<View>::ati(void) {
-    return Reflection::mangle<View>("Gecode::Int::Arithmetic::Mult");
-  }
-
-  template <class View>
-  Reflection::ActorSpec
-  Mult<View>::spec(const Space* home, Reflection::VarMap& m) const {
-    return TernaryPropagator<View,PC_INT_BND>::spec(home, m, ati());
-  }
-
-}}}
-
-// STATISTICS: int-prop
-