Esempio n. 1
0
        static void Main(string[] args)
        {
            int status = 127;

            try
            {
                OplFactory.DebugMode = true;
                OplFactory         oplF        = new OplFactory();
                OplErrorHandler    errHandler  = oplF.CreateOplErrorHandler(Console.Out);
                OplModelSource     modelSource = oplF.CreateOplModelSourceFromString(GetModelText(), "carseq");
                OplSettings        settings    = oplF.CreateOplSettings(errHandler);
                OplModelDefinition def         = oplF.CreateOplModelDefinition(modelSource, settings);
                CP            cp         = oplF.CreateCP();
                OplModel      opl        = oplF.CreateOplModel(def, cp);
                OplDataSource dataSource = new MyData(oplF);
                opl.AddDataSource(dataSource);
                opl.Generate();

                if (cp.Solve())
                {
                    Console.Out.WriteLine("OBJECTIVE: " + opl.CP.ObjValue);
                    opl.PostProcess();
                    opl.PrintSolution(Console.Out);
                    status = 0;
                }
                else
                {
                    Console.Out.WriteLine("No solution!");
                    status = 1;
                }

                oplF.End();
            }
            catch (ILOG.OPL.OplException ex)
            {
                Console.WriteLine(ex.Message);
                status = 2;
            }
            catch (ILOG.Concert.Exception ex)
            {
                Console.WriteLine(ex.Message);
                status = 3;
            }
            catch (System.Exception ex)
            {
                Console.WriteLine(ex.Message);
                status = 4;
            }
            Environment.ExitCode = status;

            Console.WriteLine("--Press <Enter> to exit--");
            Console.ReadLine();
        }
Esempio n. 2
0
        static int Main(string[] args)
        {
            int          status  = 127;
            const string DATADIR = "../..";

            try
            {
                OplFactory         oplF        = new OplFactory();
                OplErrorHandler    handler     = oplF.CreateOplErrorHandler(Console.Out);
                OplModelSource     modelSource = oplF.CreateOplModelSource(DATADIR + "/mulprod.mod");
                OplSettings        settings    = oplF.CreateOplSettings(handler);
                OplModelDefinition def         = oplF.CreateOplModelDefinition(modelSource, settings);
                Cplex         cplex            = oplF.CreateCplex();
                OplModel      opl        = oplF.CreateOplModel(def, cplex);
                OplDataSource dataSource = oplF.CreateOplDataSource(DATADIR + "/mulprod.dat");
                opl.AddDataSource(dataSource);
                opl.Generate();
                if (cplex.Solve())
                {
                    Console.Out.WriteLine();
                    Console.Out.WriteLine("OBJECTIVE: " + opl.Cplex.ObjValue);
                    opl.PostProcess();
                    opl.PrintSolution(Console.Out);
                    status = 0;
                }
                else
                {
                    Console.Out.WriteLine("No solution!");
                    status = 1;
                }
                oplF.End();
            }
            catch (ILOG.OPL.OplException ex)
            {
                Console.WriteLine(ex.Message);
                status = 2;
            }
            catch (ILOG.Concert.Exception ex)
            {
                Console.WriteLine(ex.Message);
                status = 3;
            }
            catch (System.Exception ex)
            {
                Console.WriteLine(ex.Message);
                status = 4;
            }

            Console.WriteLine("--Press <Enter> to exit--");
            Console.ReadLine();

            return(status);
        }
Esempio n. 3
0
        static int Main(string[] args)
        {
            int          status  = 127;
            const string DATADIR = "../..";

            try
            {
                OplFactory         oplF        = new OplFactory();
                OplErrorHandler    handler     = oplF.CreateOplErrorHandler(Console.Out);
                OplModelSource     modelSource = oplF.CreateOplModelSource(DATADIR + "/lifegameip.mod");
                OplSettings        settings    = oplF.CreateOplSettings(handler);
                OplModelDefinition def         = oplF.CreateOplModelDefinition(modelSource, settings);
                Cplex cplex = oplF.CreateCplex();
                cplex.ReadVMConfig(DATADIR + "/process.vmc");
                OplModel opl = oplF.CreateOplModel(def, cplex);
                opl.Generate();
                cplex.Solve();
                Console.Out.WriteLine();
                Console.Out.WriteLine("OBJECTIVE: " + opl.Cplex.ObjValue);
                opl.PostProcess();
                opl.PrintSolution(Console.Out);
                if (cplex.HasVMConfig())
                {
                    Console.Out.WriteLine("cplex has a VM config");
                }
                else
                {
                    throw new IloException("cplex does not have a VM config");
                }
                cplex.DelVMConfig();

                if (cplex.HasVMConfig())
                {
                    throw new IloException("cplex still has a VM config");
                }
                else
                {
                    Console.Out.WriteLine("cplex VM config was removed");
                }

                status = 0;
                oplF.End();
            }
            catch (ILOG.OPL.OplException ex)
            {
                Console.WriteLine(ex.Message);
                status = 2;
            }
            catch (ILOG.Concert.Exception ex)
            {
                Console.WriteLine(ex.Message);
                status = 3;
            }
            catch (System.Exception ex)
            {
                Console.WriteLine(ex.Message);
                status = 4;
            }

            Console.WriteLine("--Press <Enter> to exit--");
            Console.ReadLine();

            return(status);
        }
