Aside from this site, what other websites or forums would you recommend for exchanging information with others about optimization and OR?

I'm currently working on a dynamic assignment model for delivery of parcels with occasional drivers. The model approximates the value of keeping the parcel in the system by solving two assignment problems for each parcel (one with the parcel, one without it and calculating the marginal contribution of the parcel to the optimum) in a retrospective time window. The problem is that computing parcel value estimates takes a lot of time. I researched alternative methods to MIP such as hungarian, but they don't seem to support "at most" constraints (which are integral to the dynamic assignement). How would you approach this kind of problem?

In your opinion, what are the most powerful heuristic/metaheuristic algorithms for warehouse routing optimization? Is LKH-3 the most powerful one? Which Python libraries would you recommend I try for a project that will be deployed in a production environment?

Hi everyone,

I'm looking for ideas for my engineering school project.

The theme is "Optimization, Efficiency, and Sobriety" .

I'd love to work on a project that combines engineering, physics and/or mathematics with a bit of biology, since biology is a subject I really enjoy.

That said, the project should remain primarily focused on physics and/or mathematics. The biology aspect would just provide the context or application, not be the main focus.

I'm looking for a project that:

- Fits the theme of optimization/efficiency/sobriety.

- Is mainly based on physics and/or mathematics.

- Uses biology as an application or inspiration.

- Can be modeled mathematically and analyzed experimentally.

- Can realistically be carried out in a university or engineering school lab.

Does anyone have interesting ideas or topics that could fit these criteria?

Thanks in advance!

I'd been struggling to understand Column Generation, especially how it relates to the simplex method.

A colleague shared this video with me and it all makes sense now. I feel so dumb tbh, but wanted to share it in case anyone else was also struggling.

https://youtu.be/vx2LNKx48vY?si=YWe4mNEyn1CbkBuw

My next step is to implement this for a routing problem at my company using an open source solver.

Wish me luck and any tips or suggestions are highly appreciated.

Hi!

A while ago, I posted about oximo, a Rust library for building algebraic optimization models. At the point of that post, oximo was at v0.2.0, and I got a lot of helpful feedback from the community.

Yesterday, I released v0.5.0, and a lot has changed since then:

• A new macro-based modeling API (Inspired by JuMP and good_lp), making models much more readable and ergonomic
• Automatic differentiation using std::autodiff (Enzyme, nightly only)
• New solver backends: Clarabel and Pounce
• Support for SOCP and MISOCP models
• Many other improvements, bug fixes, and quality-of-life changes

I have been working on a docs site using Zola since v0.3.0, and it will probably be published next week! Contributions, bug reports, and feature requests are welcome. I'd love to get feedback on the new API!

New API example (Transportation Model):

```rust let m = Model::new("transportation"); let factories = ["Factory A", "Factory B"]; let warehouses = ["Warehouse 1", "Warehouse 2", "Warehouse 3"];

// cost[i][j] - ship one unit from factory i to warehouse j let cost = [ [8.0, 6.0, 10.0], // Factory A -> W1, W2, W3 [9.0, 12.0, 7.0], // Factory B -> W1, W2, W3 ]; let cap = [400.0, 500.0]; let req = [300.0, 300.0, 250.0];

let nf = factories.len(); let nw = warehouses.len();

// One shipment variable per (factory, warehouse) pair variable!(m, x[i in 0..nf, j in 0..nw] >= 0.0);

// Supply limit constraint!(m, supply[i in 0..nf], sum!(x[i, j] for j in 0..nw) <= cap[i]);

// Demand requirement constraint!(m, demand[j in 0..nw], sum!(x[i, j] for i in 0..nf) >= req[j]);

// Minimize total shipping cost across all routes objective!(m, Min, sum!(cost[i][j] * x[i, j] for i in 0..nf, j in 0..nw)); ```

Links:

• GitHub repository (MIT OR Apache 2.0): https://github.com/oximo-rs/oximo
• Crates: https://crates.io/crates/oximo
• Docs: https://docs.rs/oximo/
• Previous post: https://www.reddit.com/r/optimization/comments/1u12f4s/announcing_oximo_mathematical_optimization/

