docs: add comprehensive documentation for new optimization algorithms

Add detailed documentation for four newly implemented optimization algorithms:
- QOJAYA (Quasi-Oppositional Jaya): Enhanced Jaya with quasi-oppositional learning
- GOTLBO (Generalized Oppositional TLBO): TLBO with oppositional-based learning
- ITLBO (Improved TLBO): TLBO with adaptive teaching factors and elitism
- Multi-objective TLBO: Extension of TLBO for problems with multiple objectives

Updates include:
- New algorithm descriptions in README.md with usage examples
- Detailed API documentation with parameters, return values and flow diagrams
- Algorithm-specific markdown files in docs/algorithms with mathematical formulations
- Real-world application examples and references to original papers
- Updated index.md with algorithm comparison table and usage recommendations
- Fixed test cases to account for stochastic nature of optimization algorithms

References:
- R.V. Rao & D.P. Rai (2017) - QOJAYA paper
- R.V. Rao & V. Patel (2013) - GOTLBO paper
- R.V. Rao & V. Patel (2012) - ITLBO paper
- R.V. Rao & V.D. Kalyankar (2014) - Multi-objective TLBO paper

Author: sandeepkunkunuru

README.md

@@ -6,6 +6,10 @@ This package implements several powerful optimization algorithms developed by Pr
 - **Jaya Algorithm**
 - **Rao Algorithms (Rao-1, Rao-2, Rao-3)**
 - **TLBO (Teaching-Learning-Based Optimization) Algorithm**
+- **QOJAYA (Quasi-Oppositional Jaya) Algorithm**
+- **GOTLBO (Generalized Oppositional TLBO) Algorithm**
+- **ITLBO (Improved TLBO) Algorithm**
+- **Multi-objective TLBO Algorithm**
 
 These algorithms are designed to solve both **constrained** and **unconstrained** optimization problems without relying on metaphors or algorithm-specific parameters. The BMR and BWR algorithms are based on the paper:
 
@@ -17,6 +21,7 @@ These algorithms are designed to solve both **constrained** and **unconstrained*
 - **Simple**: Most algorithms have no algorithm-specific parameters to tune.
 - **Flexible**: Handles both constrained and unconstrained optimization problems.
 - **Versatile**: Includes a variety of algorithms suitable for different types of optimization problems.
+- **Multi-objective Optimization**: Support for problems with multiple competing objectives.
 
 ## Installation
 
