Linear Programming - Science topic

I asked that question to the person who code that package, and he said C(9) coefficient does not have any meaning here, just ignore. It comes up because the package is written for the old version of Eviews and has not been updated that is why.

Dear B.V Baranidharan

The link that Mohamed-Mourad Lafifi mentioned is useful. In addition, to finding code kindly check GitHub:

See the following comprehensive references:

1) Linear Programming and Network Flows

Book by Hanif D. Sherali, John J. Jarvis, and M. S. Bazaraa

2) Linear Programming, 1983

Book by Katta G. Murty

Hi Sibabalo,

Do you get an answer to your question? I have your problem now.

Thanks

Sanchit Saran Agarwal

These links might help:

1. https://www.energyplan.eu/othertools/national/markaltimes/

2. https://iea-etsap.org/markal/faq.html

Two main problems in the perspective of SG:

*Integration of Microgrid, while considering uncertain factors and limitations of the present grid.

*Integration of charging stations for EVs taking into view users' profiles and traditional grid capacity.

In general, it is not a better metaheuristic than the other ones. But there are general approaches for facing the practical problems: in your cases it is needed to make evolve one or more solutions populations. In the work attached you could find a useful approach for facing your problem. Neverless, would be useful using more than one metaheuristic and to compare them by different indicators

Dear R. M. Fouad,

Also i suggest you to see links on topic.

Best regards

Most LPs arising in practice can be solved quickly using simplex. For very large and/or degenerate instances, interior point methods (IPMs) may be faster. Many solvers (e.g., CPLEX, Gurobi, Xpress, MOSEK) allow the user to try several methods.

I am just exploring different methods for this phase, but as you said, once the defuzzification is done I will find the solution. I particularly want to explore alpha-cuts based methods.

In case of MATLAB you can try this:

CLC; clear;

P=[1:10]; %can work for any size or elements of P

Y=[1 1 0 1 1 1 0 1 1 1];

Q=P;

for i=1:length(p)

If y(i) ==0

Q(i)=0;

Q(i+1:end)=P(1:end-i)

end

end

In addition we have a few special algorithms for large-scale problems, such as

Benders decomposition, Dantzig-Wolfe decomposition, and more varieties of

decomposition tools.

