Integer Programming - Science topic

Suggest reviewing this paper for MCDM methods:

Dear R. M. Fouad,

Also i suggest you to see links on topic.

Best regards

Hi Masar Alrabeeah,

Did you code the epsilon constraint method using OPL? May I ask how did you code this? I tried but could not get the right results.

Thanks a lot.

Ondřej Benedikt Michael Patriksson Alexandre Frias Faria Adam N. Letchford Thanks all for your valuable insights. I have played more with my instances and find out that it's more related to the structure of my model formulation.

My model needs to determine both routes of vehicles & time-windows of customers given a set of scenarios each of which contains parameters like traveling time. So, it's quite harder than classic VRPTW where time-windows are known.

It's hard for some specific problem size. If I simply ignore these "bad instances", then the solving time indeed increases when problem size grows.

If all righthand sides are 1, then you can reduce the problem to a series of shortest-path problems:

If not, then you can use the method in this paper:

Check this out.

You can ask your thesis advisor about what journal they think would be best to submit your work. It is hard to suggest a journal for you without seeing the actual paper.

The following references might help you:

https://kilthub.cmu.edu/articles/journal_contribution/Symmetry_in_Integer_Linear_Programming/6708215#:~:text=by%20Francois%20Margot-,An%20integer%20linear%20program%20(ILP)%20is%20symmetric%20if%20its%20variables,the%20structure%20of%20the%20problem.&text=during%20its%20solution.-,It%20also%20surveys%20related%20topics%2C%20such%20as%20symmetry%20detection%2C%20polyhedral,all%20non%20isomorphic%20optimal%20solutions.

We did that, please check the Media files attached to the following paper: https://ieeexplore.ieee.org/abstract/document/9126175

The method for solving this problem depends on the properties of functions F, f, g (convex, concave, other properties).

If properties are not known - the only method is looking through all values of variables.

The response from those who know about both - such as me - is that PSO and other meta things will very unlikely be as robust and accurate as a modern branch-and-bound code. I have always been puzzled why people seem to not be interested in what the optimum actually is - I thought that finding an optimum was the whole idea with using optimisation in the first place!

And yet there are more people here that seem to be content with non-optimal points. I would not be, and therefore I do not use meta things, and instead use tools that guarantee that the final output always is optimal. I have always thought that that is the whole purpose with the use of optimisation tools. But for some I guess not. I can't understand why - it seems to be a waste of time.

In the second algorithm, Grasshopper doesn't recognize the numbers as numbers, it recognized it as string, that's why it's shown in quotation marks.

Dear Dorsa Abdolhamidi, although I deviate a bit from your specific question, I recommend you check the link that I copied at the end. It is the product of a degree work on sequencing. There Daniel Da Corte makes a very good review of the literature on the subject, which can give you ideas to rethink your problem and arrive at a PPL. I have not continued working on the subject, but you can contact Da Corte, who is enrolled in Research Gate. I hope I have provided some help. Successes in your research.

Best regards,

José Hernández.

The link: http://ares.unimet.edu.ve/sistemas/fpis05/Profesor/Secuenciacion/indexEN.html

Hi

Here ts my email

Perhaps your IP is equivalent to an LP - for example single-commodity flows (including shortest path) are solvable as LP.

The NFL (not to confuse with the National Football League) is not a wild card to implement whatever stuff that comes to mind. Even in the case where an objective function isn't, say, differentiable, but at least Lipschitz continuous we do have an edge over methods that do not require anything - because they guarantee nothing either. I am referring to the flood of metaheuristics that have no natural stopping criteria beyond # iterations. In contrast Lipschitz continuity provides lower bounds that can be profitably utilized in decomposition methods, along the lines of Branch-and-Bound.

Simple:

1) Open optimization toolbox

2) Select GA solver (and enter your objective function and constraint file detail)

3) Set lower bound as 0 upper bound as 1 (this set must be as many variable)

4) Under integer variable put index of all the variable whose values to be either 0 or 1

5) Run

You can get the result.

You may require basic knowledge of how to use optimization toolbox.

