bin-packing.cpp

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.dev>
 *
 *  Copyright:
 *     Christian Schulte, 2010
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.dev
 *
 *  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 "test/int.hh"
 
#include <gecode/minimodel.hh>
#include <climits>
 
namespace Test { namespace Int {

  namespace BinPacking {


    class LoadBinAssignment : public Assignment {
    protected:
      int n_bins;
      int n_items;
      Gecode::IntSet d_load;
      Gecode::IntSet d_bin;
      int load;
      Gecode::IntSetValues* dsv;
    public:
      LoadBinAssignment(int m, const Gecode::IntSet& d_m,
                        int n, const Gecode::IntSet& d_n,
                        int l)
        : Assignment(m+n,d_m),
          n_bins(m), n_items(n), d_load(d_m), d_bin(d_n), load(l),
          dsv(new Gecode::IntSetValues[static_cast<unsigned int>(m+n)]) {
        for (int i=n_bins; i--; )
          dsv[i].init(d_load);
        for (int i=n_items; i--; )
          dsv[n_bins+i].init(d_bin);
      }

      virtual bool has_more(void) const {
        return dsv[0]();
      }

      virtual void next(Gecode::Support::RandomGenerator&) {
        // Try to generate next bin assignment
        {
          int i = n_items-1;
          while (i >= 0) {
            ++dsv[n_bins+i];
            if (dsv[n_bins+i]())
              return;
            dsv[n_bins+(i--)].init(d_bin);
          }
        }
        // Try to generate next load assignment
        {
        retry:
          int i = n_bins-1;
          while (true) {
            ++dsv[i];
            if (dsv[i]() || (i == 0)) {
              if (dsv[i]() && (load >= 0)) {
                int l = 0;
                for (int k=0;k<n_bins; k++)
                  l += dsv[k].val();
                if (load != l)
                  goto retry;
              }
              return;
            }
            dsv[i--].init(d_load);
          }
        }
      }

      virtual int operator[](int i) const {
        assert((i>=0) && (i<n_bins+n_items));
        return dsv[i].val();
      }

      virtual ~LoadBinAssignment(void) {
        delete [] dsv;
      }
    };

    class BPT : public Test {
    protected:
      int m;
      Gecode::IntArgs s;
      bool valid;
      int t;
      mutable int il[8];
      static int total(const Gecode::IntArgs& s) {
        int t = 0;
        for (int i=s.size(); i--; )
          t += s[i];
        return t;
      }
    public:
      BPT(int m0, const Gecode::IntArgs& s0, bool v=true)
        : Test("BinPacking::"+str(m0)+"::"+str(s0)+"::"+(v ? "+" : "-"),
               m0+s0.size(), 0, 100),
          m(m0), s(s0), valid(v), t(total(s)) {
        testsearch = false;
      }

      virtual Assignment* assignment(void) const {
        // Compute plausible bin sizes
        int a = t / m;
        return new LoadBinAssignment(m,Gecode::IntSet(a-1,a+2),
                                     s.size(),Gecode::IntSet(0,m-1),
                                     valid ? t : -1);
      }

      virtual bool solution(const Assignment& x) const {
        // Loads are from 0 to m-1, after that are items
        // Check whether loads sum up to total size
        int l=0;
        for (int j=m; j--; )
          l += x[j];
        if (l != t)
          return false;
        // Check whether items are at possible bins
        for (int j=m; j--; )
          if ((x[m+j] < 0) || (x[m+j] >= m))
            return false;
        // Compute whether items add up
        for (int j=m; j--; )
          il[j] = 0;
        for (int i=s.size(); i--; )
          il[x[m+i]] += s[i];
        for (int j=m; j--; )
          if (il[j] != x[j])
            return false;
        return true;
      }

      virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
        using namespace Gecode;
        IntVarArgs l(m);
        IntVarArgs b(s.size());
        for (int j=m; j--; )
          l[j]=x[j];
        for (int i=s.size(); i--; )
          b[i]=x[m+i];
        binpacking(home, l, b, s);
      }
    };

    class MBPT : public Test {
    protected:
      int d;
      int m;
      Gecode::IntArgs s;
      Gecode::IntArgs c;
      mutable int il[4][8];
    public:
      MBPT(int d0, int m0,
           const Gecode::IntArgs& s0, const Gecode::IntArgs& c0)
        : Test("MultiBinPacking::"+str(d0)+"::"+str(m0)+"::"+
               str(s0)+"::"+str(c0), s0.size() / d0, 0, m0-1),
          d(d0), m(m0), s(s0), c(c0) {
        testsearch = false;
        testfix = false;
      }

      virtual bool solution(const Assignment& x) const {
        // x are the bin variables
        for (int k=d; k--; )
          for (int j=m; j--; )
            il[k][j] = 0;
        for (int k=d; k--; )
          for (int i=x.size(); i--; )
            il[k][x[i]] += s[i*d+k];
        for (int k=d; k--; )
          for (int j=m; j--; )
            if (il[k][j] > c[k])
              return false;
        return true;
      }

      virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
        using namespace Gecode;
        IntVarArgs l(d*m);
        for (int j=m*d; j--; )
          l[j]=IntVar(home, 0, Gecode::Int::Limits::max);
        binpacking(home, d, l, x, s, c);
      }
    };

    class CliqueMBPT : public Base {
    protected:
      int n_items;
      Gecode::IntArgs clique;
      class TestSpace : public Gecode::Space {
      public:
        // Constructor
        TestSpace(void) {}
        // Copy function
        virtual Gecode::Space* copy(void) {
          return nullptr;
        }
      };
    public:
      CliqueMBPT(const Gecode::IntArgs& c)
        : Base("Int::MultiBinPacking::Clique::"+Test::str(c)), clique(c) {}

      virtual bool run(void) {
        using namespace Gecode;
        TestSpace* home = new TestSpace;
        /*
         * Set up a multi-dimensional bin packing problems of dimension 2
         * where the item sizes in one dimension are all one but for some
         * random items and two in the other dimension if the item is
         * included in the clique  and where the capacity in both dimensions
         * is 3.
         */
        // Number of items
        int n_items = clique[clique.size()-1] + 1;
        // Capacity
        IntArgs c({3,3});
        // Item sizes
        IntArgs s(2*n_items);
        for (int i=2*n_items; i--; )
          s[i]=1;
        // Create some random conflicts
        for (int i=clique.size()-1; i--; )
          s[_rand(n_items)*2+0]=2;
        // Create conflicts corresponding to the clique
        for (int i=clique.size(); i--; )
          s[clique[i]*2+1]=2;
        // Load and bin variables
        IntVarArgs b(*home, n_items, 0, n_items-1);
        IntVarArgs l(*home, 2*n_items, 0, 3);
        IntSet mc = binpacking(*home, 2, l, b, s, c);
        if (home->status() == SS_FAILED) {
          delete home;
          return false;
        }
        if (static_cast<unsigned int>(clique.size()) != mc.size()) {
          delete home;
          return false;
        }
        for (int i=clique.size(); i--; )
          if (!mc.in(clique[i])) {
            delete home;
            return false;
          }
        delete home;
        return true;
      }
    };

    class DFFLowerBound : public Base {
    protected:
      class TestSpace : public Gecode::Space {
      public:
        TestSpace(void) {}
        virtual Gecode::Space* copy(void) {
          return nullptr;
        }
      };
    public:
      DFFLowerBound(void)
        : Base("Int::BinPacking::DFFLowerBound") {}

      virtual bool run(void) {
        using namespace Gecode;
        TestSpace* home = new TestSpace;
        IntVarArgs l(*home, 3, 0, 5);
        IntVarArgs b(*home, 6, 0, 2);
        IntArgs s({4,2,2,2,2,2});
        binpacking(*home, l, b, s, IPL_FULL);
        bool failed = home->status() == SS_FAILED;
        delete home;
        return failed;
      }
    };

    class PropagationLevels : public Base {
    protected:
      class TestSpace : public Gecode::Space {
      public:
        TestSpace(void) {}
        virtual Gecode::Space* copy(void) {
          return nullptr;
        }
      };

      bool check_case(int n_bins, int capacity, const Gecode::IntArgs& sizes,
                      const bool expected_failed[4]) const {
        using namespace Gecode;
        IntPropLevel const levels[] =
          {IPL_BASIC, IPL_DEF, IPL_ADVANCED, IPL_FULL};
        for (unsigned int i = 0; i < 4; i += 1) {
          TestSpace* home = new TestSpace;
          IntVarArgs l(*home, n_bins, 0, capacity);
          IntVarArgs b(*home, sizes.size(), 0, n_bins-1);
          binpacking(*home, l, b, sizes, levels[i]);
          bool failed = home->status() == SS_FAILED;
          delete home;
          if (failed != expected_failed[i])
            return false;
        }
        return true;
      }
    public:
      PropagationLevels(void)
        : Base("Int::BinPacking::PropagationLevels") {}

      virtual bool run(void) {
        using namespace Gecode;
        bool const advanced_failed[] = {false, true, true, true};
        bool const full_failed[] = {false, false, false, true};
        return
          check_case(3, 5, IntArgs({4,2,2,2,2,2}), advanced_failed) &&
          check_case(5, 35,
                     IntArgs({32,30,24,21,19,11,10,9,8,5,3}),
                     full_failed);
      }
    };

    class DFFLargeWeights : public Base {
    protected:
      class TestSpace : public Gecode::Space {
      public:
        TestSpace(void) {}
        virtual Gecode::Space* copy(void) {
          return nullptr;
        }
      };
    public:
      DFFLargeWeights(void)
        : Base("Int::BinPacking::DFFLargeWeights") {}

