Optimization Methods for Industrial Processes

What Is Mathematical Optimization?

Mathematical optimization is the process of finding the best solution from a set of feasible alternatives, subject to constraints. Every optimization problem consists of three elements:

1. Objective function: What you want to maximize or minimize (profit, cost, time, energy...)
2. Decision variables: The choices you control (production quantities, schedules, design parameters...)
3. Constraints: Limits that cannot be exceeded (budget, capacity, raw materials...)

Optimization is at the heart of industrial decision-making — from production planning and supply chain management to energy minimization and machine scheduling.

Linear Programming: The Solid Foundation

Linear Programming (LP) solves optimization problems where both the objective function and all constraints are linear — first-degree relationships with no squared terms or variable products.

Standard form:

Maximize (or Minimize):  Z = c1*x1 + c2*x2 + ... + cn*xn

Subject to:
  a11*x1 + a12*x2 + ... + a1n*xn <= b1
  a21*x1 + a22*x2 + ... + a2n*xn <= b2
  ...
  x1, x2, ..., xn >= 0

Industrial example — production planning:

A factory produces two products A and B:

• Product A: profit $50/unit, requires 2 hours machining + 1 kg raw material
• Product B: profit $40/unit, requires 1 hour machining + 2 kg raw material
• Available: 100 machining hours, 80 kg raw material

Maximize: Z = 50*x_A + 40*x_B

Subject to:
  2*x_A + x_B <= 100   (machining hours)
  x_A + 2*x_B <= 80    (raw material)
  x_A, x_B >= 0

Graphical solution (for two variables only): Plot each constraint as a line — the feasible region is the polygon where all constraints are satisfied. The optimal solution always lies at a vertex of this polygon.

Solving the system: x_A = 40, x_B = 20, giving Z = 50(40) + 40(20) = 2800.

The Simplex Method: Systematic Solution

The Simplex Method, developed by George Dantzig in 1947, is the most widely used algorithm for solving linear programs. Instead of checking every vertex of the feasible polytope (potentially millions), it intelligently moves from one vertex to a better adjacent vertex until reaching the optimum.

Simplex steps:

1. Convert to equality constraints: Add slack variables

   • 2*x_A + x_B + s1 = 100
   • x_A + 2*x_B + s2 = 80

2. Build the initial tableau: A matrix containing all variable coefficients

3. Select entering variable (pivot column): The variable with the most negative coefficient in the objective row

4. Select leaving variable (pivot row): Using the minimum ratio test

5. Pivot operation: Perform row operations to transform the tableau

6. Iterate: Until no negative coefficients remain in the objective row — the optimum has been reached

Why is Simplex efficient? Although the number of vertices can be exponential in the number of variables, Simplex practically requires a roughly linear number of steps — solving problems with thousands of variables in seconds.

Special cases:

• Multiple optima: When the objective function is parallel to a constraint — infinitely many optimal solutions
• Infeasible: Constraints are contradictory — no solution satisfies all of them
• Unbounded: The objective can improve without limit — usually means a missing constraint

Genetic Algorithms: Simulating Natural Evolution

What if the problem is nonlinear, the objective function is discontinuous, or the variables must be integers (like the number of machines)? Linear programming cannot help. Genetic Algorithms (GA) are search methods inspired by natural evolution.

The idea: Instead of an exact mathematical solution, simulate natural selection:

1. Initialization: Generate a random population of candidate solutions (individuals)
2. Fitness evaluation: Compute the objective function for each individual — better values mean higher fitness
3. Selection: Choose the best individuals for reproduction — stronger individuals have better odds
4. Crossover: Combine two good solutions to create a new solution (offspring)
5. Mutation: Randomly alter a small part of a solution — prevents getting stuck in local optima
6. Iterate: Repeat across generations — each generation improves upon the last

Solution encoding:

• Binary: Each solution is a string of 0s and 1s — like genetic code
• Real-coded: Each variable is a real number — better suited for engineering problems
• Permutation: An ordering of elements — for scheduling and routing problems

Control parameters:

Industrial Optimization Applications

Production Scheduling

Consider 5 jobs needing processing on 3 machines in different sequences. Every delay incurs a penalty. The problem: what is the best ordering to minimize total completion time?

This is the job shop scheduling problem — one of the hardest optimization problems computationally (NP-hard). Genetic algorithms produce excellent solutions in minutes, while brute-force optimal solutions could take years of computation.

Energy Minimization

Minimize: E = sum_i P_i(x_i) * t_i

Subject to:
  Total production >= Demand
  Each machine <= Maximum capacity
  Peak electrical load <= Subscription limit

By intelligently distributing production between peak and off-peak hours, electricity bills can be reduced by 15-25%.

Mix Optimization

In cement or feed manufacturing, you need to blend different raw materials in proportions that meet quality specifications at minimum cost. This is a classic linear programming problem.

Tool Path Optimization

In CNC machining, minimizing the total distance the cutting tool travels between holes saves production time. This is a variant of the Traveling Salesman Problem (TSP) — effectively solved with genetic algorithms.

Comparison of Optimization Methods

Practical rule: Start with linear programming if possible — it guarantees the true optimum. If the problem is nonlinear, involves integer variables, or has a complex objective function, switch to genetic algorithms or other metaheuristics such as Simulated Annealing or Particle Swarm Optimization (PSO).

Software Tools for Optimization

These tools are freely available for industrial optimization:

• Python + SciPy: scipy.optimize for general optimization problems
• PuLP: Python library for linear and integer programming
• MATLAB linprog: Linear programming solver in MATLAB
• Excel Solver: Adequate for small problems (up to 200 variables)
• Google OR-Tools: Open-source library for combinatorial optimization

The tool matters less than the formulation. A wrong tool applied to a correct formulation is better than the best tool applied to a wrong formulation.