Hope that you can do it now.

Sincerely,

Alam

Differential evolution is a good method. You can try with this method

Checking feasibility of an equality-constrained knapsack problem is a classic NP-complete problem, which has applications in cryptography.

If the right-hand side is reasonably small, you can solve the problem with dynamic programming.

If that is not the case, you could try the lattice basis reduction methods developed by Karen Aardal and others.

Rafael: It is not necessarily the case at all that the optimization model that you construct to represent your real problem should have, as you state, "the least number of variables". In fact, in combinatorial optimization - which is a rather large subset of the reality-based models that we want to solve - there are many successful approaches based on what is known as "column generation" methods. Such methods will simply - well, not that simply - enable fruitful variables in the original space of variables to be generated, and used to derive an optimal solution to the explicit optimization problem. Such methods have been involved in many successful applications during the last three or so decades. Just "google" the term and perhaps the problem type that you are interested in, and see if you get a hit! :-)

Of the same problem? Yes, oh yes. In large-scale integer or mixed-integer optimization, this is legio. And indeed, quite often a "richer" formulation (which typically means MANY more integer variables) means that the solver has more alternatives. Quite often the richer formulation will have a better duality gap, too.

Dear Amir,

I suggest you to see links and attached files on topic.

-Solving Two-stage Robust Optimization ... - Optimization Online

-1 Column Generation and the Cutting Stock Problem

https://resources.mpi-inf.mpg.de/.../lecture24-ColumnGenerationC...

-Chapter 3: Discrete Optimization – Integer Programming - Polimi

home.deib.polimi.it/amaldi/...16.../IP-column-generation-16-17.pd...

-Column generation strategies and decomposition approaches to the ...

Best regards

Hi everyone. I want just to make some comments regarding this issue, hoping it is still relevant for those involved in the conversation and for those who will look for a reference in it. As noted above, the fact that at least one of the variables is constrained to have discrete values makes any Mixed-integer problem by definition non-convex. Usually the way to deal with these kind of non-convex problems is through enumeration, which requires us to explore all the different possible values of those discrete variables. Since the number of combinations of the possible discrete solutions grows exponentially (e.g. with n binary variables you have 2^n possible combinations) one needs to rely on tools to avoid exploring all these combinations. Among these tools, we can solve the continuous relaxation of the original problem (defining the discrete variables as continuous variables bounded by the original discrete bounds) which can inform us on bounds for the original problem. Each time we find a solution that satisfies the original integrality constraints, i.e. that all the variables originally discrete have a discrete value and satisfy all the constraints, we find a feasible solution to the original problem which also provides a primal bound (upper bound in case you are minimizing). Every other solution of the continuous relaxation, that is solving a problem in a larger feasible region compared to the original, provides a dual bound (lower bound if minimizing) to the original problem. Using these bounds we can reduce the search space for our enumeration algorithms resulting in the famous Branch and Bound methods.

Soon after developing these methods for Mixed Integer linear programs (which by definition have a convex continuous relaxation), it was identified that the actual boundary between Polynomial solvable and Non-polynomial solvable was not in the linear/nonlinear boundary but in the convex/non convex boundary; meaning that there are polynomial algorithms to solve nonlinear convex programs. This allowed that one could solve the convex MINLP problems using the same Branch and Bound techniques with each node being Polynomial solvable. Finally, other methods relying on the decomposition of the MINLP in MILP and NLP problems were developed. The decomposition of the original problem was done though the gradient based approximation of the nonlinear functions (outer approximation), which produces a supporting hyperplane, i.e. an inequality that won't cut off any part of the feasible region, if the constraints defined a convex feasible region.

So, to the original question, whether if it is necessary to test convexity of the MILP/MINLP problems we have:

Together with some colleagues we have recently published a paper comparing solvers for convex MINLP. It is open access and you can find it here . Please let us know if you have any other question regarding this topic.

Cheers!

Some clarifications are necessary.

1. What is the purpose of efficiency? It is not mentioned later.

2. In point 2. is it exactly one worker, at least one worker or something else?