      virtual bool run(void) {
        using namespace Gecode;
        {
          TestSpace* home = new TestSpace;
          IntVarArgs l(*home, 2, 0, Gecode::Int::Limits::max);
          IntVarArgs b(*home, 1, 0, 1);
          IntArgs s({Gecode::Int::Limits::max});
          binpacking(*home, l, b, s);
          bool failed = home->status() == SS_FAILED;
          delete home;
          if (failed)
            return false;
        }
        {
          TestSpace* home = new TestSpace;
          int c = Gecode::Int::Limits::max / 2;
          IntVarArgs l(*home, 2, 0, c);
          IntVarArgs b(*home, 1, 0, 1);
          IntArgs s({c});
          binpacking(*home, l, b, s);
          bool failed = home->status() == SS_FAILED;
          delete home;
          if (failed)
            return false;
        }
        {
          TestSpace* home = new TestSpace;
          IntVarArgs l(*home, 2, 0, 1100000000);
          IntVarArgs b(*home, 2, 0, 1);
          IntArgs s({1000000000,1000000000});
          binpacking(*home, l, b, s);
          bool failed = home->status() == SS_FAILED;
          delete home;
          return !failed;
        }
      }
    };

    class Create {
    public:
      Create(void) {
        using namespace Gecode;
 
        {
          IntArgs s0({0,0,0,0});
          IntArgs s1({2,1,1});
          IntArgs s2({1,2,3,4});
          IntArgs s3({4,3,2,1});
          IntArgs s4({1,2,4,8});
          IntArgs s5({1,1,1,1});
          IntArgs s6({1,1,2,2});
          IntArgs s7({1,3,3,4});
          IntArgs s8({1,3,3,0,4,0});
          IntArgs s9({1,2,4,8,16,32});
 
          for (int m=1; m<4; m++) {
            (void) new BPT(m, s0);
            (void) new BPT(m, s1);
            (void) new BPT(m, s2);
            (void) new BPT(m, s3);
            (void) new BPT(m, s4);
            (void) new BPT(m, s5);
            (void) new BPT(m, s6);
            (void) new BPT(m, s7);
            (void) new BPT(m, s8);
            (void) new BPT(m, s9);
            (void) new BPT(m, s1, false);
          }
        }
 
        {
          IntArgs s1({1,2, 2,1, 1,2, 2,1});
          IntArgs c1({3,3});
          (void) new MBPT(2, 4, s1, c1);
          (void) new MBPT(2, 6, s1, c1);
          IntArgs s2({1,1, 1,1, 1,1});
          IntArgs c21({1,1});
          IntArgs c22({2,2});
          (void) new MBPT(2, 6, s2, c21);
          (void) new MBPT(2, 6, s2, c22);
          IntArgs s3({1,2,3, 3,2,1, 2,1,3, 1,3,2});
          IntArgs c31({3,3,3});
          IntArgs c32({4,4,4});
          IntArgs c33({6,6,6});
          (void) new MBPT(3, 4, s3, c31);
          (void) new MBPT(3, 4, s3, c32);
          (void) new MBPT(3, 4, s3, c33);
          (void) new MBPT(3, 5, s3, c31);
          (void) new MBPT(3, 5, s3, c32);
          (void) new MBPT(3, 5, s3, c33);
        }
 
        {
          IntArgs c1({0,2,4,6});
          IntArgs c2({1,2,3,4,5,6,7,8});
          IntArgs c3({1,3,7,10,15,22,27,97});
          IntArgs c41({1,2,3,4,5,6,7,14});
          IntArgs c42({1,2,3,4,5,6,7,15});
          IntArgs c43({1,2,3,4,5,6,7,16});
          IntArgs c44({1,2,3,4,5,6,7,30});
          IntArgs c45({1,2,3,4,5,6,7,31});
          IntArgs c46({1,2,3,4,5,6,7,32});
          IntArgs c47({1,2,3,4,5,6,7,62});
          IntArgs c48({1,2,3,4,5,6,7,63});
          IntArgs c49({1,2,3,4,5,6,7,64});
 
          (void) new CliqueMBPT(c1);
          (void) new CliqueMBPT(c2);
          (void) new CliqueMBPT(c3);
          (void) new CliqueMBPT(c41);
          (void) new CliqueMBPT(c42);
          (void) new CliqueMBPT(c43);
          (void) new CliqueMBPT(c44);
          (void) new CliqueMBPT(c45);
          (void) new CliqueMBPT(c46);
          (void) new CliqueMBPT(c47);
          (void) new CliqueMBPT(c48);
          (void) new CliqueMBPT(c49);
        }
 
        (void) new DFFLowerBound;
        (void) new PropagationLevels;
        (void) new DFFLargeWeights;
      }
    };
 
    Create c;

 
  }
 
}}
 
 
// STATISTICS: test-int