You may have heard, that Gurobi has released the next version of their solver software.
Today we released version 0.3.1062.0 of the Optimization.Framework which adds support for Gurobi 5.0. As always, you can get the latest version of the Optimization.Framework from the Nuget repository: http://nuget.org/packages/Optimization.Framework.

We had a few requests for a forum where people can ask questions about the Optimization.Framework recently, so here it is: https://groups.google.com/forum/#!forum/optimizationframework-forum.

Lars

Today I got a surprise visit from Jochen, a student, who just finished his bachelor thesis at the group of Prof. Kundisch (Information Management and E-Finance). He had been using the Optimization.Framework in his thesis and wanted to say thank you for the Framework and a few hints I had given him.

Not only did he say thank you, but he also gave me an amazon voucher (see below).

@Jochen: By posting this I want to say thanks! You made my day! This was the first time the Optimization.Framework ever got a donation!

Lars

The APMOD program is now online!

Today we released a new NuGet package, which allows you to use GLPK with the Optimization.Framework.

The great thing about this package is that
- it will also install the Optimization.Framework automatically
- it will install the precompiled assemblies of GLPK
- it configures the paths to the assemblies by changing your app.config file accordingly (at this point we assume that your process runs as a 64-bit process; if this is not the case, simply go to your app.config and change the path to the native assembly from x64 to x86)

This means, that you get a fully working C# modeling language including a precompiled and preconfigured free to use solver, so that you can start modeling right away.

This new package is licensed under the GPL, which basically means that you will most likely not use it for commercial products. The Optimization.Framework itself however will still be licensed as it has always been. So, you get to choose if you want the free one-stop package which forces you to publish your software under the GPL or if you want the version for which you need to get a Gurobi, Cplex or MOPS license but which you will still be able to use without adapting your own license.

The new package can be found via the NuGet package manager. Simply type “GPLK” in the search box. You can also go to this site and download the package manually: http://nuget.org/packages/Optimization.Solver.GLPK
If you want to fork the source code go to: https://github.com/larsbeck/Optimization.Solver.GLPKSolver

Merry Christmas and a Happy New Year everybody!

Lars

I did post this on G+ before, but I thought to share this with all non G+ users too:

The other day, when a few people from our group had their coffee break together, they thought that it was a shame, that we OR people so far don’t have super heroes…and this is what we came up with:

The setting of our story is the modern, but enormously dark city of Dantzig, Poland

The good guys (aka iForce):
- Optiman (Superhero; weapon of choice: Feasibility pumpgun, vehicle: Hyper plane)
- Heuristic boy (Sidekick)
- Obiwan Gurobi (old guy you go to when you have a hard to solve problem – the only sentence he knows though still helpful every time: “May the iForce be with you”)