3. What parameter do you want to minimize (maximize)?

The problem could be modeled using linear programming. You can find the LP model for assignment and try to modify it. Try for some small instances to state it by hand and type it into some LP solver like CPLEX. In a few try-error iteration you should be able to formulate the problem. With correct formulation of the LP problem, you should get optimal values for instances that are not to large.

In general, the formulation should be proved to be equivalent to the problem, but that is another issue.

Olivér Ősz is right.

In principle, when modeling a problem with different modeling languages (such as GAMS, AMPL), you can expect that a global solver, such as CPlex, will return the same objective function value, no matter what modeling language you used. But...

The solution process within Cplex is different, when you present the variables and constraints in a different ordering. And you have no control about the ordering of those (i.e. the interface between the modeling language and the solver), and even if you would have that kind of control, there's no general strategy to find a good ordering (for example, and ordering that leads to minimum runtime).

What does that mean for you? In case you have an easy problem with a unique optimum, you would not feel much difference from using different modeling languages or different MIP solvers.

In case you have multiple optima, you might get different solutions from different modeling languages (although, of course, they have the same objective function value).

In case your problem is too difficult to find a global optimal solution in finite time, and you terminate the solution process prematurely, then you will easily end up with very different solutions and very different objective function values, depending on the modeling language you have used.

Dear Fatemeh,

Maybe I am getting too late into this discussion. What I would do is to solve the following problem P:

minimize (1,1,...,1)' e

(Y-Zx) > -e

-(Y-Zx) > -e

a <= x_i <= b for each vector variable component

and programming myself a simple branch and bound algorithm:

1. Solve P

2. check whether some variable x_i has a value that is different from a or b.

3. (branching) Say you find that x_t is a < x_t < b. Then solve the following two problems:

P1

minimize (1,1,...,1)' e

(Y-Zx) > -e

-(Y-Zx) > -e

x_t = a

P2

minimize (1,1,...,1)' e

(Y-Zx) > -e

-(Y-Zx) > -e

x_t = b

4. Perform step 3 on the solutions of all problems you have.

5. (bounding) . Stop branching if:

- the solution of a problem is infeasible

- all variables in the solution have values either a or b ("integer" solution)

- the solution of the problem still contains variables with values different to a or b, but the objective is worse than a previously found "integer" solution.

I know it is brut force, but it will keep the structure of your problem and will guarantee what you want. And, it is very easy to program.

Hope it helps.

Vlad

Your constraint relating X and Y with P is inherently non-convex (unless P has some special property). So it looks like binary variables are indeed necessary.

The relaxation by the Simplex method solves the MILP for certain special classes - if the problem matrix is (totally) unimodular, e.g. the node-arc-incidence matrix of a directed graph.

So there are MILPs where the representation by the constraints really give the convex hull of the feasible (integer) points and the solution of the problem just is solving an LP.

A representation by a CONVEX problem would require to know the facets of the convex hull of the integer feasible points.

If you succeed to do that for an arbitrary problem with binary variables you'll be a good candidate for the Fields medal.

The non-convex equation mentioned above exactly represents a binary variable and consequently the non-convex nonlinear problem is as hard to solve as the original BIP - but by other methods.

I don't know of an (even non-convex) representation for a general integer variable by similar means.

3-D Bin packing - when packing groceries, your suitcase, build your bookshelf, or arrange your books in it, storing hobby things, or the left-overs in the basement. :-)

People who are on a diet can optimize it so that it matches the nutritional values and maximizes its tastefulness - or minimizes its cost. (The diet problem is a classic LP one.)

It is one possibility to always choose the larges fractional value - but by no means the only one. The choice of the branching variable especially in the beginning is very important for the size of the resulting tree.

Unfortunately there is no way to know the optimal choice a priori,

The answer of Daniel Molina Pérez pointed out two means incorporated in many solvers.

The backwards looking one is called pseudo costs branching in CPLEX. It records the changes in the LP bound by branching on te variables and chooses one which gave the greatest change. Of course this information is not available in the beginning.