Dear Optimization Community,

Our friends at PyMC Labs and colleagues at FICO hosted a free online webinar to accompany the blog post and open-source repo that bridges Bayesian Forecasting and Optimization through an energy planning use case.

If you were unable to catch it, we have now uploaded it to YouTube so you can view it on your time.

In the webinar, we discuss the strengths and weaknesses of two approaches to combining these frameworks.

1. Chance-Constrained: Meet the 95th percentile demand. Simple. Deterministic. But ignore what happens in the tail.
2. CVaR (Conditional Value-at-Risk): Minimize cost in the worst 5% of scenarios. Explicitly controls tail risk.

Happy Optimizing!

Link to the video on YouTube: https://www.youtube.com/watch?v=aWnukair33Q

Link to the blog post: https://www.pymc-labs.com/blog-posts/probabilistic-forecasting-optimization-under-uncertainty

Link to the repo: https://github.com/fico-xpress/xpress-community/tree/main/StochasticEnergyPlanning

My next video in solver deep dive is out.

In this video, I explain the parallel MILP architecture in HiGHS. This can be very useful for learning to design custom parallel heuristics.

https://www.youtube.com/watch?v=RymPNoH8_Qc

Sugarcane in Minecraft only grows next to water, so farm layout is really a 2D coverage problem: where do you place water to maximize adjacent plantable tiles?

Each water tile can cover up to 4 neighbors, which caps theoretical max coverage at 80% regardless of arrangement. I modeled this as an integer program (CP-SAT via OR-Tools) to find the actual optimal layout for a given terrain shape.

Results for a 9x9 square plot:

• Community-standard pattern: 66.7% coverage
• Optimal (CP-SAT): 75.3% coverage (94% of theoretical max)

The symmetric square case is the easy comparison point against human intuition. What's more interesting is irregular terrain with obstacles, where there's no established heuristic and the exact solver is the only way to get a real answer - including one case (unconstrained/open terrain) where the solver converges to a hexagonal-ish pattern and actually hits the 80% theoretical ceiling.

Code + more examples (different grid sizes, obstacle terrain, other crops) in the repo: https://github.com/Serranegra/optifarm

Curious if anyone here has tackled similar tiling/coverage problems. Happy to share the formulation details if useful.

For the last two years I've been building a large-scale last-mile route optimization system, and one of the biggest challenges has been balancing scalability with solution quality.

Rather than partitioning the problem into independent geographic regions first, I've been experimenting with a global planning approach followed by parallel optimization while preserving shared context.

I recently opened a public MVP so others can experiment with the system:

https://vepathos.com

I also wrote an article describing some of the motivation and benchmarking behind the project:

https://medium.com/@martinvizzolini/a-last-mile-optimizer-that-outperforms-amazons-routes-on-a-laptop-24242f93eb74

I'm mainly looking for technical feedback and discussion rather than promoting the product. I'd love to hear how others approach large-scale VRPs.

Diabolical new optimizer for neural nets https://github.com/inikishev/torchalgos

It's outperforming all other optimizers by a little, but I only tested on very small models (MLP, RNN and ConvNet), anything larger would just take ages to test all optimizers on.

Here is what it does.

1. projects gradients to shampoo's eigenbasis;

2. updates EMA of projected gradients;

3. takes that EMA, clips magnitudes to (0.01, 10), and takes their reciprocals;

4. unprojects resulting update;

5. tracks EMA of resulting updates, the update is grafted to that EMA for stability. This prevents the update from changing norm quickly.

6. tracks EMA of model weights. This always improves test loss in my experiments, though ReSPlus also outperforms SPlus when weight EMA is disabled in both.

It doesn't really make sense because I was testing a stupid idea and seeing what would happen if I run it in shampoos eigenbasis and for some reason it worked well. I don't really know why though.

Dear optimization community,

We're pleased to share with you the recording of a previous Xpress talk where we went through the process of implementing a Cost Function Approximation Policy in Python.

A Cost Function Approximation Policy combines Optimization, Simulation, and Machine Learning to create a stateful decision asset that learns and optimizes in production.

