| iodrvmem.c |
/*******************************************************
Mosel Example Problems
======================
file iodrvmem.c
```````````````
Using the IO driver `mem'.
- Model source included in application program -
(c) 2008 Fair Isaac Corporation
author: S. Heipcke, 2004, rev. Feb. 2017
********************************************************/
#include <stdio.h>
#include "xprm_mc.h"
/*****************************************************/
/* The source of the model as an array of characters */
/*****************************************************/
const char source_of_model[]=
"model Burglar\n"
"uses 'mmxprs'\n"
"declarations\n"
" WTMAX = 102 ! Maximum weight allowed\n"
" ITEMS = {'camera', 'necklace', 'vase', 'picture', 'tv', 'video', \n"
" 'chest', 'brick'} ! Index set for items\n"
" VALUE: array(ITEMS) of real ! Value of items\n"
" WEIGHT: array(ITEMS) of real ! Weight of items\n"
" take: array(ITEMS) of mpvar ! 1 if we take item i; 0 otherwise\n"
"end-declarations\n"
"VALUE::(['camera', 'necklace', 'vase', 'picture', 'tv', 'video',\n"
" 'chest', 'brick'])[15,100,90,60,40,15,10,1]\n"
"WEIGHT::(['camera', 'necklace', 'vase', 'picture', 'tv', 'video',\n"
" 'chest', 'brick'])[2,20,20,30,40,30,60,10]\n"
"! Objective: maximize total value\n"
"MaxVal:= sum(i in ITEMS) VALUE(i)*take(i)\n"
"! Weight restriction\n"
"sum(i in ITEMS) WEIGHT(i)*take(i) <= WTMAX\n"
"! All variables are 0/1\n"
"forall(i in ITEMS) take(i) is_binary\n"
"maximize(MaxVal) ! Solve the problem\n"
"! Print out the solution\n"
"writeln(\"Solution:\\n Objective: \", getobjval)\n"
"forall(i in ITEMS) writeln(' take(', i, '): ', getsol(take(i)))\n"
"end-model";
/*****************/
/* Main function */
/*****************/
int main()
{
XPRMmodel mod;
int result,i;
char bimfile[2000]; /* Buffer to store BIM file */
size_t bimfile_size; /* Buffer to store actual size of BIM file */
char mosfile_name[40]; /* File name of MOS file */
char bimfile_name[64]; /* File name of BIM file */
i=XPRMinit(); /* Initialize Mosel */
if((i!=0)&&(i!=32))
return 1;
/* Prepare file names for compilation using 'mem' driver: */
/* "mem:base address/size[/actual size pointer]" */
bimfile_size=0;
sprintf(mosfile_name, "mem:%p/%d",
source_of_model, (int)sizeof(source_of_model));
sprintf(bimfile_name, "mem:%p/%d/%p",
bimfile, (int)sizeof(bimfile), &bimfile_size);
/* Compile model from memory to memory */
if(XPRMcompmod(NULL, mosfile_name, bimfile_name, "Knapsack example"))
return 2;
printf("BIM file uses %lu bytes of memory.\n", bimfile_size);
/* Load a BIM file from memory */
if((mod=XPRMloadmod(bimfile_name, NULL))==NULL)
return 3;
if(XPRMrunmod(mod, &result, NULL)) /* Run the model */
return 4;
return 0;
}
|
|
| iodrvmem2.c |
/*******************************************************
Mosel Example Problems
======================
file iodrvmem2.c
````````````````
Using the IO driver `mem'.
- Model source in separate .mos file -
(c) 2008 Fair Isaac Corporation
author: S. Heipcke, 2004, rev. Feb. 2017
********************************************************/
#include <stdio.h>
#include "xprm_mc.h"
/*****************/
/* Main function */
/*****************/
int main()
{
XPRMmodel mod;
int result,i;
char bimfile[2000]; /* Buffer to store BIM file */
size_t bimfile_size; /* Buffer to store actual size of BIM file */
char bimfile_name[64]; /* File name of BIM file */
i=XPRMinit(); /* Initialize Mosel */
if((i!=0)&&(i!=32))
return 1;
/* Prepare file names for compilation using 'mem' driver: */
/* "mem:base address/size[/actual size pointer]" */
bimfile_size=0;
sprintf(bimfile_name, "mem:%p/%d/%p",
bimfile, (int)sizeof(bimfile), &bimfile_size);
/* Compile model file to memory */
if(XPRMcompmod(NULL, "burglar2.mos", bimfile_name, "Knapsack example"))
return 2;
printf("BIM file uses %lu bytes of memory.\n", bimfile_size);
/* Load a BIM file from memory */
if((mod=XPRMloadmod(bimfile_name, NULL))==NULL)
return 3;
if(XPRMrunmod(mod, &result, NULL)) /* Run the model */
return 4;
return 0;
}
|
|
| iodrvraw.c |
/*******************************************************
Mosel Example Problems
======================
file iodrvraw.c
```````````````
Using the IO drivers `raw' and `mem'.
- Model source included in application program -
(c) 2008 Fair Isaac Corporation
author: S. Heipcke, 2004, rev. Feb. 2017
********************************************************/
#include <stdio.h>
#include "xprm_mc.h"
/*****************************************************/
/* The source of the model as an array of characters */
/*****************************************************/
const char source_of_model[]=
"model Burglar2r\n"
"uses 'mmxprs'\n"
"parameters\n"
" DATA=''\n"
" SOL=''\n"
" WTMAX = 102 ! Maximum weight allowed\n"
"end-parameters\n"
"declarations\n"
" ITEMS: set of string ! Index set for items\n"
" VALUE: array(ITEMS) of real ! Value of items\n"
" WEIGHT: array(ITEMS) of real ! Weight of items\n"
" SOLTAKE: array(ITEMS) of real ! Solution values\n"
"end-declarations\n"
"initialisations from 'raw:'\n"
" [VALUE,WEIGHT] as DATA\n"
"end-initialisations\n"
"declarations\n"
" take: array(ITEMS) of mpvar ! 1 if we take item i; 0 otherwise\n"
"end-declarations\n"
"! Objective: maximize total value\n"
"MaxVal:= sum(i in ITEMS) VALUE(i)*take(i)\n"
"! Weight restriction\n"
"sum(i in ITEMS) WEIGHT(i)*take(i) <= WTMAX\n"
"! All variables are 0/1\n"
"forall(i in ITEMS) take(i) is_binary\n"
"maximize(MaxVal) ! Solve the problem\n"
"! Solution output\n"
"forall(i in ITEMS) SOLTAKE(i):= getsol(take(i))\n"
"writeln(\"Solution:\\n Objective: \", getobjval)\n"
"writeln(SOLTAKE)\n"
"initialisations to 'raw:'\n"
" SOLTAKE as SOL\n"
"end-initialisations\n"
"end-model";
const struct
{ /* Initial values for array 'data': */
const char *ind; /* index name */
double val,wght; /* value and weight data entries */
} data[]={{"camera",15,2}, {"necklace",100,20}, {"vase",90,20},
{"picture",60,30}, {"tv",40,40}, {"video",15,30},
{"chest",10,60}, {"brick",1,10}};
double solution[8]; /* Array for solution values */
/*****************/
/* Main function */
/*****************/
int main()
{
XPRMmodel mod;
XPRMalltypes rvalue, itemname;
XPRMset set;
int result,i;
char bimfile[2000]; /* Buffer to store BIM file */
size_t bimfile_size; /* Buffer to store actual size of BIM file */
char mosfile_name[40]; /* File name of MOS file */
char bimfile_name[64]; /* File name of BIM file */
char data_name[40]; /* File name of initial values for 'data' */
char solution_name[40]; /* File name of solution values */
char params[96]; /* Parameter string for model execution */
i=XPRMinit(); /* Initialize Mosel */
if((i!=0)&&(i!=32))
return 1;
/* Prepare file names for compilation using 'mem' driver: */
/* "mem:base address/size[/actual size pointer]" */
bimfile_size=0;
sprintf(mosfile_name, "mem:%p/%d",
source_of_model, (int)sizeof(source_of_model));
sprintf(bimfile_name, "mem:%p/%d/%p",
bimfile, (int)sizeof(bimfile), &bimfile_size);
/* Compile model from memory to memory */
if(XPRMcompmod(NULL, mosfile_name, bimfile_name, "Knapsack example"))
return 2;
printf("BIM file uses %lu bytes of memory.\n", bimfile_size);
/* Load a BIM file from memory */
if((mod=XPRMloadmod(bimfile_name, NULL))==NULL)
return 3;
/* Prepare file names for 'initializations' using the 'raw' driver: */
/* "rawoption[,...],filename" */
/* (Here, 'filename' uses the 'mem' driver, data is stored in memory) */
/* Options for 'raw': */
/* 'slength=0': strings are represented by pointers to null terminated */
/* arrays of characters (C-string) instead of fixed size arrays*/
/* 'noindex': only array values are expected - no indices requested */
#ifdef _WIN32
sprintf(data_name, "slength=0,mem:%#Ix/%u", (size_t)data,
sizeof(data));
sprintf(solution_name, "noindex,mem:%#Ix/%u", (size_t)solution,
sizeof(solution));
#else
sprintf(data_name, "slength=0,mem:%#lx/%u", (unsigned long)data,
sizeof(data));
sprintf(solution_name, "noindex,mem:%#lx/%u", (unsigned long)solution,
sizeof(solution));
#endif
/* Pass file names as execution param.s */
sprintf(params, "DATA='%s',SOL='%s'", data_name, solution_name);
if(XPRMrunmod(mod, &result, params)) /* Run the model */
return 4;
/* Display solutions values obtained from the model */
printf("Objective: %g\n", XPRMgetobjval(mod));
XPRMfindident(mod, "ITEMS", &rvalue); /* Get the model object 'ITEMS' */
set = rvalue.set;
for(i=0;i<8;i++)
printf(" take(%s): %g\n", XPRMgetelsetval(set, i+1, &itemname)->string,
solution[i]);
return 0;
}
|
|
| iodrvraw2.c |
/*******************************************************
Mosel Example Problems
======================
file iodrvraw2.c
````````````````
Using the IO drivers `raw' and `mem'.
- Model source in separate .mos file -
(c) 2008 Fair Isaac Corporation
author: S. Heipcke, Feb. 2007, rev. Feb. 2017
********************************************************/
#include <stdio.h>
#include "xprm_mc.h"
const struct
{ /* Initial values for array 'data': */
const char *ind; /* index name */
double val,wght; /* value and weight data entries */
} data[]={{"camera",15,2}, {"necklace",100,20}, {"vase",90,20},
{"picture",60,30}, {"tv",40,40}, {"video",15,30},
{"chest",10,60}, {"brick",1,10}};
double solution[8]; /* Array for solution values */
/*****************/
/* Main function */
/*****************/
int main()
{
XPRMmodel mod;
XPRMalltypes rvalue, itemname;
XPRMset set;
int result,i;
char data_name[40]; /* File name of initial values for 'data' */
char solution_name[40]; /* File name of solution values */
char params[96]; /* Parameter string for model execution */
i=XPRMinit(); /* Initialize Mosel */
if((i!=0)&&(i!=32))
return 1;
/* Prepare file names for 'initializations' using the 'raw' driver: */
/* "rawoption[,...],filename" */
/* (Here, 'filename' uses the 'mem' driver, data is stored in memory) */
/* Options for 'raw': */
/* 'slength=0': strings are represented by pointers to null terminated */
/* arrays of characters (C-string) instead of fixed size arrays*/
/* 'noindex': only array values are expected - no indices requested */
sprintf(data_name, "slength=0,mem:%p/%d", data, (int)sizeof(data));
sprintf(solution_name, "noindex,mem:%p/%d", solution, (int)sizeof(solution));
/* Pass file names as execution param.s */
sprintf(params, "DATA='%s',SOL='%s'", data_name, solution_name);
if(XPRMexecmod(NULL, "burglar2r.mos", params, &result, &mod))
return 2; /* Execute a model file */
/* Display solutions values obtained from the model */
printf("Objective: %g\n", XPRMgetobjval(mod));
XPRMfindident(mod, "ITEMS", &rvalue); /* Get the model object 'ITEMS' */
set = rvalue.set;
for(i=0;i<8;i++)
printf(" take(%s): %g\n", XPRMgetelsetval(set, i+1, &itemname)->string,
solution[i]);
return 0;
}
|
|
| iodrvcb.c |
/*******************************************************
Mosel Example Problems
======================
file iodrvcb.c
``````````````
Using the IO drivers `cb' and `sysfd'.
(c) 2008 Fair Isaac Corporation
author: S. Heipcke, 2004, rev. Feb. 2017
********************************************************/
#include <stdio.h>
#include "xprm_mc.h"
/**************************************/
/* Callback function to handle output */
/**************************************/
long XPRM_RTC cbmsg(XPRMmodel model, void *info, char *buf, unsigned long size)
{
/* Note: 'model' is NULL if the stream is used outside of an execution */
printf("Mosel: %.*s", (int)size, buf);
return 0;
}
/*****************/
/* Main function */
/*****************/
int main()
{
XPRMmodel mod;
int result, i;
char outfile_name[40]; /* File name of output stream */
i=XPRMinit(); /* Initialize Mosel */
if((i!=0)&&(i!=32))
return 1;
/* Using 'sysfd' driver: */
/* Redirect error stream to default output */
XPRMsetdefstream(NULL, XPRM_F_ERROR, "sysfd:1");
/* Prepare file name for output stream */
/* using 'cb' driver: */
/* "cb:function pointer[/callback data]" */
sprintf(outfile_name, "cb:%p", cbmsg);
/* Set default output stream to callback */
XPRMsetdefstream(NULL, XPRM_F_WRITE, outfile_name);
/* Execute = compile/load/run model file
`burglar2.mos'
Generates the BIM file `burglar2.bim' */
/* if(XPRMexecmod(NULL,"burglar2.mos",NULL,&result,NULL))
return 2; */
if(XPRMcompmod(NULL, "burglar2.mos", NULL, "Knapsack example"))
return 2; /* Compile the model `burglar2.mos',
output the file `burglar2.bim' */
if((mod=XPRMloadmod("burglar2.bim", NULL))==NULL) /* Load a BIM file */
return 3;
if(XPRMrunmod(mod, &result, NULL)) /* Run the model */
return 4;
return 0;
}
|
|
| burgbindata.c |
/********************************************************
Mosel User Guide Example Problems
=================================
file burgbindata.c
``````````````````
Example of use of BinDrv for reading and writing files.
(c) 2013 Fair Isaac Corporation
author: S.Heipcke, Apr. 2013
********************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include "bindrv.h"
#include "xprm_mc.h"
static void writeburgbin(void);
static void readburgbin(void);
static void *dummy_malloc(size_t s,void *ctx);
/* Input data */
static double vdata[]={15,100,90,60,40,15,10, 1}; /* VALUE */
static double wdata[]={ 2, 20,20,30,40,30,60,10}; /* WEIGHT */
static char *ind[]={"camera", "necklace", "vase", "picture", "tv",
"video", "chest", "brick" }; /* Index names */
int datasize=8;
int main()
{
int result;
writeburgbin();
if(XPRMinit()) /* Initialize Mosel */
return 1;
/* Execute = compile/load/run a model */
if(XPRMexecmod(NULL,"burglar2m.mos",NULL,&result,NULL))
return 2;
readburgbin();
return 0;
}
/*****************************/
/* Create a BinDrv data file */
/*****************************/
static void writeburgbin(void)
{
FILE *f;
s_bindrvctx bdrv;
int i;
f=fopen("burgdatabin","w");
bdrv=bindrv_newwriter((size_t (*)(const void *,size_t,size_t,void*))fwrite,f);
bindrv_putctrl(bdrv,BINDRV_CTRL_LABEL); bindrv_putstring(bdrv,"BurgData");
bindrv_putctrl(bdrv,BINDRV_CTRL_OPENLST); /* [ */
for(i=0;i<datasize;i++)
{
bindrv_putctrl(bdrv,BINDRV_CTRL_OPENNDX); /* ( */
bindrv_putstring(bdrv,ind[i]); /* index */
bindrv_putctrl(bdrv,BINDRV_CTRL_CLOSENDX); /* ) */
bindrv_putctrl(bdrv,BINDRV_CTRL_OPENLST); /* [ */
bindrv_putreal(bdrv,vdata[i]); /* val1 */
bindrv_putreal(bdrv,wdata[i]); /* val2 */
bindrv_putctrl(bdrv,BINDRV_CTRL_CLOSELST); /* ] */
}
bindrv_putctrl(bdrv,BINDRV_CTRL_CLOSELST); /* ] */
bindrv_delete(bdrv);
fclose(f);
}
/***************************************/
/* Read and display a BinDrv data file */
/***************************************/
static void readburgbin(void)
{
FILE *f;
s_bindrvctx bdrv;
union { int i; double r; char b; char *str; BINDRV_LONG l;} val;
f=fopen("resdatabin","r");
bdrv=bindrv_newreader((size_t (*)(void *,size_t,size_t,void*))fread,f);
bindrv_getctrl(bdrv,&(val.i));
if(val.i==BINDRV_CTRL_LABEL)
{
while(bindrv_nexttoken(bdrv)>=0)
{
bindrv_getstring(bdrv,&(val.str)); /* label: */
if(strcmp(val.str,"SolTake")==0)
{
free(val.str);
printf("Solution values:\n");
bindrv_getctrl(bdrv,&(val.i)); /* [ */
while(bindrv_nexttoken(bdrv)>=0)
{
bindrv_getctrl(bdrv,&(val.i));
if(val.i== BINDRV_CTRL_LABEL) break;
switch(val.i)
{
case BINDRV_CTRL_OPENNDX: /* ( */
printf(" take(");
bindrv_getstring(bdrv,&(val.str)); /* index */
printf("%s",val.str);
bindrv_getctrl(bdrv,&(val.i)); /* ) */
printf(")=");
bindrv_getreal(bdrv,&(val.r)); /* value */
printf(" %g\n",val.r);
break;
case BINDRV_CTRL_CLOSELST: /* ] */
printf("\n");
break;
default:
printf("Unexpected token %d\n", val.i); exit(1);
}
}
}
else if(strcmp(val.str,"Objective")==0)
{
free(val.str);
bindrv_getreal(bdrv,&(val.r));
printf("Objective value = %g\n", val.r);
}
else
{
printf("Unexpected label '%s'\n", val.str);
free(val.str);
exit(1);
}
}
}
else
{
printf("Unexpected token '%d'\n", val.i);
exit(1);
}
bindrv_delete(bdrv);
fclose(f);
}
|
|
| burgbindata.java |
/********************************************************
Mosel User Guide Example Problems
=================================
file burgbindata.java
`````````````````````
Example of use of BinDrv for reading and writing files.
(c) 2013 Fair Isaac Corporation
author: S.Heipcke, Apr. 2013
********************************************************/
import java.io.*;
import java.nio.*;
import com.dashoptimization.*;
public class burgbindata
{ // Input data
static final double[] vdata={15,100,90,60,40,15,10, 1}; // VALUE
static final double[] wdata={ 2, 20,20,30,40,30,60,10}; // WEIGHT
static final String[] ind={"camera", "necklace", "vase", "picture", "tv",
"video", "chest", "brick" }; // Index names
static final int datasize=8;
public static void main(String[] args) throws Exception
{
writeBurgBin();
XPRM mosel;
XPRMModel mod;
mosel = new XPRM(); // Initialize Mosel
mosel.compile("burglar2m.mos");
mod = mosel.loadModel("burglar2m.bim");
mod.run();
readBurgBin();
}
/*****************************/
/* Create a BinDrv data file */
/*****************************/
static void writeBurgBin() throws IOException
{
BinDrvWriter bdrv;
FileOutputStream f;
f=new FileOutputStream("burgdatabin");
bdrv=new BinDrvWriter(f);
bdrv.putControl(bdrv.CTRL_LABEL).put("BurgData"); // label:
bdrv.putControl(bdrv.CTRL_OPENLST); // [
for(int i=0;i<datasize;i++)
{ // (index)
bdrv.putControl(bdrv.CTRL_OPENNDX).put(ind[i]).putControl(bdrv.CTRL_CLOSENDX);
bdrv.putControl(bdrv.CTRL_OPENLST).put(vdata[i]).put(wdata[i]);
bdrv.putControl(bdrv.CTRL_CLOSELST); // [val1 val2]
}
bdrv.putControl(bdrv.CTRL_CLOSELST); // ]
f.close();
}
/***************************************/
/* Read and display a BinDrv data file */
/***************************************/
static void readBurgBin() throws IOException
{
BinDrvReader bdrv;
FileInputStream f;
int c;
f=new FileInputStream("resdatabin");
bdrv=new BinDrvReader(f);
if(bdrv.getControl()==BinDrvReader.CTRL_LABEL)
{
while(bdrv.nextToken()>=0)
{
String s=bdrv.getString(); // label:
if(s.equals("SolTake"))
{
System.out.println("Solution values:");
bdrv.getControl();
while(bdrv.nextToken()>=0)
{
c=bdrv.getControl(); // [
if(c==BinDrvReader.CTRL_LABEL) break;
switch(c)
{
case BinDrvReader.CTRL_OPENNDX: // (
System.out.print(" take("+bdrv.getString()+")="); // index
bdrv.getControl(); // )
System.out.println(bdrv.getReal()); // value
break;
case BinDrvReader.CTRL_CLOSELST: // ]
System.out.println(""); break;
default:
System.out.println("Unexpected Control");
System.exit(0);
}
}
}
else if(s.equals("Objective"))
System.out.println("Objective value = "+bdrv.getReal());
else
{
System.out.println("Unexpected label "+s);
System.exit(0);
}
}
}
else
{
System.out.println("Unexpected token");
System.exit(1);
}
f.close();
}
}
|
|
| burglar2.mos |
(!******************************************************
Mosel Example Problems
======================
file burglar2.mos
`````````````````
Data read from file.
(c) 2008 Fair Isaac Corporation
author: S. Heipcke, Jan. 2001
*******************************************************!)
model Burglar2
uses "mmxprs"
declarations
WTMAX = 102 ! Maximum weight allowed
ITEMS: set of string ! Index set for items
VALUE: array(ITEMS) of real ! Value of items
WEIGHT: array(ITEMS) of real ! Weight of items
end-declarations
initializations from "burglar.dat"
[VALUE,WEIGHT] as "BurgData"
end-initializations
declarations
take: array(ITEMS) of mpvar ! 1 if we take item i; 0 otherwise
end-declarations
! Objective: maximize total value
MaxVal:= sum(i in ITEMS) VALUE(i)*take(i)
! Weight restriction
sum(i in ITEMS) WEIGHT(i)*take(i) <= WTMAX
! All variables are 0/1
forall(i in ITEMS) take(i) is_binary
maximize(MaxVal) ! Solve the MIP-problem
! Solution output
forall(i in ITEMS) SOLTAKE(i):= getsol(take(i))
writeln("Solution:\n Objective: ", getobjval)
writeln(SOLTAKE)
initializations to "burglarout.txt"
SOLTAKE
end-initializations
end-model
|
|
| burglar2r.mos |
(!******************************************************
Mosel Example Problems
======================
file burglar2r.mos
``````````````````
Use of I/O drivers for data handling.
(c) 2008 Fair Isaac Corporation
author: S. Heipcke, 2004, rev. Apr. 2013
*******************************************************!)
model Burglar2r
uses 'mmxprs'
parameters
IODRV='raw:'
DATA='BurgData'
SOL='SolTake'
WTMAX = 102 ! Maximum weight allowed
end-parameters
declarations
ITEMS: set of string ! Index set for items
VALUE: array(ITEMS) of real ! Value of items
WEIGHT: array(ITEMS) of real ! Weight of items
SOLTAKE: array(ITEMS) of real ! Solution values
end-declarations
initialisations from IODRV
[VALUE,WEIGHT] as DATA
end-initialisations
declarations
take: array(ITEMS) of mpvar ! 1 if we take item i; 0 otherwise
end-declarations
! Objective: maximize total value
MaxVal:= sum(i in ITEMS) VALUE(i)*take(i)
! Weight restriction
sum(i in ITEMS) WEIGHT(i)*take(i) <= WTMAX
! All variables are 0/1
forall(i in ITEMS) take(i) is_binary
maximize(MaxVal) ! Solve the problem
! Solution output
forall(i in ITEMS) SOLTAKE(i):= getsol(take(i))
writeln("Solution:\n Objective: ", getobjval)
writeln(SOLTAKE)
initialisations to IODRV
SOLTAKE as SOL
end-initialisations
end-model
|
|
| burglar2m.mos |
(!******************************************************
Mosel Example Problems
======================
file burglar2m.mos
``````````````````
Use of I/O drivers for data handling.
(c) 2008 Fair Isaac Corporation
author: S. Heipcke, 2004,rev. Apr. 2013
*******************************************************!)
model Burglar2r
uses 'mmxprs'
parameters
DATA='bin:burgdatabin'
SOL='bin:resdatabin'
WTMAX = 102 ! Maximum weight allowed
end-parameters
declarations
ITEMS: set of string ! Index set for items
VALUE: array(ITEMS) of real ! Value of items
WEIGHT: array(ITEMS) of real ! Weight of items
SOLTAKE: array(ITEMS) of real ! Solution values
end-declarations
initialisations from DATA
[VALUE, WEIGHT] as "BurgData"
end-initialisations
declarations
take: array(ITEMS) of mpvar ! 1 if we take item i; 0 otherwise
end-declarations
! Objective: maximize total value
MaxVal:= sum(i in ITEMS) VALUE(i)*take(i)
! Weight restriction
sum(i in ITEMS) WEIGHT(i)*take(i) <= WTMAX
! All variables are 0/1
forall(i in ITEMS) take(i) is_binary
maximize(MaxVal) ! Solve the problem
! Solution output
forall(i in ITEMS) SOLTAKE(i):= getsol(take(i))
writeln("Solution:\n Objective: ", getobjval)
writeln(SOLTAKE)
initialisations to SOL
SOLTAKE as "SolTake"
evaluation of getobjval as "Objective"
end-initialisations
end-model
|
|