Esempio n. 4
0
        int Run()
        {
            int        status = 127;
            OplFactory oplF   = new OplFactory();

            if (_cl.CompileName != null)
            {
                OplCompiler    compiler    = oplF.CreateOplCompiler();
                StreamWriter   ofs         = new StreamWriter(_cl.CompileName, false);
                OplModelSource modelSource = oplF.CreateOplModelSource(_cl.ModelFileName);
                compiler.Compile(modelSource, ofs);
                ofs.Close();
                Trace("Compile");
                return(0);
            }
            if (_cl.ModelFileName == null && !_cl.IsProject)
            {
                return(0);
            }

            Trace("initial");
            OplRunConfiguration rc;
            OplErrorHandler     errHandler = oplF.CreateOplErrorHandler();

            if (_cl.IsProject)
            {
                OplProject prj = oplF.CreateOplProject(_cl.getProjectPath());
                rc = prj.MakeRunConfiguration(_cl.getRunConfigurationName());
            }
            else
            {
                if (_cl.DataFileNames.Length == 0)
                {
                    rc = oplF.CreateOplRunConfiguration(_cl.ModelFileName);
                }
                else
                {
                    rc = oplF.CreateOplRunConfiguration(_cl.ModelFileName, _cl.DataFileNames);
                }
            }
            rc.ErrorHandler = errHandler;
            OplModel    opl      = rc.OplModel;
            OplSettings settings = opl.Settings;

            settings.IsWithLocations     = true;
            settings.IsWithNames         = true;
            settings.IsForceElementUsage = _cl.IsForceElementUsage;

            status = 9;
            if (opl.ModelDefinition.hasMain())
            {
                status = opl.Main();
                Console.Out.WriteLine("main returns " + status);
                Trace("main");
            }
            else if (errHandler.Ok)
            {
                opl.Generate();
                Trace("generate model");
                if (opl.HasCplex)
                {
                    if (_cl.ExportName != null)
                    {
                        opl.Cplex.ExportModel(_cl.ExportName);
                        Trace("export model " + _cl.ExportName);
                    }
                    if (_cl.IsRelaxation)
                    {
                        Console.Out.WriteLine("RELAXATIONS to obtain a feasible problem: ");
                        opl.PrintRelaxation(Console.Out);
                        Console.Out.WriteLine("RELAXATIONS done.");
                    }
                    if (_cl.IsConflict)
                    {
                        Console.Out.WriteLine("CONFLICT in the infeasible problem: ");
                        opl.PrintConflict(Console.Out);
                        Console.Out.WriteLine("CONFLICT done.");
                    }
                    if (!_cl.IsRelaxation && !_cl.IsConflict)
                    {
                        bool result = false;
                        try
                        {
                            result = opl.Cplex.Solve();
                        }
                        catch (IloException ex)
                        {
                            Console.Out.WriteLine("### ENGINE exception: " + ex.Message);
                        }
                        if (result)
                        {
                            Trace("solve");
                            Console.Out.WriteLine();
                            Console.Out.WriteLine();
                            Console.Out.WriteLine("OBJECTIVE: " + opl.Cplex.ObjValue.ToString("F"));
                            opl.PostProcess();
                            Trace("post process");
                            if (_cl.IsVerbose)
                            {
                                opl.PrintSolution(Console.Out);
                            }
                            status = 0;
                        }
                        else
                        {
                            Trace("no solution");
                            status = 1;
                        }
                    }
                }
                else
                {//opl.hasCP()
                    bool result = false;
                    try
                    {
                        result = opl.CP.Solve();
                    }
                    catch (IloException ex)
                    {
                        Console.Out.WriteLine("### Engine exception: " + ex.Message);
                    }
                    if (result)
                    {
                        Trace("solve");
                        if (opl.CP.HasObjective())
                        {
                            Console.Out.WriteLine();
                            Console.Out.WriteLine();
                            Console.Out.WriteLine("OBJECTIVE: " + opl.CP.ObjValue.ToString("F"));
                        }
                        else
                        {
                            Console.Out.WriteLine();
                            Console.Out.WriteLine();
                            Console.Out.WriteLine("OBJECTIVE: no objective");
                        }
                        opl.PostProcess();
                        Trace("post process");
                        if (_cl.IsVerbose)
                        {
                            opl.PrintSolution(Console.Out);
                        }
                        status = 0;
                    }
                    else
                    {
                        Trace("no solution");
                        status = 1;
                    }
                }
            }
            if (_cl.ExternalDataName != null)
            {
                StreamWriter ofs = new StreamWriter(_cl.ExternalDataName, false);
                opl.PrintExternalData(ofs);
                ofs.Close();
                Trace("write external data " + _cl.ExternalDataName);
            }
            if (_cl.InternalDataName != null)
            {
                StreamWriter ofs = new StreamWriter(_cl.InternalDataName, false);
                opl.PrintInternalData(ofs);
                ofs.Close();
                Trace("write internal data " + _cl.InternalDataName);
            }

            Trace("done");
            return(status);
        }
Esempio n. 5
0
        static void Main(string[] args)
        {
            int nbWarehouses = -1;
            int nbStores     = -1;
            int fixedP       = -1;
            int disaggregate = -1;

            for (int i = 0; i < args.Length; i++)
            {
                if ("-h".Equals(args[i]))
                {
                    usage();
                }
                else if ("fixed".Equals(args[i]))
                {
                    if (i == args.Length)
                    {
                        usage();
                    }
                    fixedP = System.Int32.Parse(args[++i]);
                }
                else if ("nbWarehouses".Equals(args[i]))
                {
                    if (i == args.Length)
                    {
                        usage();
                    }
                    nbWarehouses = System.Int32.Parse(args[++i]);
                }
                else if ("nbStores".Equals(args[i]))
                {
                    if (i == args.Length)
                    {
                        usage();
                    }
                    nbStores = System.Int32.Parse(args[++i]);
                }
                else if ("disaggregate".Equals(args[i]))
                {
                    if (i == args.Length)
                    {
                        usage();
                    }
                    disaggregate = System.Int32.Parse(args[++i]);
                }
                else
                {
                    break;
                }
            }

            if (fixedP == -1 || nbWarehouses == -1 || nbStores == -1 || disaggregate == -1)
            {
                usage();
            }

            int status = 127;

            try
            {
                OplFactory.DebugMode = true;
                OplFactory         oplF        = new OplFactory();
                OplErrorHandler    errHandler  = oplF.CreateOplErrorHandler(Console.Out);
                OplModelSource     modelSource = oplF.CreateOplModelSourceFromString(GetModelText(), "warehouse");
                OplSettings        settings    = oplF.CreateOplSettings(errHandler);
                OplModelDefinition def         = oplF.CreateOplModelDefinition(modelSource, settings);
                Cplex         cplex            = oplF.CreateCplex();
                OplModel      opl        = oplF.CreateOplModel(def, cplex);
                OplDataSource dataSource = new MyParams(oplF, nbWarehouses, nbStores, fixedP, disaggregate);
                opl.AddDataSource(dataSource);
                opl.Generate();
                if (cplex.Solve())
                {
                    Console.Out.WriteLine("OBJECTIVE: " + opl.Cplex.ObjValue);
                    opl.PostProcess();
                    opl.PrintSolution(Console.Out);
                    status = 0;
                }
                else
                {
                    Console.Out.WriteLine("No solution!");
                    status = 1;
                }

                oplF.End();
            }
            catch (ILOG.OPL.OplException ex)
            {
                Console.WriteLine(ex.Message);
                status = 2;
            }
            catch (ILOG.Concert.Exception ex)
            {
                Console.WriteLine(ex.Message);
                status = 3;
            }
            catch (System.Exception ex)
            {
                Console.WriteLine(ex.Message);
                status = 4;
            }

            Environment.ExitCode = status;

            Console.WriteLine("--Press <Enter> to exit--");
            Console.ReadLine();
        }