using Gecode :Multiple Multidimensional Knapsack Problem (MMKP)

#ifdef _AFX_ENABLE_INLINES
#define _AFX_INLINE AFX_INLINE
 
#if !defined(_AFX_CORE_IMPL) || !defined(_AFXDLL) || defined(_DEBUG)
#define _AFX_PUBLIC_INLINE AFX_INLINE
#else
#define _AFX_PUBLIC_INLINE
#endif
#endif

public enum Options{find_Optimal_Solution, find_realizable_solution};

typedef CArray<bool,bool> CTruthArray;
typedef CPtrArray<uint*,uint*>CResultArray;


struct NODE // Declare NODE structure
{   
   UINT* R; //TESTED RAM VALUES
   UINT* C; //TESTED CPU VALUES
   UINT* B; //TESTED BAT VALUES
}

struct TEST //Declare TEST structure
{
   UINT* Dr; //Desired TEST Value for RAM
   UINT* Dc; //Desired TEST Value for CPU
   UINT* Db; //Desired TEST Value for BAT
}

struct MATRIX // row first, column second, as a 2D structure
{
   UINT* row;
   UINT* col;
}

class CMMKP : public Script, CObject
{
	DECLARE_DYNACREATE(CMMKP)
public:
// Construction
	CMMKP();

protected:
        int n;//number of testers
        int m;// number of nodes
        UINT* Gain; // objective variable
        UINT* R, C, B, Dr, Dc, Db, Gn, Lr;
        NODE node1, node2, node3;
        TEST test1, test2, test3;
        MATRIX matATruths;
        MATRIX matBTruths;
        MATRIX matResults;
 
        CTruthArray* Atruths; 
        CTruthArray* Btruths; 
        CUintArray* Kvalues;

        void Linear(MMKP* pMMKP, UINT index, UINT mode, UINT type);
        void GetSolution(Option& opt);
        void ApplyConstrains();
        void InitTruthArray();
        MATRIX GetMatrix(UINT** results);

public:
	~CMMKP();
	void Serialize(CArchive&);
#ifdef _DEBUG
	void Dump(CDumpContext&) const;
	void AssertValid() const;
#endif

}

CMMKP::CMMKP()
{
   Atruths = new CTruthArray();//Array of Boolean variables (0 or 1) or (FALSE or TRUE)
   Btruths = new CTruthArray();//Array of Boolean variables (0 or 1) or (FALSE or TRUE)
   Kvalues = new CUintArray();// Array of unsigned integers, values from 0 to 2^16 - 1
}

CMMKP::~CMMKP()
{
    if(Atruths != NULL)
       delete Atruths;
    if(Btruths != NULL)
       delete Btruths;
    if(Kvalues != NULL)
       delete Kvalues ;
}

void CMMKP::GetSolution(Option& opt)
{
//You will need to rewrite the code below to match what I've done so far
    switch (opt.model())
    {
        case find_Optimal_Solution:
        Gn = {4,20,30,40,50};
        //Objective function
        for (int i = 0; i < n; i++)
        {
            linear(*this, Gn, X.row(i), IRT_EQ, Gain);
        }
        for ( int i=0; i<n;i++)>
        {
             for ( int j =0; j<m;j++)>
             {
                 Results(i,j)=X(i,j);
             }
        }
        break;
        case find_realizable_solution:
        for ( int i=0; i<n;i++)>
        {
             for ( int j =0; j<m;j++)>
             {
                 Results(i,j)=X(i,j);
             }
        }
        break;
}

void CMMKP::Linear(MMKP* pMMKP, UINT index, UINT mode, UINT type)
{
//This is where you put the code for the linear function.
}

void MMKP::InitArrays()
{
    UINT num = n*m;
    Atruths->SetSize(num,-1);
//  IntVarArray a(*this,n*m,0,1); // Array of n*m boolean variables
    matATruths = GetMatrix(Atruths);// Matrix "view" of the array a

    Kvalues->SetSize(num,-1);
//  k=IntVarArray(*this,n*m ,0,100000);
    matResults = GetMatrix(Kvalues);// Matrix "view" of array k

    Btruths->SetSize(num,-1);
//  IntVarArray b(*this, m*n,0,1);
    matBTruths = GetMatrix(Btruths);// Matrix "view" of array b


    node1.R = {4,10,15,20,40};
    node1.C = {4,20,25,30,40};
    node1.B = {4,20,30,35,40};

    test1.Dr = {4,5,10,15,25};
    test1.Dc = {4,15,20,35,37};
    test1.Db = {4,10,15,20,35}; 
}

//creation of constraints
// ... over rows
void CMMKP::ApplyConstrains()
{
	for ( int j=0; j<n;j++)>
	{
	    linear(*this , X.row(j),IRT_EQ,1);
	}

	//... over columns
	// first, get the columns, we will use an intermidiare matrix XDual
		
	for (int i=0; i<m;i++)>
	{
	    for ( int j =0; j<n mode="hold" />	    {
	        XDual(i,j)=X(j,i);
	    }
	}

	for (int j = 0; j < m; j++)
         {
	     linear(*this, Dr,XDual.row(j),IRT_NQ, R[j]);
	}

	for (int j = 0; j < m; j++) 
         {
	     linear (*this, Dc, XDual.row(j), IRT_NQ,C[j]);
	}

	for (int j = 0; j < m; j++)
         {
	     linear (*this, Db, XDual.row(j), IRT_NQ,B[j]);
         }
}

/*		
// post branching
// branch(*this, a, INT_VAR_SIZE_MAX(), INT_VAL_MAX());
// search support

BOOL CMMKP::Share(MMKP& s, BOOL share):Script(share, s)
{
      a.update(*this, share, s.a);
}
 
virtual Space* CMMKP::Copy(BOOL share)
{
     return new MMKP(share,*this);
}
 
// print solution there is a better one available 
//     ON_COMMAND(ID_FILE_PRINT, &CEditView::OnFilePrint) as an example.  
//      You will need a 'view' to your data for this to work.

void print(std::ostream& os) const  {
		for(int i = 0; i < n; i++) {
		 for(int j = 0; j < n; j++)
           os << std::setw(4) << a[i * n + j];
		 os << std::endl;
	}
}
	};
*/