The forward looking one is called strong branching and does a limited number of simplex steps on some chosen candidate branching variables to see which one gives the greatest improvement of the bound.

There is a third way offered by most solvers: that the user (who knows his model much better than the solver) identifies 'important' variables by assigning a higher branching priority.

I really encourage you to do a literature search. Have a look to Wolsey's book, too.

Besides the choice of the branching variable the implementation of clever heuristics is very important since early knowledge of good primal bounds would allow for earlier inferiority cutoffs and reduces the size of the B&B tree considerably.

The excellent commercial solvers like Gurobi and CPLEX contain a lot of techniques to speed up the solution process and their defaults are carefully tuned to a large set of test problems . But though these defaults perform best 'in the mean' still the right choice of parameters for any particular MIP is a kind of art.

Unconstrained Quadratic Integer Programming is strongly NP-hard even when the objective function is convex. The proof is by reduction from the Closest Vector Problem.

Dear Sir

Dear Kelvin,

The equation [x/a] + [y/b] = c, where  [  ] is the floor function, has the 

general  solution:  x = ma + r and y = (c-m)b + s,

where m is any arbitrary integer,  0 ≤ r < a and  0 ≤ s < b.

Now, you need x = y  > 0  to obtain positive  solutions x for  [x/a] + [x/b] = c ,

direct substitution shows m = ( bc + s - r )/(a+b).

Next, you test all possible values of s and r to give a list of all possible positive integer values of m. Otherwise the equation has no solution.

Example :  [x/2] + [x/3] = 5.

m = ( bc + s - r )/(a+b) = ( 15 + s - r )/(5)  where  0 ≤ r < 2 and  0 ≤ s <3.

All possible values of m are {3,14/5,13/5,16/5} , m= 3 is the only positive integer solution.

Therefore x = ma +r  provides  6 and 7  are all possible solutions for   [x/2] + [x/3] = 5.

Best wishes 

The only way to get error bounds is through the use of deterministic solvers.  Additionally, if the problem is nonconvex when integrality is relaxed, you will need a global MINLP solver for valid error bounds.  There are several global MINLP solvers available nowadays; all are based on branch and bound technology.  The global MINLP solvers BARON, ANTIGONE, SCIP, LINDOGLOBAL and COUENNE are all available under GAMS; some of them are available under AMPL and AIMMS.  Some comparisons between these solvers are provided in Mittelmann's site at http://plato.asu.edu/ftp/minlp.html.  BARON, in particular, is available for free through the NEOS server.  It is also available in commercial forms from GAMS, AIMMS, AMPL and minlp.com.  The minlp.com distribution can run under MATLAB, YALMIP, Pyomo and JuMP.  The BARON option you can use for faster termination is called deltaTerm.

You may need to reduce the dimensionality of the data using the Genetic algorithm in conjunction with another algorithm (an evaluator) that evaluates the merit of the selected subset before applying classification/regression algorithm. Or you could try other search methods, such as a Ranker method--it might be useful in your case and has a fast performance. 

HTH.

Samer

You can also take a look at this paper:

In the case when integer programming is equivalent to linear programming - such as is the case with integer programs that are equivalent to linear network flow problems (like the shortest paths problem) - the KKT conditions are necessary and sufficient. But for integer programs that cannot be translated into a network flow problem or a 2-matroid problem this is not going to work. 

there is no such optimization technique which we said it is the best. so u have to choose according to your application what you basically required as in most of the optimization techniques there are two processes one is exploitation and second is exploration. now its depends upon your application what are you want .........

Note that valid inequality tighten the feasible region of the problem which is formed by the constraints (not by the objective functions). Therefore, there is no obstacle to use the linear relaxation. However, you can also use the computational time as another index to evaluate valid inequalities.

Dear Abhinav Kumar Sharma,

Code of NSGA_II is very complicated and in each iteration you should be sure about the correctness of the new matrixes. It may be a defect in this matter.