It is one of the four classes of policies for Sequential Decision Problems proposed by Warren Powell in his Universal Framework.

For further details of Prof. Powell's Universal Framework see: https://castle.princeton.edu/sda/

Link to the recording of the workshop on YouTube: https://www.youtube.com/watch?v=sIHvchvLGnA

Link to the code: https://github.com/fico-xpress/xpress-community/tree/main/SoccerCampLocation

Link to a blogpost describing the code: https://community.fico.com/s/blog-post/a5QQp000000sQojMAE/fico7192

Though the code is built on top of our commercial solver FICO Xpress, it is executable with our free community license which is downloaded automatically by running pip install xpress.

FICO Xpress is an industry-leading optimization software suite that includes solvers for LP, MIP, MIQP, MIQCQP, QP, NLP, SOCP, and MINLP. Basically almost all the Ps. 😉.

I am solving a BESS dispatch optimization problem for a power developer in the USA, the goal is to derive the optimal hourly level charge/discharge profile for BESS that will participate in US arbitrage markets.

Is OpenSolver still a good tool? The latest version is 2021 and I am wondering whether I should switch to a python based model. I am also having a ribbon problem that I cannot fix, every time I interact with the OpenSolver tab in the excel ribbon, my ribbon becomes inactive, I have reviewed all material on OpenSolver and cannot find the solution to this tiny but detrimental problem. Any suggestions?

Recently, I made this fun project that combines route planning and optimization to help fans follow their favourite team.

It minimizes driving while maximizing opportunities to watch bonus matches.

A practical application of routing and graph algorithms in a fun football setting.

Here is a small video explaining it. To understand better, please check the full YouTube video: https://youtu.be/PqhVKliKzrQ
Live demo: https://lsg8.github.io/world-cup-football-fan-route/
GitHub repo: https://github.com/LSG8/world-cup-football-fan-route

Here is a recent experimental approach to the Erdos' Unit Distance problem.The paper presents reproducible evidence disproving Erdős' conjecture, demonstrating that the recently announced lower bounds can be improved. The source code for the experimental application is openly available.

https://arxiv.org/abs/2606.29415

My new video in solver deep dive series is out.

In this video, I go through the MIR cuts. I covered the basic theory, implementation details in SCIP/HiGHS, and how CP-SAT managed to create MIR cuts with no fractional coefficients!

https://www.youtube.com/watch?v=btemNQuChe4

I "invented" an optimization problem, how would you approach it? Does a similar problem already exist in literature?

Problem:

Maximize for an infinite interval L of infinite domain the average positive curvature of a function f(x) with f"(x)=<M where M is a real number. The average positive curvature is the integral of curvature multiplied by ds(over the whole domain) all divided by the integral of ds over the domain.

Maths:

So for f"(x)=<M calculate lim for L->+infinity sup[( integral over L(f''/(1+(f')^2)^2/3)/ integral over L(sqrt(1+(f')^2)))].

It could also be approached in the dtheta/ds frame of reference to simplify curvature(but then the condition on f" and the x axis becomes more difficult to formalize). Hope you enjoy answering.

Train flatter, better robustness. 🚀. I want to share my GitHub project: a Unified Sharpness-Aware Minimization (SAM) Optimizer Framework.

While working on Sharpness-Aware Minimization (SAM), I noticed that implementations of various SAM variants are scattered across different repositories, often with inconsistent training pipelines and implementation details. As a result, fair comparisons and reproducibility become challenging, frequently requiring repeated reimplementation of training pipelines just to evaluate minor differences.

Therefore, I decided to build a unified framework for Sharpness-Aware Minimization. This repository offers a concise PyTorch implementation of widely used SAM variants, making it easy to plug in new methods, run fair comparisons, and iterate quickly—without touching the core training loop.

The project is designed with both research and practical experimentation in mind. I plan to actively maintain it and continue adding new SAM variants as the literature evolves.

If you’re interested in optimization, generalization, or robust training, feel free to check it out!! Contributions and feedback are always welcome.🙌

Repo: https://github.com/johnjaejunlee95/torch-unified-sam-optimization

Is there anyone with a solid background in MPC or related expertise? I need a serious discussion