If you have access to multiple solvers you can try Pyomo framework (https://pyomo.readthedocs.io/en/stable/#). Using Pyomo you can test multiple solvers for example AMPL, PICO, CBC, CPLEX, IPOPT, Gurobi and GLPK; then you can decide which solver is better for the problem you want to solve.

Also, in Wikipedia you can find a list of solvers https://en.wikipedia.org/wiki/List_of_optimization_software

My best regards,

Yes, I have some files of solution for linear programming with solver in excel, I can share with you

Have a look at https://www.kite.com/python/docs/sklearn.svm.LinearSVR

OR: https://genstat.kb.vsni.co.uk/knowledge-base/svmfit/

The complexity of the simplex algorithm is an exponential-time algorithm. In 1972, Keely and Minty proved that the simplex algorithm is an exponential-time algorithm by one example. On the other hand, the simplex algorithm is behaving in the polynomial-time algorithm for solving real-life problems.

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:

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.

Some useful contextualization for the simplest variant of the vehicle routing problem (the CVRP):

• The Christofides, Mingozzi, and Toth [CMT] vehicle routing instances with up to 200 clients have been released in 1979, and it took around 35 years of research and progress on exact methods to solve them optimally. In particular, simple MILP formulation for the CVRP (e.g., two-index vehicle flow formulation) can only solve some problems with a few dozes of clients.

• For the newer Uchoa et al. [X] instances with 100 to 1000 clients, there are monetary prizes for anyone able to consistently solve them to optimality (http://vrp.atd-lab.inf.puc-rio.br/index.php/en/cvrp-challenge). So far, this prize remains unclaimed, and many instances with as few as 300 customers remain unsolved.

• Practical applications often involve >5,000 clients (!!!) and *many* complicating constraints, additional decisions, and objectives called "attributes". Application cases with over 50,000 stops/clients are also quite common in courier delivery and refuse collection. Opting for an optimal solution through MILP in these situations is a guaranteed failure, and it usually reflects a lack of practical experience in the field. Even good lower bounds can be hard to get when problem size grows.

Dear Liming, at a first glance the problem seems not to have a unique solution in general. Assuming for example that all the matrices are nxn, you need to solve n² equations (corresponding to the elements of B) in 2n² unknowns (the elements of X and Y.

If what matters is to find a solution, even if not unique, a possible approach could be to look for a minimum of the norm ||XAY-B|| with respect to the entries x_ij and y_ij. To get a differentiable function, one could take the Frobenius norm of the residual XAY-B.

Dear All,

I'm totally agree with colleague Paul Oke.

Best regards

To answer to criticism of spurious regression, if it is time trended. Causality is still a bigger issue than just uncovering stationarity of time dated series. We need the theory to guide us and the use of statistics in experimental research design to handle causality is still not resolve.

Yes. Still studies are going on in some countries and areas. Some studies are concentrating on Agricultural Policy Impact Analysis with Multi-Market Models.

Hi Raphael Santos

I have used most of the tools mentioned before. While each of them has its strengths and weaknesses, nowadays I have been constantly relying on the same tool for solving all kinds of optimization problems.

This tool is a combination of Julia programming language with the Julia package JuMP which defines (in my opinion) the most elegant and intuitive modeling language that makes it easy to try different solvers on the same problem by simply changing the solver name in the code. It also allows easy access to more advanced features of MILP solvers such as generic support for callback functions that can be used to modify the problem while solving it with the addition of valid inequalities and user-defined heuristics.

As an example, solving the TSP using the DFJ (Danzig-Fulkerson-Johnson) formulation that has an exponential number of subtour elimination constraints is straightforward with JuMP. You can simply set up a "lazy constraint callback" function that will check if subtours are present in the solution and if not, add constraints to break these subtours. This is particularly easy when considering only integer solutions, but you can also use the "user callback" function to cut off fractional subtours. JuMP has turorials of several important modeling paradigms that can be used as a basis for your model. Here are the relevant links:

You can download Julia programming language from

Website for the JuMP package

Tutorials for modeling with JuMP

More example problems solved with JuMP

Best regards

Juho

Dear Lars

I agreed 100 % with you in that a Solver must identify unfeasibility, but my question is: How many solvers or MCDM methods do you know that have that capacity?

Only one: Linear Programming

The procedure is very simple: It compares criteria independent values, and if a solution satisfies these values. If only one criterion is not satisfied the project is unfeasible.

Nowadays, problems are 'solved' assuming that a problem is feasible, not taking into account that t hat circumstance may not exist.

I have read hundreds of comments and papers from our colleagues. How many of them posed this problem?

Nobody.

I wrote in RG almost a year ago about this problem, you can see it in my profile under the number 304, and again, in May 2020 under the number 318. Both have had some moderate reading but nobody came forward to acknowledge and discuss it. You are the only person that addresses that issue.

Regarding LocalSolver I know what it, is but my experience on it is null.

Arnold Sher

Thanks a lot sir for sharing this good content.

A multi-depot VRP with less than 10 nodes should be almost enumerable, as there exist less than 1024 possible subsets of customers. Given this fact, perhaps the simplest solution approach is to generate all feasible routes from each depot, discard those that are not TSP-optimal, and directly solve a set partitioning formulation based on these routes. Now, if you face larger problems (e.g., 15 nodes or more), you should use the formulations suggested by Adam and Noha, or even go for sophisticated branch-and-price approaches as described in

since the code associated with this paper is freely accessible at

Thank you all friends. I added all the primal constraints with the strong duality constraint which connects primal and dual variables together. it worked and primal and dual variables were calculated simultaneously by the solver.

I appreciate all above answers, and they are very helpful! Ralf Gollmer Gary Paul Martin Simpson Nuno Miguel Marques de Sousa Mohamed-Mourad Lafifi

If you have solved one of the primal or dual LP problems, you can derive the solution to the other without having solved another problem - IF the problems are not degenerate - and that seldom appears in practice. But when they do occur, you have a simple solution to that bug also.

Hello,

You need to debug your code first. You may need to test each part of your code to see if you get any feasible results. For example, instead of the objective function, use a dummy function to check if the equations are correct. Moreover, disable all the constraints to see if your problem is defined correctly. Remove each equation one by one and check the effect on your results.

O.k., of course you can use any heuristic method. It will give you SOME result - and you'll never kow whether tar solution is even close to optimal.

I strongly support Michaelk Patriksson's reply: try a really good MIP solver like CPLEX or Gurobi (which are free for academic use). And only if these take too long or are even unable to find a feasible solution the usage of a heuristics is justified.

Btw. many of the heuristics have problems fulfilling linear constraints being no simple bounds....

Good topic can please provide more information

You can simply use MSExcel data analysis tool pack to develop your optimization problem and solve. You can find lots of videos in YouTube. Good luck.

Hey guys thanks, I later noticed it was an inventory problem and not an LPP. The student I was supposed to solve for said he wanted to solve an LPP but I later did more research and found it was an Inventory Problem. Thanks anyways.

Temitayo Bankole I am afraid that this procedure only works for LP problems, while I am dealing with the MILP problem, job-shop scheduling.

Dear Nouran,

You can find the answer in this paper:

https://www.mdpi.com/2073-8994/12/2/243

Best regards,

Sarbast

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

The Simplex algorithm is a mathematical tool primarily. Some statistical fitting problems can be cast as a linear program, but I consider this incidental.

GAMS itself is no solver, it is a modeling system with interfaces to a number of solvers - Gurobi being one of them.

So there is no point in trying to compare GAMS with any solver.

Gurobi is a solver for linear and (convex) quadratic mixed-integer problems.

GAMS has interfaces to solvers for different problem classes, too (like more general nonlinear optimization problems).

But if your problem is a MILP, you might compare the modeling via GAMS with the modeling via the Gurobi Python API.

I have worked with both (and with other modeling systems like AMPL, OPL and other solvers, especially CPLEX) in research on discrete stochastic optimization. The choice of the modeling interface depends simply on your preferences and the tasks to be performed (like modifying the problem according to the solution and solving a series of problems). If you are used to the GAMS language you might prefer it to others. GAMS and AMPL are not free software and you have to pay for many of the solvers for them, too.

Best regards

Ralf

I think that rounding approach is the best, whether before evaluating the objective function or after evaluating the objective function because in both cases the reason for the same result occurs.

This question, like many others you have posted in the last few days, can all be answered in the same way: it depends on the problems you are wanting to solve.

I would suggest looking at the results of the Black Box Optimisation Benchmarks (BBOB).

There are many different algorithms that are compared and many are freely available via github, or from the authors of the codes. The tremendous advantage is that you can see how they perform on many different types of problems, some of which might be similar to what are wanting to solve in your own work. Furthermore, you won't have to trawl through reams of cloying self-assessment and self-appraisal of many commercial products which, not surprisingly, are always fulsome in praise of their own product.

As recommended by Michael Patriksson, I also recommend that you attempt to solve (or get bounds for) at least small instances of your problem with mathematical programming algorithms such as COUENNE (https://projects.coin-or.org/Couenne) or other similar solvers. Beyond the insights on problem structure that you may learn in the process, this will also help to assess the solution quality of your metaheuristic on small datasets.

Now, regarding the impact of initial solutions in population-based search (e.g., genetic algorithms), you should have two general goals in mind: (1) diversity, (2) quality. For some problems, spending a lot of (coding and computational) effort to generate clever solutions is not worth it, as in a fraction of seconds your population-based algorithm may retrieve solutions of equally good or better quality. In such situations, ad-hoc construction techniques may even lead to reduce your population diversity without a clear benefit. For example, for some combinatorial optimization problems arising in transportation and logistics (vehicle routing problem), we had much more success with a randomized initial population subject to local search (equivalent to gradient descent in continuous space) as this would much better sample our search space. Moreover, diversity is important in the initial stages of the search as well as later on, and therefore should be actively preserved to avoid phenomenons of premature convergence.

You do not have to implement it by yourself. Many solvers have already built-in multistart routines. For example:

Not for the chance of plugging a paper written me and a colleague, but the link below is a thorough analysis of what optimality means:

The above is the last preprint - here is the permanent link to Oper Res:

Optimization algorithms are really pretty simple. Just keep climbing up the hill until you get to the top. Take some precautions to make sure your step size isn't too big and try many different starting points far away form the optimum to make sure you have found the true optimum an not just a local optimum.

As I indicated in my answer to your previous similar question, you have to demonstrate insensitivity to initial solution (or starting search points) for at least a few dozens of them or more, not just a few of them. Your initial solutions (starting search points) must be random uniformly distributed points in the multidimensional solution domain. Again, there is no rigorous proof that your solution found this way is the global one. You may only state that there is a high probability that it is the global (but not 100%). The more initial solutions were use the higher that probability.

Dear Anshik,

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

Best regards

I would not make such a statement in a paper. It can be easily be refuted.

If an algorithm is unable to walk from a local solution to a better local solution, it only means that it locally converges. The global solution could be far away from that local one.

In general, I would use a set of uniformly random starting points for finding a set of local optimal solutions. If these local solutions found from different starting points are close enough to each other (or the same), then it is likely that this is the global solution. The more random starting points you use (the bigger the density of the starting points in the solution domain) the higher the probability that the solution is global. However, there is no rigorous proof of that. This will be just a heuristic judgement.

I would refrain from the use of higher order partial derivatives (higher than 2). Numerical calculation of high order partial derivatives is computationally unstable, lose the numerical accuracy very fast, up to total non-usability for deciding on the new step in search of the solution.

You problem is equivalent to (if I understand your notation):

X=k1(z1+y1+q1)+k2(z2+y2+q2)+k3(z3+y3+q3)->max

If z, y, q are given constants, then their sums are also given constants, say K1, K2, K3

X=k1*K1 + k2*K2 +k3*K3 ->max

There are no constraints for the decision variables k1, k2, k3.

This is a linear form that is maximized as these variables take unlimited max values......, hence there is no unique solution. Something is missing in your problem statement.

I would suggest to make your initial point (initial solution) better. Probably your solver from current initial point only finds local optima.

It's called an accounting row. It is an equation that simply adds things up.

x1 + x2 - Y = 0

Later, these things that are added up can also be constrained.

Y < 100

or

Y > 10

Yes, there are a number of softwares which can solve linear programming problem in a click giving the optimal solution or an indication of in-feasibility or unbounded solution. But, that is second stage. First stage is to learn the basics of linear programming solution procedures i.e. graphical method and Simplex method. The students will have in-depth knowledge of such procedures by manually solving them. Once got acquainted with the procedure, they can use software like Lindo, Matlab etc. to solve the complex LP problems which can not be handled manually.

Convex optimization involves minimizing a convex objective function (or maximizing a concave objective function) over a convex set of constraints.

Linear programming is a special case of convex optimization where the objective function is linear and the constraints consist of linear equalities and inequalities.

Nonlinear programming concerns optimization where at least one of the objective function and constraints is nonlinear.

(Adapted from Mathematical optimization: Major subfields on Wikipedia.)

Therefore, convex optimization overlaps both linear and nonlinear programming, being a proper superset of the former and a proper subset of the latter. However, note that nonlinear programming, while technically including convex optimization (and excluding linear programming), can be used to refer to situations where the problem is not known to be convex (see Boyd and Vandenberghe, p. 9, below). Hence, it may be more useful in practice to think of a hierarchy: linear - convex - nonlinear. Another useful view is given by the following quote, kindly supplied by littleO: "The great watershed in optimization isn't between linearity and nonlinearity, but convexity and nonconvexity." -- R. Tyrrell Rockafellar, in SIAM Review, 1993

That's right. More precisely, if an inequality is of "<=" type, we use convex under-estimators for the left-hand side. If the inequality is of ">=" type, we use concave over-estimators (or you can just multiply the inequality by -1).

McCormick's original paper (from 1972) explains this very well. So does this paper:

Ryoo, H. S., & Sahinidis, N. V. (1996). A branch-and-reduce approach to global optimization. Journal of global optimization, 8(2), 107-138.

Please have a look at this attached chapter and hopefully you find your answer

Refer the following:

https://www.emerald.com/insight/content/doi/10.1108/BIJ-10-2017-0281/full/html

https://www.emerald.com/insight/content/doi/10.1108/JM2-12-2012-0042/full/html

https://www.emerald.com/insight/content/doi/10.1108/17410381311292340/full/html

https://www.emerald.com/insight/content/doi/10.1108/JM2-02-2014-0012/full/html

http://netlib.org/lp/ has a nice collection of large-scale LP problems.

Also see http://www.numerical.rl.ac.uk/cute/netlib.html .

Thank you Katarzyna

I believe that we have a misunderstanding.

I agree with your definition of variables, but I DON’T CALL as ‘criterion’ an objective function. NOT in LP, although YES in SIMUS, because in this method criteria and objective functions are interchangeable.

But in general, in MCDM, my definition of criterion or constraint is exactly the same as yours, as well as your definition of performance values. However, if it is true that criteria ‘constrain’ the alternatives, I prefer to use the term ‘constrain’ for the values which are limits or thresholds of criteria, that is, the RHSs, because they constrain the range of validity of criteria. In reality, criteria ‘force’ the alternatives to respect some conditions, which in turn may be high or low, and bounded by the RHSs.

You mentioned before that you had 2500 variables or alternatives, and you say that there are 3 production units; does it mean that each production unit may have many alternatives?

Can a particular alternative, be replicated in any number of production units? For instance, alternative 789 can be in units A and C, or even in A, B and C, while other alternatives may only be in one of them?

When you say that other variables are placed, are you referring to artificial and slack variables? If this is so, it is strange, since the solver adds them automatically, or maybe I did not understand your statement.

I assume that you want to know how production of unit B changes when you modify the RHS of some constants, for instance # 1.

What do you mean by ‘I display’ constraint #1 up, constraint 1, and constrain # 1 down? I understand that you want to say is that you can put low and high limits for constraint # 1. Is this correct?

I have two questions for this:

1. Why you consider a constrain 1, when if you have low and high limits defined by ≥ and ≤ operators respectively, constraint 1 is included in the range? In my opinion that arrangement may cause you to get an infeasible solution, because if the model select a value between the two ends, how does it manage to also comply with constraint 1, which I imagine has the ‘=’ operator?

2. How do you know that constraint 1 or any other is the one you have to work with? It could very well be that said constraint does not have any influence in the alternatives selected. That is, you have to work with the criteria that are responsible for the selection, maybe one or several. Once determined, you will have the certainty that these will change the solution found. If you work with constraint that are not relevant, you can increment and decrement by changing their RHSs, and you will see that there will be no change in the selection.

This information, as you know, is in the dual, or you can see directly in the Solver screen for sensitivity analysis (SA). Of course, you know all of this, but my comment derives because you don’t explain why criterion 1 is selected for SA.

No, I was not referring to the objective function Z coefficients. I am referring to changes in the RHSs.

To your question, my answer is that yes, you can. Each time you modify the RHS of a binding constraint and use the Simplex, you can immediately see the new values of the alternatives.

It is extremely useful to work at the same time with the dual, and once you get the new values for the alternatives go to ‘sensitivity’ (in Solver you have to run the Solver twice for each RHS change, the first gives you the new alternative values, and then you have to run it again in order to get the sensitivity analysis screen), that gives a lot of information, such as the shadow prices, the relevant criteria, the validity range for each shadow price, as well as the reduced costs.

For my software, don’t worry, you can have it any time you want.

I understand that there is a mistake when you say that the slope is determined by the reduced cost value.

The slope is given by the shadow prices. The reduced cost tells you how much you have to modify a coefficient in the objective function in order that the corresponding alternative enters in the solution. Observe that the reduced cost for selected variables is zero.

Outside the range nothing happens, because the criteria that you were using is no longer binding, and the alternative keeps it last value.

In your next paragraph, you say: ‘But if I change RHS to some value outside of the range, I can see that indeed, basis have been changed as well, but the change is related to, for example, a variable indicating the production in unit A jumped from 50 to 0’.

Yes, you are right, if the base changes, there will be another variable instead of A, and this one will be zero.

The jump from 50 to 0, means that when the upper/lower limit of the range is exceeded, that variable no longer belongs to the solution, and since Z is equal to de sum of the products between the aijs and the solution found, and A is no longer in the solution, its value is zero, but the variable keeps it last value..

I am attaching a worksheet for an example that I did years ago, with two alternatives A1 and A2, subject two five criteria and which objective was to maximize production.

The first optimal result indicates that A3=0.16 and A6 = 1.22. This result is showing a Z=52,000 and that the corresponding criteria are C2 and C3.

Observe that:

· C2 has as shadow price (λ2) = 0.07 and C3 a shadow price of (λ3) = 17.95.

· Solver also shows that maximum increment for λ3 is 429, while the maximum increment for λ2 is 48.

Consequently, the upper limit for C3 = 335 (Its RHS) + 429 = 764 and for C2= 559 (Its RHS) + 48 =607.

· If we consider only C3 and we increase its RHS, as shown in the Excel spreadsheet (we can increase in any appropriate amount even if not equal). Observe how the A3 value progressively rises up to 2.74, which corresponds to the upper limit of C3, that is 764.

· Both λ3 and λ2 keep constant along the whole procedure

· Simultaneously the value or score of A6 progressively decreases from 1.22 up to 0, for RHS3 = 764.

· The original upper limit of RHS3 decreases from 420 to 0, for RHS3 = 764.

Correspondingly the original upper limit of RHS2 increases from 48 to 825, for RHS3= 764.

· If the value of 764 is surpassed, say we put 765, alternative A3 keeps its value, since C3 does not have influence on it, however A6 = 0, meaning that this alternative it is no longer a solution, however, notice that λ3= 0 while λ2= 24.61, after the 764 limit is reached.

In fact, we should change RHS3 and RHS2 simultaneously, each one with its own increments/or decrements, and then the performance curve will be the result of both acting at the same time, as in real-world scenarios.

The graphic shows Z performance curve with the λ3. It appears as a broken straight line because I was using different amounts of increments for RHS3, since

I believe that this elemental example shows you how the range is diminishing in the selected alternative

Now, if you want to keep the original production of B unchanged, why don’t you express it as a new constraint, using the binary format, that is in this criterion all alternatives are zero, except B which is 1.

If you have a value in mind for B, say for instance 820,you put it as the RHS, and indicate with the ≥, ≤, or = operators if you want to get a result for B larger than 820, or lower than 820, or equal to 820, respectively.

However, I would stay away from the equality, because it imposes very hard restrictions to the problem.

I sincerely hope that my comments help you, and indeed, I am very interested if you can keep me informed me if it works

To minimise |V-1|, where V is a positive continuous variable, just minimise x subject to x >= V-1 and x >= 1- V.

we can chose linear or dual dependent to conditional constrants

Genetic Algorithm can be an alternative solution :

A friend just told me not to answer (even if it is only now and then). He supposed that even good answers do not change people's mind. Anyway, we had these discussions again and again. But these discussions seem to get lost every now and then. So, let me bring it to one or two threads again, may be using different words.

Like in every field there may be good research and bad research. So, do not put all of it together into one pot with possibly even wrong comprehensions.

Regarding the metaheuristics community, there is some awareness at least in parts of it that not everything that seems shiny is shining. A good reference to explore this view is by our friend Kenneth Sörensen:

https://doi.org/10.1111/itor.12001

And another good pointer is to the word matheuristics which we framed to investigate the interoperation of metaheuristics and mathematical programming techniques. Is it allowed to point to a wikipedia page? May be yes: https://en.wikipedia.org/wiki/Matheuristics

Have fun exploring and learning how to separate the wheat from the chaff :-)

Excellent answers

To check if an inequality is redundant, set up another LP in which you try to maximise the violation of the given inequality, subject to the other inequalities. If the violation is zero, the given inequality is redundant.

Dear Barış Karakum, in the first OR courses, we usually teach the students, that the important thing is to solve the problems, not apply models.

Thus, unless it is for theoretical purposes, the model that is applying is not important. The important thing is that the model you constructed solves the problem situation. Whether or not it belongs to a certain type is irrelevant.

In any case, even if it has only one source and only one destination, if it has several types of vehicles, especially if they have different characteristics, it can be considered as a transportation problem. Vehicles are transformed into sources or destinations, as appropriate. Here in Research Gate there are several articles of ours that discuss the problem of multiple transports, which may be useful to you.

We hope many successes in your research. Best regards,

José Hernández.

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.

Hi Manish Khanra !

Try find and read recommendation about project portfolio planning from PMI Standard for Portfolio Management (overview is available at https://www.pmi.org/learning/library/pmi-standard-portfolio-management-8216).

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! :-)

Thank you for the answer

Thank you for your response Mr. Phil B Brubaker, kindly note that my question is about employing machine learning in solving such optimization problems (regardless the linearity).

MODI and VAM will provide near optimal result.

First, look up the Frank-Wolfe algorithm. It is based precisely on a first-order approximation of the objective function, resulting in a linear function that is then minimized. (Because of the linearity of the approximation, the subproblem solution is one of the extreme points of the feasible set.) A line search in the original objective function over the line segment between the current iterate and the extreme point just found yields the next iteration, and so on. A more detailed description is here:

It's definitely NOT an efficient method, but for small examples it is ok, and it's a very good illustration how an iterative method converges.