@@ -123,6 +128,106 @@ best_solution_rao3, best_scores_rao3 = Rao3_algorithm(bounds, num_iterations, po
 print(f"Rao-3 Best solution found: {best_solution_rao3}")
 ```
 
+### Example: QOJAYA Algorithm
+
+```python
+import numpy as np
+from rao_algorithms import QOJAYA_algorithm, objective_function
+
+# Unconstrained QOJAYA
+# -------------------
+# Define the bounds for a 2D problem
+bounds = np.array([[-100, 100]] * 2)
+
+# Set parameters
+num_iterations = 100
+population_size = 50
+num_variables = 2
+
+# Run the QOJAYA algorithm
+best_solution, best_scores = QOJAYA_algorithm(bounds, num_iterations, population_size, num_variables, objective_function)
+print(f"QOJAYA Best solution found: {best_solution}")
+```
+
+### Example: GOTLBO Algorithm
+
+```python
+import numpy as np
+from rao_algorithms import GOTLBO_algorithm, objective_function
+
+# Unconstrained GOTLBO
+# -------------------
+# Define the bounds for a 2D problem
+bounds = np.array([[-100, 100]] * 2)
+
+# Set parameters
+num_iterations = 100
+population_size = 50
+num_variables = 2
+
+# Run the GOTLBO algorithm
+best_solution, best_scores = GOTLBO_algorithm(bounds, num_iterations, population_size, num_variables, objective_function)
+print(f"GOTLBO Best solution found: {best_solution}")
+```
+
+### Example: ITLBO Algorithm
+
+```python
+import numpy as np
+from rao_algorithms import ITLBO_algorithm, objective_function
+
+# Unconstrained ITLBO
+# ------------------
+# Define the bounds for a 2D problem
+bounds = np.array([[-100, 100]] * 2)
+
+# Set parameters
+num_iterations = 100
+population_size = 50
+num_variables = 2
+
+# Run the ITLBO algorithm
+best_solution, best_scores = ITLBO_algorithm(bounds, num_iterations, population_size, num_variables, objective_function)
+print(f"ITLBO Best solution found: {best_solution}")
+```
+
+### Example: Multi-objective TLBO Algorithm
+
+```python
+import numpy as np
+from rao_algorithms import MultiObjective_TLBO_algorithm
+
+# Define two objective functions
+def objective_function1(x):
+    return np.sum(x**2)  # Minimize the sum of squares
+
+def objective_function2(x):
+    return np.sum((x-2)**2)  # Minimize the sum of squares from point (2,2,...)
+
+# Multi-objective TLBO
+# -------------------
+# Define the bounds for a 2D problem
+bounds = np.array([[-100, 100]] * 2)
+
+# Set parameters
+num_iterations = 100
+population_size = 50
+num_variables = 2
+
+# Run the Multi-objective TLBO algorithm
+pareto_front, pareto_fitness, best_scores_history = MultiObjective_TLBO_algorithm(
+    bounds, 
+    num_iterations, 
+    population_size, 
+    num_variables, 
+    [objective_function1, objective_function2]
+)
+
+print(f"Number of solutions in Pareto front: {len(pareto_front)}")
+print(f"First Pareto optimal solution: {pareto_front[0]}")
+print(f"Corresponding objective values: {pareto_fitness[0]}")
+```
+
 ### Unit Testing
 
 This package comes with unit tests. To run the tests:
@@ -173,6 +278,34 @@ TLBO is a parameter-free algorithm inspired by the teaching-learning process in
 
 - **Paper Citation**: R. V. Rao, V. J. Savsani, D. P. Vakharia, "Teaching-Learning-Based Optimization: An optimization method for continuous non-linear large scale problems", Information Sciences, 183(1), 2012, 1-15.
 
+### QOJAYA (Quasi-Oppositional Jaya) Algorithm
+
+QOJAYA enhances the standard Jaya algorithm by incorporating quasi-oppositional learning to improve convergence speed and solution quality. It generates and evaluates quasi-opposite solutions alongside the standard Jaya updates.
+
+- **Paper Citation**: R. V. Rao, D. P. Rai, "Optimization of welding processes using quasi-oppositional-based Jaya algorithm", Journal of Mechanical Science and Technology, 31(5), 2017, 2513-2522.
+- **Real-world Application**: The algorithm has been successfully applied to optimize welding processes, including tungsten inert gas (TIG) welding and friction stir welding. It determines optimal parameters like welding current, voltage, and speed to maximize weld strength while minimizing defects.
+
+### GOTLBO (Generalized Oppositional TLBO) Algorithm
+
+GOTLBO combines TLBO with generalized opposition-based learning to enhance exploration capabilities and convergence speed. It applies opposition in both teacher and learner phases.
+
+- **Paper Citation**: R. V. Rao, V. Patel, "An improved teaching-learning-based optimization algorithm for solving unconstrained optimization problems", Scientia Iranica, 20(3), 2013, 710-720.
+- **Real-world Application**: GOTLBO has been applied to mechanical design optimization problems, including the design of pressure vessels, spring design, and gear train design. It effectively finds optimal dimensions and parameters that minimize weight while satisfying safety constraints.
+
+### ITLBO (Improved TLBO) Algorithm
+
+ITLBO enhances the standard TLBO algorithm with an adaptive teaching factor, elite solution influence, and three-way interaction in the learner phase.
+
+- **Paper Citation**: R. V. Rao, V. Patel, "An elitist teaching-learning-based optimization algorithm for solving complex constrained optimization problems", International Journal of Industrial Engineering Computations, 3(4), 2012, 535-560.
+- **Real-world Application**: ITLBO has been successfully applied to optimize heat exchangers, finding the optimal design parameters that maximize heat transfer while minimizing pressure drop and material costs. It has also been used for power system optimization to minimize generation costs and transmission losses.
+
+### Multi-objective TLBO Algorithm
+
+Multi-objective TLBO extends TLBO to handle multiple competing objectives using Pareto dominance and crowding distance for selection. It returns a set of non-dominated solutions (Pareto front).
+
+- **Paper Citation**: R. V. Rao, V. D. Kalyankar, "Multi-objective TLBO algorithm for optimization of modern machining processes", Advances in Intelligent Systems and Computing, 236, 2014, 21-31.
+- **Real-world Application**: The algorithm has been applied to optimize machining processes like turning, milling, and grinding operations. It simultaneously optimizes multiple objectives such as surface roughness, material removal rate, and tool wear, helping manufacturers achieve high-quality parts with efficient production.
+
 ## Docker Support
 
 You can use the included `Dockerfile` to build and test the package quickly. To build and run the package in Docker:
@@ -191,4 +324,8 @@ This package is licensed under the MIT License. See the [LICENSE](LICENSE) file
 1. Ravipudi Venkata Rao, Ravikumar Shah, "BMR and BWR: Two simple metaphor-free optimization algorithms for solving real-life non-convex constrained and unconstrained problems," [arXiv:2407.11149v2](https://arxiv.org/abs/2407.11149).
 2. Ravipudi Venkata Rao, "Jaya: A simple and new optimization algorithm for solving constrained and unconstrained optimization problems", International Journal of Industrial Engineering Computations, 7(1), 2016, 19-34.
 3. Ravipudi Venkata Rao, "Rao algorithms: Three metaphor-less simple algorithms for solving optimization problems", International Journal of Industrial Engineering Computations, 11(2), 2020, 193-212.
-4. Ravipudi Venkata Rao, V. J. Savsani, D. P. Vakharia, "Teaching-Learning-Based Optimization: An optimization method for continuous non-linear large scale problems", Information Sciences, 183(1), 2012, 1-15.
+4. Ravipudi Venkata Rao, V. J. Savsani, D. P. Vakharia, "Teaching-Learning-Based Optimization: An optimization method for continuous non-linear large scale problems", Information Sciences, 183(1), 2012, 1-15.
+5. Ravipudi Venkata Rao, D. P. Rai, "Optimization of welding processes using quasi-oppositional-based Jaya algorithm", Journal of Mechanical Science and Technology, 31(5), 2017, 2513-2522.
+6. Ravipudi Venkata Rao, V. Patel, "An improved teaching-learning-based optimization algorithm for solving unconstrained optimization problems", Scientia Iranica, 20(3), 2013, 710-720.
+7. Ravipudi Venkata Rao, V. Patel, "An elitist teaching-learning-based optimization algorithm for solving complex constrained optimization problems", International Journal of Industrial Engineering Computations, 3(4), 2012, 535-560.
+8. Ravipudi Venkata Rao, V. D. Kalyankar, "Multi-objective TLBO algorithm for optimization of modern machining processes", Advances in Intelligent Systems and Computing, 236, 2014, 21-31.

docs/algorithms/gotlbo.md

@@ -0,0 +1,143 @@
+# Generalized Oppositional Teaching-Learning-Based Optimization (GOTLBO)
+
+## Overview
+
+The Generalized Oppositional Teaching-Learning-Based Optimization (GOTLBO) algorithm is an enhanced version of the standard TLBO algorithm developed by Prof. R.V. Rao. It incorporates oppositional-based learning to improve convergence speed and solution quality. The algorithm maintains the two-phase approach of the original TLBO (Teacher Phase and Learner Phase) while adding the ability to explore more of the search space through opposition.
+
+## Key Features
+
+- **Enhanced exploration**: Uses oppositional-based learning to explore more of the search space.
+- **Parameter-free**: Like the original TLBO, GOTLBO doesn't require any algorithm-specific parameters.
+- **Improved convergence**: Often converges faster than the standard TLBO algorithm.
+- **Two-phase approach**: Maintains the Teacher Phase and Learner Phase from the original TLBO.
+- **Handles constraints**: Effectively handles both constrained and unconstrained optimization problems.
+
+## Algorithm Workflow
+
+```mermaid
+graph TD
+    A[Initialize Population] --> B[Evaluate Fitness]
+    B --> C[Identify Best Solution as Teacher]
+    C --> D[Teacher Phase: Update Solutions Based on Teacher]
+    D --> E[Generate Opposition-Based Solutions in Teacher Phase]
+    E --> F[Select Better Solutions]
+    F --> G[Learner Phase: Update Solutions Based on Peer Learning]
+    G --> H[Generate Opposition-Based Solutions in Learner Phase]
+    H --> I[Select Better Solutions]
+    I --> J{Termination Criteria Met?}
+    J -->|No| B
+    J -->|Yes| K[Return Best Solution]
+```
+
+## Mathematical Formulation
+
+### Teacher Phase with Opposition
+
+For each student (solution) $X_i$ in the population at iteration $t$:
+
+1. Generate a new solution using the standard TLBO teacher phase:
+
+$$X_{i,new}^{t} = X_{i}^{t} + r \times (X_{teacher}^{t} - T_F \times M^{t})$$
+
+Where:
+- $X_{i}^{t}$ is the $i$-th student (solution) at iteration $t$
+- $X_{teacher}^{t}$ is the best student (solution) at iteration $t$, acting as the teacher
+- $M^{t}$ is the mean of all students (solutions) at iteration $t$
+- $T_F$ is the teaching factor, which can be either 1 or 2 (randomly decided)
+- $r$ is a random number in the range [0, 1]
+
+2. Generate an opposite solution:
+
+$$O_{i}^{t} = a + b - X_{i,new}^{t}$$
+
+Where:
+- $a$ and $b$ are the lower and upper bounds of the search space
+
+3. Select the better of $X_{i,new}^{t}$ and $O_{i}^{t}$ based on their fitness values.
+
+### Learner Phase with Opposition
+
+For each student (solution) $X_i$ in the population:
+
+1. Randomly select another student $X_j$ where $j \neq i$
+2. Generate a new solution using the standard TLBO learner phase:
+
+If $f(X_i) < f(X_j)$ (i.e., if $X_i$ is better than $X_j$):
+
+$$X_{i,new}^{t} = X_{i}^{t} + r \times (X_{i}^{t} - X_{j}^{t})$$
+
+If $f(X_i) \geq f(X_j)$ (i.e., if $X_i$ is worse than or equal to $X_j$):
+
+$$X_{i,new}^{t} = X_{i}^{t} + r \times (X_{j}^{t} - X_{i}^{t})$$
+
+Where $r$ is a random number in the range [0, 1].
+
+3. Generate an opposite solution:
+
+$$O_{i}^{t} = a + b - X_{i,new}^{t}$$
+
+4. Select the better of $X_{i,new}^{t}$ and $O_{i}^{t}$ based on their fitness values.
+
+## Example Usage
+
+```python
+import numpy as np
+from rao_algorithms import GOTLBO_algorithm
+
+# Define the objective function (to be minimized)
+def sphere_function(x):
+    return np.sum(x**2)
+
+# Define problem parameters
+bounds = np.array([[-10, 10]] * 10)  # 10D problem with bounds [-10, 10] for each dimension
+num_iterations = 100
+population_size = 50
+num_variables = 10
+
+# Run the GOTLBO algorithm
+best_solution, convergence_curve = GOTLBO_algorithm(
+    bounds, 
+    num_iterations, 
+    population_size, 
+    num_variables, 
+    sphere_function
+)
+
+print("Best solution found:", best_solution)
+print("Best fitness value:", sphere_function(best_solution))
+```
+
+## Advantages
+
+1. **Improved exploration**: Oppositional-based learning helps the algorithm explore more of the search space.
+2. **Faster convergence**: Often converges faster than the standard TLBO algorithm.
+3. **No algorithm-specific parameters**: Maintains the parameter-free nature of the original TLBO algorithm.
+4. **Good for multimodal problems**: The enhanced exploration capability makes it effective for problems with multiple local optima.
+5. **Effective for large-scale problems**: Like TLBO, GOTLBO performs well on high-dimensional optimization problems.
+
+## Applications
+
+GOTLBO has been successfully applied to various real-world problems, including:
+
+- Mechanical design optimization
+- Structural optimization
+- Thermal system design
+- Electrical power systems optimization
+- Manufacturing process optimization
+- Machine learning hyperparameter tuning
+
+## Real-world Application: Mechanical Design Optimization
+
+GOTLBO has been applied to mechanical design optimization problems, including the design of pressure vessels, spring design, and gear train design. It effectively finds optimal dimensions and parameters that minimize weight while satisfying safety constraints.
+
+In a typical pressure vessel design problem:
+- **Decision variables**: Thickness of the shell, thickness of the head, inner radius, length of the cylindrical section
+- **Objective**: Minimize the total cost of the pressure vessel
+- **Constraints**: Stress constraints, geometric constraints, minimum thickness requirements
+
+GOTLBO efficiently navigates this complex parameter space to find optimal designs that minimize cost while meeting all safety requirements.
+
+## References
+
+- R. V. Rao, V. Patel, "An improved teaching-learning-based optimization algorithm for solving unconstrained optimization problems", Scientia Iranica, 20(3), 2013, 710-720.
+- R. V. Rao, V. J. Savsani, D. P. Vakharia, "Teaching-Learning-Based Optimization: An optimization method for continuous non-linear large scale problems", Information Sciences, 183(1), 2012, 1-15.

docs/algorithms/index.md

@@ -9,6 +9,10 @@ This section provides detailed documentation for all the optimization algorithms
 - [Jaya Algorithm](jaya.md): A parameter-free algorithm that always tries to move toward the best solution and away from the worst solution.
 - [Rao Algorithms (Rao-1, Rao-2, Rao-3)](rao.md): Three metaphor-less algorithms that use different strategies to guide the search process.
 - [TLBO (Teaching-Learning-Based Optimization)](tlbo.md): A parameter-free algorithm inspired by the teaching-learning process in a classroom.
+- [QOJAYA (Quasi-Oppositional Jaya)](qojaya.md): An enhanced version of Jaya that incorporates quasi-oppositional learning for improved convergence.
+- [GOTLBO (Generalized Oppositional TLBO)](gotlbo.md): An enhanced version of TLBO that incorporates oppositional-based learning to improve convergence.
+- [ITLBO (Improved TLBO)](itlbo.md): An enhanced version of TLBO with adaptive teaching factors and elitism for better performance.
+- [Multi-objective TLBO](multiobjective_tlbo.md): An extension of TLBO for solving problems with multiple competing objectives.
 
 ## Algorithm Comparison
 
@@ -23,6 +27,10 @@ The following table provides a comparison of the key features of the implemented
 | Rao-2     | Yes           | Best, Worst, and Average fitness | Uses fitness comparison with average |
 | Rao-3     | Yes           | Best solution and phase factor | Decreasing influence of best solution over time |
 | TLBO      | Yes           | Teacher-Student learning process | Two-phase approach with good performance on large-scale problems |
+| QOJAYA    | Yes           | Jaya with quasi-oppositional learning | Enhanced exploration with improved convergence |
+| GOTLBO    | Yes           | TLBO with oppositional-based learning | Better exploration and faster convergence |
+| ITLBO     | Yes           | TLBO with adaptive teaching factors | Improved convergence with elite influence |
+| MO-TLBO   | Yes           | TLBO with Pareto dominance | Handles multiple competing objectives |
 
 ## Convergence Comparison
 
@@ -46,5 +54,9 @@ The convergence speed and solution quality of these algorithms can vary dependin
 - **Rao-2**: Useful when the average fitness of the population provides meaningful guidance.
 - **Rao-3**: Effective when you want a decreasing influence of the best solution over time.
 - **TLBO**: Excellent for large-scale problems and when you want a two-phase approach to optimization.
+- **QOJAYA**: When you need better exploration capabilities than standard Jaya, especially for multimodal problems.
+- **GOTLBO**: When you need faster convergence than standard TLBO for complex problems.
+- **ITLBO**: When you need better solution quality than standard TLBO, especially for constrained problems.
+- **MO-TLBO**: When you have multiple competing objectives and need a set of trade-off solutions.
 
-For most problems, it is recommended to start with Jaya or TLBO due to their parameter-free nature and good general performance, then try the other algorithms if needed.
+For most single-objective problems, it is recommended to start with Jaya, TLBO, or their enhanced versions (QOJAYA, GOTLBO, ITLBO) due to their parameter-free nature and good general performance. For multi-objective problems, MO-TLBO is the recommended choice.