Better than rounding - and sure to lead to an optimal solution, is to use Land-Doig-Dakin. (I am however not saying that this method is a "killer", but that it provides some insights into how to think about the link between linear and integer programming.) Imagine that you first solve the LP (that is, continuous) relaxation. Among those variable  values that are fractional, and in particular farthest from being integer, you can add two branches in a search tree: in the first you add the extra constraint that that variable's value must be lower than the value rounded down to the nearest integer; in the other branch you specify that the value must be at least as high as the value rounded up. You now have two branches to solve the LP problem in, with the added bonus that you have narrowed down the search. If you keep on doing this, while also applying all the cutting rules that Branch-and-Bound has (cut if a local lower bound is worse than the value of a known feasible solution, for example, or that one branch's problem is even infeasible). This may not be quick, but it is instrumental to show how branch-and-bound actually works.

Dear Mohamed-Mourad

Thank you very much for your kind and prompt response.

The paper are very interesting. I'm eager to read them,  and I'm particularly enjoyed to know there is an expert not far from me with whom I can cooperate.

Best regards

Salim

Dear Abhinav,

Here is attached files in subject.

Best regards

See "Logical Analysis of Numerical Data" by Boros et al.

Thanks Iago

Much appreciated, i just browsed quickly through it, a fascinating and very well written note, i must say Wow

Hi Pradyumna:

OK, so I gather Silobinvar(S,t) =(0,1) if silo s is selected to receive product in time t

