Evolutionary Dynamic Optimization Laboratory (EDOLAB)

A MATLAB Optimization Platform for Education and Experimentation in Dynamic Environments

Git repository: EvoMindLab/EDOLAB

The current version is v2.10

📰 News

• [December 2025] 🎉 This work has been published in ACM Transactions on Mathematical Software (JCR Q1 - CORE/ERA A* Ranked Journal)!
  • Paper: M. Peng, D. Yazdani, D. Yazdani, Z. She, W. Luo, C. Li, J. Branke, T. T. Nguyen, A. H. Gandomi, S. Yang, Y. Jin, and X. Yao, "Algorithm 1060: EDOLAB, a Platform for Research and Education in Evolutionary Dynamic Optimization," ACM Transactions on Mathematical Software, 2025.
  • DOI: 10.1145/3785134
  • Citation: If you use EDOLAB in your research, please cite:

    @article{mai2026EDOLAB,
    author = {Peng, Mai and Yazdani, Delaram and Yazdani, Danial and She, Zeneng and Luo, Wenjian and Li, Changhe and Branke, Juergen and Nguyen, Trung Thanh and Gandomi, Amir H. and Yang, Shengxiang and Jin, Yaochu and Yao, Xin},
    title = {Algorithm 1060: EDOLAB, a Platform for Research and Education in Evolutionary Dynamic Optimization},
    journal = {ACM Transactions on Mathematical Software},
    publisher = {Association for Computing Machinery},
    url = {https://doi.org/10.1145/3785134},
    doi = {10.1145/3785134},
    articleno = {4},
    year = {2026},
    volume = {52},
    number = {1},
    pages={1--30}
    }

Get Started

# clone the project
git clone https://github.com/EvoMindLab/EDOLAB.git

Architecture Overview

Modular structure with core components:

├── Algorithm/             # EDOA implementations (ACFPSO, CDE, mQSO, etc.)
├── Benchmark/             # Benchmark generators (GMPB, MPB, FPs, GDBG)
├── Utility/               # Helper functions
├── OctaveVersion/         # Octave supports
├── GUIMode.m              # GUI entry point
└── CodeMode.m             # Script mode entry

Running EDOLAB

The current version of the GUI Mode is relatively well-developed, and we strongly recommend using it.

GUI Mode (MATLAB R2020b+)

% Launch graphical interface
run GUIMode.m

• Experimentation module

Core Features:

• Experiment configuration management
• Batch task processing
• Real-time progress monitoring
• Statistical significance analysis
• Interactive visualizations (Trend/Box plots)

• Education module

Core Features:

• Step-by-step visualization of optimization process
• Interactive control over iteration playback
• Real-time population behavior tracking
• Interactive control, freely start, stop, or jump to any iteration

Code Mode (MATLAB R2016b+/Octave)

1. Select algorithm and benchmark in CodeMode.m

   % Configure Algorithm & Benchmark in CodeMode.m
   AlgorithmName = 'mQSO';
   BenchmarkName = 'MPB';
   VisualizationOverOptimization = 0;  % 1 = Education Mode

2. Where configurable parameters are defined

   Each algorithm and benchmark exposes its configurable parameters through dedicated functions:

   • Algorithm parameters:
     Algorithm/<AlgorithmName>/getAlgConfigurableParameters_<AlgorithmName>.m
   • Benchmark parameters:
     Benchmark/<BenchmarkName>/getProConfigurableParameters_<BenchmarkName>.m

   Inside these files, parameters follow a uniform pattern:

   ConfigurableParameters.ParamName = struct( ...
       'value', <default>, ...
       'type',  '<numeric|integer|option|boolean>', ...
       'range', [...], ...
       'description', '...' );

   You can discover all available parameter names programmatically in MATLAB:

   tmpAlg = getAlgConfigurableParameters(AlgorithmName);
   fieldnames(tmpAlg)           % Algorithm parameter names
   
   tmpPro = getProConfigurableParameters(BenchmarkName);
   fieldnames(tmpPro)           % Benchmark parameter names

3. Override parameters directly in CodeMode.m (recommended for fast experiments)

   In CodeMode.m, parameters are first loaded from the files above:

   ConfigurableAlgParameters = getAlgConfigurableParameters(AlgorithmName);
   ConfigurableProParameters = getProConfigurableParameters(BenchmarkName);

   You can then override any parameter for the current run only by changing the .value fields:

   % Algorithm-side overrides (example for ACFPSO)
   ConfigurableAlgParameters.PopulationSize.value = 20;
   ConfigurableAlgParameters.c1.value             = 1.8;
   ConfigurableAlgParameters.c2.value             = 1.6;
   
   % Benchmark-side overrides (example for GMPB / MPB)
   ConfigurableProParameters.Dimension.value        = 10;
   ConfigurableProParameters.ChangeFrequency.value  = 2000;
   ConfigurableProParameters.PeakNumber.value       = 5;

   These overrides do not change any JSON or GUI configuration; they only affect the current execution of CodeMode.m.

4. Run Code Mode

   In MATLAB or Octave, simply execute:

   run CodeMode.m

Extension

Adding New Algorithms

1. Create algorithm folder
   Under Algorithm/, create a new sub-folder named after your EDOA (e.g. XYZ).

2. Implement the five core functions
   Place these files inside your new folder:

   • main_XYZ.m
     Main entry point—must accept and return the standardized Problem and Output structures.
   • SubPopulationGenerator_XYZ.m
     Generates or updates the algorithm’s subpopulations.
   • IterativeComponents_XYZ.m
     Contains the core search/update loop for each iteration.
   • ChangeReaction_XYZ.m
     Handles detection of and adaptation to environmental changes.
   • getAlgConfigurableParameters_XYZ.m
     Defines all user-configurable parameters (fields: value, type, range, description).

3. Hook into CodeMode
   Ensure that CodeMode.m can invoke main_XYZ.m by setting:

   AlgorithmName = 'XYZ';

4. Visualization & Output

   • Use the %% Visualization for education section pattern from existing EDOAs to collect GUI data.
   • At the end of main_XYZ.m, assemble an Results.Indicators structure consistent with EDOLAB’s reporting modules.

Adding New Benchmarks

1. Create benchmark folder Under Benchmark/, create a sub-folder named after your benchmark (e.g. ABC).

2. Implement the three core files Inside Benchmark/ABC/ add:

   • getProConfigurableParameters_ABC.m Define ConfigurableParameters with fields:

     ConfigurableParameters.ParamName = struct( ...
       'value', <default>, ...
       'type',  '<numeric|integer|option>', ...
       'range', [...], ...
       'description', '…' ...
     );

   • BenchmarkGenerator_ABC.m Builds the Problem structure (environments, dynamics) based solely on the parameters from getProConfigurableParameters_ABC.m.

   • fitness_ABC.m Computes the baseline fitness for each solution, conforming to EDOLAB’s input/output conventions.

3. Automatic integration Once these files are in place, your new benchmark will appear in the GUI list and can be run via CodeMode.m.

Custom Performance Metrics

1. Edit the JSON interface Open Indicators/indicators.json and add:

   "MyMetric": {
     "type": "FE based"          // or "Environment based" / "None"
   }

2. Implement in fitness.m In fitness.m, compute and store your metric:

   % FE based (every evaluation)
   Problem.Indicators.MyMetric.trend(Problem.FE) = <your calculation>;
   
   % Environment based (per environment)
   Problem.Indicators.MyMetric.trend(Problem.EnvironmentCounter) = <your calculation>;
   
   % None (final only)
   Problem.Indicators.MyMetric.final = <your calculation>;

3. Verify & Use

   • In GUI Mode, run one task and check the Completed Tasks panlel or Statistical Analysis panel to see your new indicator.
   • In Code Mode, confirm Results.Indicators.MyMetric appears in results.

Octave Support

EDOLAB provides full functionality in Octave through its dedicated OctaveVersion implementation. This standalone version maintains all core features while addressing key compatibility requirements.

1. Install required packages:

pkg install -forge io statistics
pkg load io statistics

2. Compile KDTree component:

cd OctaveVersion/Benchmark
mkoctfile --mex ConstructKDTree.cpp

3. Execute the main controller script:

run OctaveVersion/OctaveCodeMode.m

For More Information

For more information about EDOLAB, please refer to the paper and user manual. If you need further assistance, please contact Mai Peng at pengmai1998@gmail.com or Danial Yazdani at danial.yazdani@gmail.com.

MATLAB Support

• GUI Mode requires MATLAB R2020b+ and the Parallel Computing Toolbox. Recommended MATLAB R2024a or later.
• Code Mode requires MATLAB R2016b+.

License

This program is to be used under the terms of the GNU General Public License

Copyright (c) 2022-present Danial Yazdani