The bad guys:
- Dr. LocOpt (Villain; weapon of choice: his “Degeneration” powers (think of the Quake3 voice, saying “Regeneration” – http://fliiby.com/file/6193/obtcmihvjz.html)
- Poly hydra (Dr. LocOpt’s dangerous snake monster with many heads)
- N.P. Hard (Villain; weapon of choice: Infeasibility cloak, also: the guy who makes every easy problem enormously hard to solve, btw. no one knows his real first and middle name, only the initials)
- Two Phase (using the simplest possible decision support system ever – a coin)

The neutral characters (sometimes good, sometimes bad):
- Cutwoman (sometimes she can help by using her cuts, e.g. her director’s cut, but sometimes eliminates feasible solutions…she always has her own agenda)
- simpLex Luther (not the most clever guy, but very successful and everybody knows him)
- Cylce-Ops (drives simpLex Luther nuts)

Polititians:
- Al GOR

Guest stars:
Bender (Futurama), MethodMan (rapping: “We are the column generation”) and of course the one and only MIP Jagger

Here is an image of our whiteboard:

Characters proposed from people who commented on the G+ post:
- Nash-man (already knows what you’re going to do, the only way to defeat him is to think irrationally…) – as proposed by Vincent Knight
- Sad L. Point (villain): gives users false hope of a solution, then depresses them by dashing that hope – as proposed by Paul Rubin
- Swapman (who is protecting your neighbourhood from innefficient solutions) – as proposed by Tim Schöneberg

Here is how it works:

1. Join our LinkedIn group before September 30th, which can be found here: APMOD2012 LinkedIn group
2. Wait until you receive an EMail with a promotion code – you should find it in your inbox shortly after September 30th
3. Whenever you decide to register for APMOD2012 provide the promotion code and get a 10% discount

Note: By joining the LinkedIn group you DO NOT commit to register for APMOD2012. Joining the LinkedIn group before September 30th simply enables you to save 10% of the registration fee in case you decide to register for APMOD2012.

Why are we doing this?

The results of a survey at OR-Exchange on “what conference properties are important to you?” showed that your peers who are attending a conference are rather important to you. In order to give you the chance to see who is actually interested in coming, we try to bring everybody together in our LinkedIn group.

Gurobi released a new version of their solver software.

Highlights include:

• Substantial performance improvements in our MIP and Barrier solvers:
  A 31% improvement in overall MIP performance, with a 75 % improvement on models that take more than 100 seconds to solve.
  A 14% improvement in overall barrier performance, with a 23 % improvement on models that take more than 100 seconds to solve.
• Pay-By-The-Day licensing: A new short-term, low-cost licensing option that gives you the ability to dynamically adjust the number of licenses available to you in order to cope with variations in demand. The minimum license period is just one calendar day.
• A new default automatic setting for choosing the algorithms used to solve LP and QP models: The new default uses the concurrent optimizer for LP models and the Barrier solver for QP models. The new defaults provide substantially improved overall performance.
• A new heuristic for finding feasible solutions to difficult MIP models: This heuristic can be quite useful in cases where other approaches are unable to find a feasible solution.
• Additional information is now provided for infeasible and unbounded models: Advanced users can now obtain an unbounded ray for unbounded models and an infeasibility proof for infeasible models.

I personally like the idea of a per-day-use because it allows you to use Gurobi in a very flexible short term way. Cloud computing scenarios (which I am working on with our framework) come to mind…

For more information on the latest version of Gurobi go to their website.

In our first tutorial we explain how you can use the framework in order to build a sudoku solver.

To download the source code click here

To see the source code click read the full article.

Credits to my brother Nils, who cut this video for me. I know this is a lot of work, thanks!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Common;
using Optimization;
using Optimization.Solver.Gurobi;

namespace Sudoku_Solver
{
    class Program
    {
        static void Main(string[] args)
        {
            var board = new Board();
            int dimension = 9;

            for (int i = 0; i < dimension; i++)
            {
                board.Columns.Add(new Column());
                board.Rows.Add(new Row());
                board.Squares.Add(new Square());
            }
            var squares = board.Squares.ToList();
            int k = 0;
            foreach (var column in board.Columns)
            {
                int j = 0;
                foreach (var row in board.Rows)
                {
                    var cell = new Cell();
                    column.Cells.Add(cell);
                    row.Cells.Add(cell);
                    board.Cells.Add(cell);
                    int val = ((k / (int)Math.Sqrt(dimension)) * (int)Math.Sqrt(dimension) + j / (int)Math.Sqrt(dimension));
                    squares[val].Cells.Add(cell);
                    j++;
                }
                k++;
            }

            var numbers = Enumerable.Range(1, dimension);
            var cellvariables = new VariableCollection("cellVariable", 0, 1, VariableType.Integer, board.Columns,
                                                       board.Rows, numbers);

            var model = new Model();

            board.Cells.ForEach(
                cell => model.AddConstraint(Expression.Sum(numbers.Select(number => cellvariables[cell.Column, cell.Row, number])) == 1)
                );

            board.Columns.ForEach(
                column =>
                    numbers.ForEach(
                    number =>
                        model.AddConstraint(Expression.Sum(column.Cells.Select(cell => cellvariables[cell.Column, cell.Row, number])) == 1)
                    )
                );

            board.Rows.ForEach(
                row =>
                    numbers.ForEach(
                    number =>
                        model.AddConstraint(Expression.Sum(row.Cells.Select(cell => cellvariables[cell.Column, cell.Row, number])) == 1)
                )
            );

            board.Squares.ForEach(
                square =>
                    numbers.ForEach(
                    number =>
                        model.AddConstraint(Expression.Sum(square.Cells.Select(cell => cellvariables[cell.Column, cell.Row, number])) == 1)
                    )
                );

            var columns = board.Columns.ToList();
            var rows = board.Rows.ToList();

            cellvariables[columns[0], rows[1], 7].LowerBound = 1;

            var solver = new GurobiSolver();
            var solution = solver.Solve(model);
            cellvariables.SetVariableValues(solution.VariableValues);

            board.Rows.ForEach(
                row =>
                {
                    board.Columns.ForEach(
                        column =>
                        numbers.ForEach(
                            number =>
                            {
                                if (cellvariables[column, row, number].Value == 1)
                                {
                                    Console.Write(number + " ");
                                }
                            }
                            )
                        );
                    Console.WriteLine();
                }

                );

            Console.Read();
        }
    }
}