and Recipebinvar(r,t) =(0,1) if recipe r is being produced in time t.    You want to only select one silo in any time period so, SUM_s(Silobinvar(s,t) =1 for all t.

You also want to keep silo s selected for as may consecutive periods as it takes to fill silo. another way to say that is you want to minimize the cumulative transitions from non-filling to filling states for all silos.  

Suppose you consider Silo(s,t+1)-Silo(s,t) =u(s,t+1) - v(s,t+1). and add min epsilon*Sum_s,t (u(s,t)). to the objective function.  epsilon is small enough so it otherwise does not affect the optimal solution, but all else equal this chooses fill patterns that only start to fill (u(s,t+1)>0) once.  (Check this logic.  on first blush it does not appear to me you need to min eps*SUM_s,t (u(s,t)+v(s,t)), but adding this does not appear to matter, since their difference will equal Silobinvar(s,t,) for all s and t, and minimizing one should minimize the other.  since their difference will always be 0 or 1, they should not even need to be declared integer.. Check the logic on this to confirm this works.  Probably need some special treatment of first and/or last period as well.

I presume you have other constraints that drive the solution to completely filled silos - i.e. no partially filled silos are feasible/optimal. so this would drive solutions that fill the silos but only start to fill once - and therefore once they start filling they don't stop until the silo is full.   

If on the other hand there are no other constraints that force the silos to be full, this will not be sufficient.  If the latter you may need to think about more binary variables X(r,s,t) = (0,1) if recipe r is being put into silo s at time t.

Alternatively you could look at the so-called unit commitment problem for electric utilities.  this problem selects the generating units that are available and unavailable, and some units (like large thermal/nuclear plants have startup times and shut down times that need to be enforced, and once they are online they stay online for consecutive time periods - unlike peaking units or hydropower that can be dispatched quickly with little to no startup and then shut down without a cooling period.

There is a huge literature on this with many different algorithns - primal-dual methods have received much attention.  Note the unit commitment problem is typically closely coupled with the economic dispatch problem:  given the units currently committed (available) distribute the current period demand across the available units to minimize generating costs (and other secondary objectives).  These problems obviously link across time periods based on projected demand.

One of Dantzig's last papers was on the stochastic version of this problem with Gerd Infanger in the European journal of operations research:  

Intelligent control and optimization under uncertainty with application to hydro power  By:Dantzig, GB (Dantzig, GB); Infanger, G (Infanger, G)  EUROPEAN JOURNAL OF OPERATIONAL RESEARCH.  Volume: 97. Issue: 2. Pages: 396-407

DOI: 10.1016/S0377-2217(96)00206-8

Hope this is of some help

Dear Victor,

First way : If the fonction is non-linear, non-quadratic, non-convex on linear and quadratic functions much better search policies are available.

Second way : support vector machine learning via quadratic programming or Genetic Algorithm.

Here is some reference in subject.

-Hansen, Ostermeier, Gawelczyk (1995). On the adaptation of arbitrary normal mutation distributions in evolution strategies: The generating set adaptation. Sixth ICGA, pp. 57-64, Morgan Kaufmann

- 2Salomon (1996). "Reevaluating Genetic Algorithm Performance under Coordinate Rotation of Benchmark Functions; A survey of some theoretical and practical aspects of genetic algorithms." BioSystems, 39(3):263-278

Best regards

Thanks for your help.

Perhaps you don't need to use MatLab at all?  If you wish to solve the Lagrangian dual via the subgradient method, then it is easy to write your own little function (say in C) to update the multipliers.  Alternatively, if you want to solve the Lagrangian dual using the Bundle method, then the problem of updating the multipliers is a convex quadratic program, which CPLEX can solve easily.  In either case, you can still draw on CPLEX to solve the relaxed problems (which I understand are MIPs).

 Good easy fix. So start from k+1 instead of k for 2nd coordinate and it is enough to get n=2k different pairs, using otherwise the same formula. Thanks I.E. Kaporin. Seems completely settled now.

Perhaps you  could clarify? I don't see a mention of the word offset in the page as it exists today (2016/05/15). You probably already know the definition available at http://oeis.org/wiki/Offsets. 

Yes of course you can model any scheduling problem with Mathematical model and after that write it on a solver like Cplex or implement your own exact method like brunch and bound. But what do you mean by a "general approach "? you can find a large variety of formulating scheduling problem in the literature and what you can do is trying to be inspired about that works like how the constraints are formulated and try to formulate "mathematically" the constraints of your problem", but a "GENERAL" formulation that you can apply to any scheduling problem?!! No, I don't think so,... maybe two or three constrains but not all the model because each problem has his specific contraints to take on concideration

Kindly, have a look on the following publication.

If you did not need to preserve the value of your floating point numbers, but just model them (represent them unequivocally) you could simply take the significand and the exponent of the floating point, find the prime numbers whose order corresponds to their values, and model them through the product  of those primes. Then you would have an integer for each floating point.

But you probably need to preserve the exact value of the floating point numbers. In that case, if a sequence of integer ratios is acceptable I would suggest you convert the floating points to their rational number equivalents: p/q, with p and q integers. Take a look at the following link:

Kind regards

Fernando

Hello Tsambani,

                 Firstly, thanks for the answer. But I don't find anything useful in the link you provided. My question was something totally different.

Thanks and Regards

Shree

The previous answer is great and gives some good examples. Another "reason" for ILP that I might add is that it is often the most obvious and most straightforward way to represent the selection of discrete alternatives (for example a binary variable X_ j is 1 or 0). I'd even ask what would you do instead? Perhaps represent X_ j as a real number bounded by 1 and zero (relaxation of the problem). This is a strategy for attacking the case, but you would have to agree that fractional solutions are not representative of the real problem that we have set. (This occurs in facility location, portfolio selection, and many other areas.) So the problem might require branch and bound or other implicit enumeration schemes to finish off the selection of only integer solutions.

I think that if you want to understand some of the beauty (and difficulty) of ILP check out the knapsack problem. Almost as simple as you could imagine, and yet there are integer variables with real meaning and significance for this model. While this is "difficult" it has not stopped clever algorithmic approaches that improve over the most obvious greedy heuristic.

Integer programming problems are np-hard so you are not looking for whether the solution is optimal (you would not be able to find one if the problem is big, as it seems). So you are just wondering if the solution is feasible. 

If it is an exact problem (objective functions f=0) just replace the variables with the solution values and see if they verify the equation.

If not or if you want more confidence you can compare the solution with random variable values and see how much better it behaves. If the solution is quite better than randomness GAMS is probably doing things right. It is also advisable to check which model GAMS is using, to make sure it is the right one.

Kind regards.

Fernando.

This thread seems to address both the question of which cuts are best for the LRP, and how to add them using MATLAB.    Regarding the second question, MATLAB is not well suited to the cut and lazy constraint callback functions that offer the best way to add cuts dynamically during the MIP optimization (as Yasser pointed out)..   Therefore, the best you can do with with either the Toolbox functions like intlinprob(), the corresponding CPLEX toolbox functions (e.g., cplexmilp()),  or the Class API that CPLEX also offers consists of solving your MIP, adding your elimination constraints, then reoptimizing from scratch.    This will probably run much slower than implementing this using CPLEX's C, C++, Java or Python APIs and using the lazy constraint callback to add the constraints (DFJ, MTZ or otherwise) to eliminate the subtours and continue the optimization.  You would avoid having to restart with each new batch of subtour elimination constraints you create.

I am using TOMLAB for this purpose. It is an interface (add-on) for MATLAB, so that you can formulate MILPs and solve them via various (commercial and free) solvers. Examples how to set up models come with the TOMLAB software.

Have a look at these implementations, which are all combinatorial and permutation type optimization problems, and solved using various algorithms:

VRP: http://yarpiz.com/372/ypap108-vehicle-routing-problem

Scheduling: http://yarpiz.com/367/ypap107-parallel-machine-scheduling

QAP: http://yarpiz.com/359/ypap104-quadratic-assignment-problem

Despite the differences between these problems, however mathematically they are almost equivalent in the sense of solution representation. The solution of all problems mentioned above, can be represented as a permutation.

It depends on the problem and on your time requirements. Have you already tried it? Don't trust that theoretical excuse that the problem is NP-hard etc... Modern solvers as CPLEX are very fast and reliable. Give it a try. In addition, B & B provides lower and upper bounds on the optimal solution, so that you can stop the search before reaching an optimal solution and you know how far you are from an optimum. Heuristic procedures as rounding cannot give you any guarantees on the quality of the solution. Heuristics is a good choice only if you have very strict time constraints, such as in real-time applications.

@Robin: By initializing i with the first odd number within the given range of n to x in  for (i = n; i <= x; i++)  and using i += 2 instead of i++, the number of iterations can be reduced by half. It would make your script still faster.

I'm surprised there are many samples in LINGO manual and Linus textbooks. I developed many application by learning those samples.

See my papers after 2014.

And your student contact LINDO directly.

Hi Lukasz,

This helps too:

Geetha

You can use projects like OpenOpt (http://openopt.org/cplex), NeosSolvers (http://www.neos-server.org/neos/solvers/) or IBM Decision Optimization Cloud (http://www-969.ibm.com/software/analytics/docloud/).

Neos is free, IBM project has free trial period.

From my own experience, I'd recommend IBM project. You just register on their website, write you LP or MILP problem to a .LP or .MPS file, upload this file to their server and run the solver. In IBM project, free access has a limitation: no more than 1 or 2 hours of calculations for 1 problem. All my problems were solved within this time limit while it took more than 10 hours on myhome computer. For money, there are no limits.

I think you have to find a way for 2 objectives. Weighting, Lexicographic, Distance Function, Min-Max formulation or Pareto-optimal approaches  are classical for dealing with multi-objectives.

I used to solve this problem by multi-objective GA implemented in C++. It's efficient and quickly

Do you mean that RandomInteger[{0, 2^31 - 1}] gives you integer number that are occasionally higher than 2^31-1? That would indeed be a bug.

The suggestion that you give would return numbers in the range 1073741824 (2*2^29) to 2147483649 (1+2*2^30).

A more intuitive way to generate a random 31-bit number, albeit not the fastest, is to first generate a list with 31 binary digits, and then convert it to an integer number:

FromDigits[RandomInteger[{0, 1}, 31], 2]

Generally Benders Decomposition is suitable for problems with complicating variables, i.e. if you fix some variables the solution of the problem become more simple. DW is suitable for problems with complicating constraints. In LP, dual of a problem with complicating variables will be a problem with complicating constraints.

In MINLP problem, using BD, the problem is converted into a set of IP and NLP problems which are solved iteratively.

Hi

Please see these links: