Solver Project

The problem is to develop a solver that can efficiently optimize an engineering system for maximum performance. The solver should be able to identify optimal parameters and design solutions that improve the overall system performance. The solver should be able to account for uncertainties in the engineering system and the environment, taking into consideration all relevant constraints and objectives. It should be able to generate feasible solutions that are both cost-effective and sustainable.

The second project for this course is similar in scope and size to the prior project but involves creating a custom solver to find an optimal design. The solver can be a modified version of an open-source solver or created as a new solver. The project should have the following characteristics as general guidelines:

  • Involve an application from engineering
  • Solver technology possibilities
    • Local Solution Techniques
      • Active Set
      • Generalized Reduced Gradient (GRG)
      • Interior Point
    • Discrete Optimization Techniques
      • Branch and Bound
      • Outer Approximation
    • Global Solution Techniques
      • Multi-start with a Local Solver
    • Global and Discrete Methods
      • Genetic Algorithms
      • Simulated Annealing
      • Multi-start with Branch and Bound
  • Preferably involve an application from prior work experience or current research interests
  • Problem size guidelines
    • 3-10 design variables
    • 10-50 equations
  • Problem type guidelines
    • Continuous variables preferred (LP, QP, NLP)
    • Can include discrete variables (MILP, MIQP, MINLP)
    • Empirical equations
    • Equations from first principles
    • Hybrid models: empirical and first principles

For the project report, turn in the following content:

  1. A 2-3 page write-up of the solution. Include solver tuning details that demonstrate an understanding not only of the solution, but of how the solver arrived at the solution. Include figures, equations, and problem background that formulates the mathematical model and presents the solution to the optimization problem. If the project builds upon another problem, include the relevant citations in the project write-up.
  2. A copy of the source code used to generate the solution.

The project reports will be graded on originality, technical difficulty, clarity of the problem statement, accuracy of the solution, description of the solution, and professionalism of the report.


This assignment can be completed in groups of three. Additional guidelines on individual, collaborative, and group assignments are provided under the Expectations link.

Generative AI Learning

Use these prompts while building and validating your solver. Direct the AI - it may act as a test engineer and rubber duck, but the algorithm implementation is the deliverable, so you must be able to defend every line.

"I am implementing {your algorithm: GRG / interior point / branch and bound / genetic algorithm / simulated annealing / multi-start} for my solver project. Act as my test engineer, not my programmer. Design a verification battery: two problems with known analytic optima (one where all constraints are inactive, one with a known active set), one pathological case that historically breaks this algorithm class (you pick it and tell me why it is hard), and one scaling stress test. For each, tell me what OUTPUT I should log (iterates, multipliers or population statistics, termination reason) to prove the solver works rather than assert it."
"My solver returned {solution, objective, iterations, termination reason} on my test problem, while IPOPT/APOPT through GEKKO returned {solution, objective}. Interview me, one question at a time: are the two answers the same optimum or different local optima, what do my logged iterates show near termination (stalling? oscillation? satisfied tolerance?), which convergence criterion fired and was it the right one, and if my solver took 10x more iterations - is that an implementation bug or an honest property of my algorithm? Make me commit to a diagnosis with evidence."

Tip: A solver you wrote is only trustworthy after it loses gracefully: report at least one problem where your solver fails or underperforms, and explain why from the algorithm's theory. That analysis is worth more than a suspiciously perfect scorecard.

What to Turn In

In addition to the report and source code described above, include a half-page Verification and AI Use appendix answering:

  1. Show your verification battery results: the known-solution tests (your solver vs analytic optimum), the pathological case, and what each proved.
  2. Include the head-to-head table against a professional solver (IPOPT or APOPT via GEKKO): solution quality, iterations/function evaluations, and termination reasons.
  3. Document one failure or weakness of your solver and connect it to the algorithm's theory (e.g., GRG line search stalling at a constraint kink, annealing budget too small, branch and bound bound too loose).
  4. State where AI assisted (test design, debugging, plotting, editing) and how you verified each AI contribution - and confirm the core algorithm logic is your own.

Course Information

Homework

Projects

Activities

Lecture Notes

Extra Content

Related Courses

Admin