Added Toy example, CVaR comparison and Optimizer comparison files to

ExactCover/utilities_exactCover.py

@@ -0,0 +1,35 @@
+import math
+import itertools
+
+def computeOptimalSolution(minus_cost_func, isFeasible_func, FR):
+    cost = math.inf
+    sol = ""
+    nL = FR.shape[1]
+    for s in [''.join(i) for i in itertools.product('01', repeat =nL)]:
+        if isFeasible_func(s):
+            if -minus_cost_func(s)<cost:
+                cost = -minus_cost_func(s)
+                sol = s
+
+    return cost, sol
+
+
+def computeAverageApproxRatio(hist, mincost, minus_cost_func):
+    #Include the cost of infeasible solutions in average approx ratio or give them approx ratio = 0?
+    tot_shots = 0
+    avg_approx_ratio = 0
+    for key in hist:
+        shots = hist[key]
+        tot_shots += shots
+        cost = -minus_cost_func(key[::-1])   #Qiskit uses big endian encoding, cost function uses litle endian encoding.
+                                                    #Therefore the string is reversed before passing it to the cost function.
+        approx_ratio = mincost/cost #Only do this to feasible solutions?? And give them 0
+        avg_approx_ratio += approx_ratio*shots
+    avg_approx_ratio = avg_approx_ratio/tot_shots
+    return avg_approx_ratio
+
+
+
+
+
+

PortfolioOptimization/utilities_portOpt.py

@@ -0,0 +1,55 @@
+import math
+import itertools
+
+
+def approxRatio(cost, max_feasible, min_feasible):
+        #Approximation ratio for feasible solutions of the portfolio optimization problem. Unfeasible solutions
+        #have approximation ratio zero.
+        #https://link.springer.com/article/10.1007/s11128-022-03766-5
+        approx_ratio = (cost-max_feasible)/(min_feasible-max_feasible)
+        return approx_ratio
+
+
+
+
+def computeMinMaxCosts(N_assets, minusCostFunction, isFeasible):
+    best_sol= None
+    min_cost = math.inf
+    costs_feasible = []
+    costs = []
+    for s in [''.join(i) for i in itertools.product('01', repeat = N_assets)]:
+
+        c_penalty = -minusCostFunction(s) #function returns -cost
+        costs.append(c_penalty)
+        if isFeasible(s):
+            costs_feasible.append(c_penalty)
+        if c_penalty < min_cost and isFeasible(s):
+
+            best_sol = s[::-1]  #Qiskit uses big endian encoding, cost function uses litle endian encoding.
+                                          #Therefore the string is reversed before passing it to the cost function.
+            min_cost= c_penalty
+        else: 
+            pass
+    return min_cost, max(costs_feasible), best_sol
+
+
+
+
+def computeAverageApproxRatio(hist, max_feasible, min_feasible, minusCostFunction, isFeasible):
+    #Takes in histogram and computes the average approximation ratio
+    tot_shots = 0
+    avg_approx_ratio = 0
+
+    for key in hist:
+
+        shots  = hist[key]
+        tot_shots = tot_shots + shots
+
+        if isFeasible(key):
+            cost = -minusCostFunction(key[::-1])   #Qiskit uses big endian encoding, cost function uses litle endian encoding.
+                                                    #Therefore the string is reversed before passing it to the cost function.
+            approx_for_key = approxRatio(cost, max_feasible, min_feasible)*shots
+            avg_approx_ratio += approx_for_key
+
+    avg_approx_ratio = avg_approx_ratio/tot_shots
+    return avg_approx_ratio

README.md

@@ -1,2 +1,17 @@
-# optimization
-Algorithms for optimization tasks (operations research)
+# Openquantumcomputing QAOA
+A python library for for quantum optimization using QAOA on quantum computer simulators.
+
+# Installation instructions
+The latest version of openquantumcomputing is installed directly from PyPI by the following command: 
+
+'''
+pip install openquantumcomputing
+'''
+...
+# Example notebooks
+Under the optimization folder a number of examples of use of the library can be found in different notebooks, for different optimization problems. All of the notebooks are roughly structured in the following way:
+1. Importing necassary modules
+2. Creating problem instance
+3. Creating QAOA instance
+4. Increasing depth for the QAOA instances
+5. Computing and plotting the approximation ratio for the given problem