How to Contribute

This system is developed in Python programming language, using poetry (alternatively pip) as project and package manager , with unittest library for unit testing and Sphinx system for documentation generation. Same tool set should be use for contribution to the project.

Contribution is encouraged in designing novel optimization methods. Requirements:

1. Algorithms should be derived from the specified class.

   • Class that implements metaheuristic optimization should be derived either from the uo.algorithm.metaheuristic.single_solution_metaheuristic.SingleSolutionMetaheuristic class, or from the uo.algorithm.metaheuristic.population_based_metaheuristic.PopulationBasedMetaheuristic. It should be placed into separate directory within /uo/algorithm/metaheuristic/ directory.

   • Class that implements exact optimization should be derived from the uo.algorithm.Algorithm class. That class should be placed into separate directory within /uo/algorithm/ directory.

2. Type hints and documentation.

   • All programming objects (classes, functions, variables, parameters, optional parameters etc.) should be type-hinted

   • All programming objects (classes, functions, etc.) should be properly documented using the system Sphinx, reStructuredText and doc comments within the code.

   • Each of the implemented algorithm should have separate documentation web page, where that algorithm is described and documented. At least, there should be the link from doc comments within implemented functionality toward the web page that explains algorithm and vice versa.

3. Unit testing coverage.

   • Implemented programming code should be fully covered with unit tests.

   • Here, unittest framework used.

   • Test should be placed into separate sub-directory under /uo/tests/ directory. Directory structure within /uo/tests/ directory should mirror directory structure of the /uo/ directory.

   • All developed code should be covered with unit test, and test coverage rate should be not less than 80%.

Contributors

Contribution domains

Contribution in the designing novel optimization methods:

a.1. Library and application:

1. Initial overall structure and organization - [VladimirFilipovic]

a.2. Total Enumeration (TE) exact algorithm:

2. Structure, organization and main loop implementation - [VladimirFilipovic]

3. Implementation with bit-array based complex counters (class ComplexCounterBitArrayFull, using bitstring.BitArray class) - [VladimirFilipovic]

4. Implementation with int based complex counters (classes ComplexCounterUniformFull and ComplexCounterUniformAscending, using int values) - [VladimirFilipovic]

a.3. Variable Neighborhood Search Variable Neighborhood Search (VNS) metaheuristics:

5. Structure, organization and main loop implementation - [VladimirFilipovic]

6. Implementation of shaking and local searches with binary representation (in class VnsShakingSupportStandardInt, using int predefined type) - [VladimirFilipovic]

7. Implementation of shaking and local searches with binary representation (in class VnsShakingSupportStandardBitArray,using bitstring.BitArray class) - [VladimirFilipovic]

a.4. Genetic Algorithms Genetic Algorithm (GA) metaheuristics:

8. Structure, organization and main loop implementation - [MarkoRadosavljevic], [VladimirFilipovic]

9. Making class uo.algorithm.metaheuristic.genetic_algorithm.GaOptimizer to be abstract and dividing its functionality into non-abstract classes uo.algorithm.metaheuristic.genetic_algorithm.GaOptimizerGenerational and uo.algorithm.metaheuristic.genetic_algorithm.GaOptimizerSteadyState - [VladimirFilipovic]

10. Implementation of GA selection methods (in classes: GaSelectionIdle, GaSelectionRoulette) - [MarkoRadosavljevic]

11. Implementation of GA crossover one point method (contained within class: GaCrossoverSupportOnePointBitArray), with binary representation (using bitstring.BitArray class) - [MarkoRadosavljevic]

12. Implementation of GA mutation one point method (contained within class: GaMutationSupportOnePointBitArray), with binary representation (using bitstring.BitArray class) - [MarkoRadosavljevic]

a.4. Electromagnetism-like Algorithm_Electromagnetism_Like_Metaheuristic (EM) metaheuristics:

13. Structure, organization and main loop implementation - [AndjelaDamnjanovic]

a.5. Simulated Annealing Simulated Annealing (SA) metaheuristics:

14. Structure, organization and main loop implementation - [MarkoLazarevic]

15. Implementation of neighborhood structures with integer representation (in class SaNeighborhoodInt, using int predefined type) - [MarkoLazarevic]

16. Implementation of neighborhood structures with binary representation (in class SaNeighborhoodBitArray, using bitstring.BitArray class) - [MarkoLazarevic]

17. Implementation of temperature calculating methods (in classes: SaTemperatureConst, SaTemperatureLinear, SaTemperatureExponential) - [MarkoLazarevic]

a.6. Model-Agnostic Meta-Learning MAML (MAML) metaheuristics:

18. Structure, organization and main loop implementation - [StojanKostic]

19. Implementation of numerical gradient calculation using finite-difference method - [StojanKostic]

Contributor List

[VladimirFilipovic] (1,2,3,4,5,6,7,8,9)

Vladimir Filipović, https://github.com/vladofilipovic e-mail: vladofilipovic@hotmail.com

[MarkoRadosavljevic] (1,2,3,4)

Marko Radosavljević, https://github.com/Markic01 e-mail: mi20079@alas.matf.bg.ac.rs

[AndjelaDamnjanovic]

Anđela Damjanović, https://github.com/AndjelaDamnjanovic e-mail: mi19059@alas.matf.bg.ac.rs

[LazarSavic]

Lazar Savić, https://github.com/killica e-mail: mi21004@alas.matf.bg.ac.rs

[MarkoLazarevic] (1,2,3,4)

Marko Lazarević, https://github.com/marko-lazarevic e-mail: mi21098@alas.matf.bg.ac.rs

[StojanKostic] (1,2)

Stojan Kostić, https://github.com/Stojan-Kole e-mail: mi21131@alas.matf.bg.ac.rs