pydecision 4.5.9__py3-none-any.whl

pyDecision/__init__.py

@@ -0,0 +1 @@
+

pyDecision/algorithm/__init__.py

@@ -0,0 +1,80 @@
+from .ahp           import ahp_method
+from .aras          import aras_method
+from .borda         import borda_method
+from .bwm           import bw_method
+from .bwm_s         import simplified_bw_method
+from .cilos         import cilos_method
+from .cocoso        import cocoso_method
+from .codas         import codas_method
+from .copeland      import copeland_method
+from .copras        import copras_method
+from .cradis        import cradis_method
+from .critic        import critic_method
+from .dematel       import dematel_method
+from .e_i           import electre_i
+from .e_i_s         import electre_i_s
+from .e_i_v         import electre_i_v
+from .e_ii          import electre_ii
+from .e_iii         import electre_iii
+from .e_iv          import electre_iv
+from .e_tri_b       import electre_tri_b
+from .edas          import edas_method
+from .entropy       import entropy_method
+from .fucom         import fucom_method
+from .fuzzy_ahp     import fuzzy_ahp_method
+from .fuzzy_ahp_ppf import ppf_ahp_method
+from .fuzzy_aras    import fuzzy_aras_method
+from .fuzzy_bwm     import fuzzy_bw_method
+from .fuzzy_copras  import fuzzy_copras_method
+from .fuzzy_critic  import fuzzy_critic_method
+from .fuzzy_dematel import fuzzy_dematel_method
+from .fuzzy_edas    import fuzzy_edas_method
+from .fuzzy_fucom   import fuzzy_fucom_method
+from .fuzzy_merec   import fuzzy_merec_method
+from .fuzzy_moora   import fuzzy_moora_method
+from .fuzzy_ocra    import fuzzy_ocra_method
+from .fuzzy_topsis  import fuzzy_topsis_method
+from .fuzzy_vikor   import fuzzy_vikor_method
+from .fuzzy_waspas  import fuzzy_waspas_method
+from .gra           import gra_method
+from .idocriw       import idocriw_method
+from .mabac         import mabac_method
+from .macbeth       import macbeth_method
+from .mairca        import mairca_method
+from .mara          import mara_method
+from .marcos        import marcos_method
+from .maut          import maut_method
+from .merec         import merec_method
+from .moora         import moora_method
+from .moosra        import moosra_method
+from .multimoora    import multimoora_method  
+from .ocra          import ocra_method
+from .opa           import opa_method
+from .oreste        import oreste_method
+from .p_ec          import ec_promethee, solution_p_ranking, plot_rank_freq, find_column_modes
+from .p_i           import promethee_i
+from .p_ii          import promethee_ii
+from .p_iii         import promethee_iii
+from .p_iv          import promethee_iv
+from .p_v           import promethee_v
+from .p_vi          import promethee_vi
+from .p_xgaia       import promethee_gaia
+from .piv           import piv_method
+from .psi           import psi_method
+from .psi_m         import mpsi_method
+from .rafsi         import rafsi_method
+from .regime        import regime_method
+from .roc           import roc_method
+from .rov           import rov_method
+from .rrw           import rrw_method
+from .rsw           import rsw_method
+from .saw           import saw_method
+from .seca          import seca_method
+from .smart         import smart_method
+from .spotis        import spotis_method
+from .todim         import todim_method
+from .topsis        import topsis_method
+from .vikor         import vikor_method, ranking
+from .waspas        import waspas_method
+from .wisp          import wisp_method
+from .wings         import wings_method

pyDecision/algorithm/ahp.py

@@ -0,0 +1,35 @@
+###############################################################################
+
+# Required Libraries
+import numpy as np
+from functools import reduce
+
+###############################################################################
+
+# Function: AHP (Analytic Hierarchy Process)
+def ahp_method(dataset, wd = 'm'):
+    inc_rat  = np.array([0, 0, 0, 0.58, 0.9, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49, 1.51, 1.48, 1.56, 1.57, 1.59])
+    X        = np.copy(dataset)
+    weights  = np.zeros(X.shape[1])
+    if (wd == 'm' or wd == 'mean'):
+        weights  = np.mean(X/np.sum(X, axis = 0), axis = 1)
+        vector   = np.sum(X*weights, axis = 1)/weights
+        lamb_max = np.mean(vector)
+    elif (wd == 'g' or wd == 'geometric'):
+        for i in range (0, X.shape[1]):
+            weights[i] = reduce( (lambda x, y: x * y), X[i,:])**(1/X.shape[1])
+        weights  = weights/np.sum(weights)   
+        vector   = np.sum(X*weights, axis = 1)/weights
+        lamb_max = np.mean(vector)
+    elif (wd == 'me' or wd == 'max_eigen'):
+        eigenvalues, eigenvectors = np.linalg.eig(X)
+        eigenvalues_real          = np.real(eigenvalues)
+        lamb_max_index            = np.argmax(eigenvalues_real)
+        lamb_max                  = eigenvalues_real[lamb_max_index]
+        principal_eigenvector     = np.real(eigenvectors[:, lamb_max_index])
+        weights                   = principal_eigenvector / principal_eigenvector.sum()
+    cons_ind = (lamb_max - X.shape[1])/(X.shape[1] - 1)
+    rc       = cons_ind/inc_rat[X.shape[1]]
+    return weights, rc
+
+###############################################################################

pyDecision/algorithm/aras.py

@@ -0,0 +1,65 @@
+###############################################################################
+
+# Required Libraries
+import matplotlib.pyplot as plt
+import numpy as np
+
+###############################################################################
+
+# Function: Rank 
+def ranking(flow):    
+    rank_xy = np.zeros((flow.shape[0], 2))
+    for i in range(0, rank_xy.shape[0]):
+        rank_xy[i, 0] = 0
+        rank_xy[i, 1] = flow.shape[0]-i           
+    for i in range(0, rank_xy.shape[0]):
+        plt.text(rank_xy[i, 0],  rank_xy[i, 1], 'a' + str(int(flow[i,0])), size = 12, ha = 'center', va = 'center', bbox = dict(boxstyle = 'round', ec = (0.0, 0.0, 0.0), fc = (0.8, 1.0, 0.8),))
+    for i in range(0, rank_xy.shape[0]-1):
+        plt.arrow(rank_xy[i, 0], rank_xy[i, 1], rank_xy[i+1, 0] - rank_xy[i, 0], rank_xy[i+1, 1] - rank_xy[i, 1], head_width = 0.01, head_length = 0.2, overhang = 0.0, color = 'black', linewidth = 0.9, length_includes_head = True)
+    axes = plt.gca()
+    axes.set_xlim([-1, +1])
+    ymin = np.amin(rank_xy[:,1])
+    ymax = np.amax(rank_xy[:,1])
+    if (ymin < ymax):
+        axes.set_ylim([ymin, ymax])
+    else:
+        axes.set_ylim([ymin-1, ymax+1])
+    plt.axis('off')
+    plt.show() 
+    return
+
+# Function: ARAS (Additive Ratio Assessment)
+def aras_method(dataset, weights, criterion_type, graph = True, verbose = True):
+    X   = np.copy(dataset)/1.0
+    bst = np.zeros(X.shape[1])
+    bsm = np.zeros(X.shape[1])
+    for j in range(0, X.shape[1]):
+        if ( criterion_type[j] == 'max'):
+            bst[j] = np.max(X[:, j])
+            bsm[j] = bst[j] + np.sum(X[:, j])
+        elif ( criterion_type[j] == 'min'):
+            bst[j]  = 1/np.min(X[:, j])
+            X[:,j]  = 1/X[:, j]
+            bsm[j]  = bst[j] + np.sum(X[:, j])
+    for j in range(0, X.shape[1]):
+        bst[j] = bst[j]/ bsm[j]
+        for i in range(0, X.shape[0]):
+            X[i, j] = X[i, j]/ bsm[j]
+    X    = X * weights
+    bst  = bst * weights
+    n_0  = np.sum(bst)
+    n_i  = np.sum(X, axis = 1)
+    k_i  = n_i/n_0
+    flow = np.copy(k_i)
+    flow = np.reshape(flow, (k_i.shape[0], 1))
+    flow = np.insert(flow, 0, list(range(1, k_i.shape[0]+1)), axis = 1)
+    if (verbose == True):
+        for i in range(0, flow.shape[0]):
+            print('a' + str(int(flow[i,0])) + ': ' + str(round(flow[i,1], 3))) 
+    if (graph == True):
+        flow = flow[np.argsort(flow[:, 1])]
+        flow = flow[::-1]
+        ranking(flow)
+    return flow
+
+###############################################################################

pyDecision/algorithm/borda.py

@@ -0,0 +1,51 @@
+###############################################################################
+
+# Required Libraries
+import matplotlib.pyplot as plt
+import numpy as np
+
+###############################################################################
+
+# Function: Rank 
+def ranking(flow):    
+    rank_xy = np.zeros((flow.shape[0], 2))
+    for i in range(0, rank_xy.shape[0]):
+        rank_xy[i, 0] = 0
+        rank_xy[i, 1] = flow.shape[0]-i           
+    for i in range(0, rank_xy.shape[0]):
+        plt.text(rank_xy[i, 0],  rank_xy[i, 1], 'a' + str(int(flow[i,0])), size = 12, ha = 'center', va = 'center', bbox = dict(boxstyle = 'round', ec = (0.0, 0.0, 0.0), fc = (0.8, 1.0, 0.8),))
+    for i in range(0, rank_xy.shape[0]-1):
+        plt.arrow(rank_xy[i, 0], rank_xy[i, 1], rank_xy[i+1, 0] - rank_xy[i, 0], rank_xy[i+1, 1] - rank_xy[i, 1], head_width = 0.01, head_length = 0.2, overhang = 0.0, color = 'black', linewidth = 0.9, length_includes_head = True)
+    axes = plt.gca()
+    axes.set_xlim([-1, +1])
+    ymin = np.amin(rank_xy[:,1])
+    ymax = np.amax(rank_xy[:,1])
+    if (ymin < ymax):
+        axes.set_ylim([ymin, ymax])
+    else:
+        axes.set_ylim([ymin-1, ymax+1])
+    plt.axis('off')
+    plt.show() 
+    return
+
+# Function: Borda
+def borda_method(dataset, criterion_type, graph = True, verbose = True):
+    X = np.zeros((dataset.shape[0], dataset.shape[1]))
+    for j in range(0, dataset.shape[1]):
+        if (criterion_type[j] == 'max'):
+            X[:,j] = np.argsort(np.argsort(-dataset[:,j]))+1
+        else:
+            X[:,j] = np.argsort(np.argsort(dataset[:,j]))+1
+    total = np.sum(X, axis = 1)
+    if (verbose == True):
+        for i in range(0, total.shape[0]):
+            print('a' + str(i+1) + ': ' + str(round(total[i], 2)))
+    if ( graph == True):
+        flow = np.copy(total)
+        flow = np.reshape(flow, (total.shape[0], 1))
+        flow = np.insert(flow, 0, list(range(1, total.shape[0]+1)), axis = 1)
+        flow = flow[np.argsort(flow[:, 1])]
+        ranking(flow)
+    return total
+
+###############################################################################

pyDecision/algorithm/bwm.py

@@ -0,0 +1,63 @@
+###############################################################################
+
+# Required Libraries
+import numpy as np
+import warnings
+warnings.filterwarnings('ignore', message = 'delta_grad == 0.0. Check if the approximated')
+
+from scipy.optimize import minimize, Bounds, LinearConstraint
+
+###############################################################################
+
+# Function: BWM
+def bw_method(mic, lic, eps_penalty = 1, verbose = True):
+    cr = []
+    mx = np.max(mic) 
+    if (mx == 1):
+        cr = 1
+    else:
+        for i in range(0, mic.shape[0]):
+            cr.append((mic[i] * lic[i] - mx)/(mx**2 - mx))
+    cr        = np.max(cr)
+    threshold = [0, 0, 0, 0.1667, 0.1898, 0.2306, 0.2643, 0.2819, 0.2958, 0.3062]
+    if (verbose == True):
+        if (cr <= threshold[mx]):
+            print('CR:', np.round(cr, 4), '(The Consistency Level is Acceptable)')
+        else:
+            print('CR:', np.round(cr, 4), '(The Consistency Level is Not Acceptable)')
+    
+    ################################################
+    def target_function(variables):
+        eps     = variables[-1]
+        wx      = variables[np.argmin(mic)]
+        wy      = variables[np.argmin(lic)]
+        cons_1  = []
+        cons_2  = []
+        penalty = 0
+        for i in range(0, mic.shape[0]):
+            cons_1.append(wx - mic[i] * variables[i])
+        cons_1.extend([-item for item in cons_1])
+        for i in range(0, lic.shape[0]):
+            cons_2.append(variables[i] - lic[i] * wy)
+        cons_2.extend([-item for item in cons_2])
+        cons = cons_1 + cons_2
+        for item in cons:
+            if (item > eps):
+                penalty = penalty + (item - eps) * 1
+        penalty = penalty + eps * eps_penalty
+        return penalty
+    ################################################
+    
+    np.random.seed(42)
+    variables = np.random.uniform(low = 0.001, high = 1.0, size = mic.shape[0])
+    variables = variables / np.sum(variables)
+    variables = np.append(variables, [0])
+    bounds    = Bounds([0]*mic.shape[0] + [0], [1]*mic.shape[0] + [1])
+    w_cons    = LinearConstraint(np.append(np.ones(mic.shape[0]), [0]), [1], [1])
+    results   = minimize(target_function, variables, method = 'trust-constr', bounds = bounds, constraints = [w_cons])
+    weights   = results.x[:-1]
+    if (verbose == True):
+        print('Epsilon Value:', np.round(results.x[-1], 4))
+    return weights
+
+###############################################################################

pyDecision/algorithm/bwm_s.py

@@ -0,0 +1,32 @@
+###############################################################################
+
+# Required Libraries
+import numpy as np
+
+###############################################################################
+
+# Function: Simplified BWM
+def simplified_bw_method(mic, lic, alpha = 0.5,verbose = True):
+  ib  = np.argmin(mic)
+  iw  = np.argmin(lic)
+  wb  = [ 1 for item in mic]
+  ww  = [ 1 for item in lic]
+  div = 0
+  for i in range(0, mic.shape[0]):
+    a   = mic[i]
+    div = div + 1/a
+  wb[ib] = 1/div
+  for i in range(0, mic.shape[0]):
+    if (i != ib):
+      wb[i] = wb[ib]/mic[i]
+  ww[iw] = 1/np.sum(lic)
+  for i in range(0, lic.shape[0]):
+    if (i != iw):
+      ww[i] = lic[i]*ww[iw]
+  w  = [alpha*wb[i] + (1 - alpha)*ww[i] for i in range(0, mic.shape[0])]
+  cr = sum([abs(wb[i] - ww[i]) for i in range(0, mic.shape[0])])
+  if (verbose == True):
+    print('CR:', np.round(cr, 4))
+  return cr, w
+
+###############################################################################

pyDecision/algorithm/cilos.py

@@ -0,0 +1,35 @@
+###############################################################################
+
+# Required Libraries
+import numpy as np
+
+from scipy.linalg import null_space
+
+###############################################################################
+
+# Function: CILOS (Criterion Impact LOSs)
+def cilos_method(dataset, criterion_type):
+    X = np.copy(dataset)/1.0
+    for j in range(X.shape[1]):
+        divisor = np.min(X[:, j]) if criterion_type[j] == 'max' else np.max(X[:, j])
+        if (divisor == 0):  
+            X[:, j] = 1e-9
+        else:
+            X[:, j] = X[:, j] / divisor
+        sum_X_j = np.sum(X[:, j])
+        if (sum_X_j == 0):  
+            X[:, j] = 1e-9
+        else:
+            X[:, j] = X[:, j] / sum_X_j
+    for j in range(X.shape[1]):
+        unique_vals = np.unique(X[:, j])
+        if (len(unique_vals) == 1):
+            X[:, j] = X[:, j] + np.random.uniform(low=1e-2, high=1e-1, size=X[:, j].shape)
+    A = X[np.argmax(X, axis = 0)]
+    P = (np.diag(A) - A) / np.diag(A)
+    F = P - np.diag(np.sum(P, axis = 0))
+    q = null_space(F)
+    q = (q / np.sum(q)).flatten()
+    return q
+
+###############################################################################

pyDecision/algorithm/cocoso.py

@@ -0,0 +1,67 @@
+###############################################################################
+
+# Required Libraries
+import matplotlib.pyplot as plt
+import numpy as np
+
+###############################################################################
+
+# Function: Rank 
+def ranking(flow):    
+    rank_xy = np.zeros((flow.shape[0], 2))
+    for i in range(0, rank_xy.shape[0]):
+        rank_xy[i, 0] = 0
+        rank_xy[i, 1] = flow.shape[0]-i           
+    for i in range(0, rank_xy.shape[0]):
+        plt.text(rank_xy[i, 0],  rank_xy[i, 1], 'a' + str(int(flow[i,0])), size = 12, ha = 'center', va = 'center', bbox = dict(boxstyle = 'round', ec = (0.0, 0.0, 0.0), fc = (0.8, 1.0, 0.8),))
+    for i in range(0, rank_xy.shape[0]-1):
+        plt.arrow(rank_xy[i, 0], rank_xy[i, 1], rank_xy[i+1, 0] - rank_xy[i, 0], rank_xy[i+1, 1] - rank_xy[i, 1], head_width = 0.01, head_length = 0.2, overhang = 0.0, color = 'black', linewidth = 0.9, length_includes_head = True)
+    axes = plt.gca()
+    axes.set_xlim([-1, +1])
+    ymin = np.amin(rank_xy[:,1])
+    ymax = np.amax(rank_xy[:,1])
+    if (ymin < ymax):
+        axes.set_ylim([ymin, ymax])
+    else:
+        axes.set_ylim([ymin-1, ymax+1])
+    plt.axis('off')
+    plt.show() 
+    return
+
+# Function: COCOSO (COmbined COmpromise SOlution)
+def cocoso_method(dataset, criterion_type, weights, L = 0.5, graph = True, verbose = True):
+    X     = np.copy(dataset)/1.0
+    best  = np.zeros(X.shape[1])
+    worst = np.zeros(X.shape[1])
+    for i in range(0, dataset.shape[1]):
+        if (criterion_type[i] == 'max'):
+            best[i]  = np.max(X[:, i])
+            worst[i] = np.min(X[:, i])
+        else:
+            best[i]  = np.min(X[:, i])
+            worst[i] = np.max(X[:, i])        
+    for j in range(0, X.shape[1]):
+        X[:,j] = ( X[:,j] - worst[j] ) / ( best[j] - worst[j] + 0.0000000000000001) 
+    S      = np.sum(X  * weights, axis = 1)
+    P      = np.sum(X ** weights, axis = 1)
+    if (np.min(S) == 0):
+        S = S + 1
+    if (np.min(P) == 0):
+        P = P + 1
+    ksi_a  = (P + S) / np.sum(P + S, axis = 0)
+    ksi_b  = (S / np.min(S)) + (P / np.min(P))
+    ksi_c  = (L * S + (1 - L) * P) / (L * np.max(S) + (1 - L) * np.max(P))
+    ksi    = np.power(ksi_a * ksi_b * ksi_c, 1/3) + 1/3 * (ksi_a + ksi_b + ksi_c)
+    if (verbose == True):
+        for i in range(0, ksi.shape[0]):
+            print('a' + str(i+1) + ': ' + str(round(ksi[i], 2)))
+    if ( graph == True):
+        flow = np.copy(ksi)
+        flow = np.reshape(flow, (ksi.shape[0], 1))
+        flow = np.insert(flow, 0, list(range(1, ksi.shape[0]+1)), axis = 1)
+        flow = flow[np.argsort(flow[:, 1])]
+        flow = flow[::-1]
+        ranking(flow)
+    return ksi
+
+###############################################################################

pyDecision/algorithm/codas.py

@@ -0,0 +1,65 @@
+###############################################################################
+
+# Required Libraries
+import matplotlib.pyplot as plt
+import numpy as np
+
+###############################################################################
+
+# Function: Rank 
+def ranking(flow):    
+    rank_xy = np.zeros((flow.shape[0], 2))
+    for i in range(0, rank_xy.shape[0]):
+        rank_xy[i, 0] = 0
+        rank_xy[i, 1] = flow.shape[0]-i           
+    for i in range(0, rank_xy.shape[0]):
+        plt.text(rank_xy[i, 0],  rank_xy[i, 1], 'a' + str(int(flow[i,0])), size = 12, ha = 'center', va = 'center', bbox = dict(boxstyle = 'round', ec = (0.0, 0.0, 0.0), fc = (0.8, 1.0, 0.8),))
+    for i in range(0, rank_xy.shape[0]-1):
+        plt.arrow(rank_xy[i, 0], rank_xy[i, 1], rank_xy[i+1, 0] - rank_xy[i, 0], rank_xy[i+1, 1] - rank_xy[i, 1], head_width = 0.01, head_length = 0.2, overhang = 0.0, color = 'black', linewidth = 0.9, length_includes_head = True)
+    axes = plt.gca()
+    axes.set_xlim([-1, +1])
+    ymin = np.amin(rank_xy[:,1])
+    ymax = np.amax(rank_xy[:,1])
+    if (ymin < ymax):
+        axes.set_ylim([ymin, ymax])
+    else:
+        axes.set_ylim([ymin-1, ymax+1])
+    plt.axis('off')
+    plt.show() 
+    return
+
+# Function: CODAS (Combinative Distance-based Assessment)
+def codas_method(dataset, weights, criterion_type, lmbd = 0.02, graph = True, verbose = True):
+    X   = np.copy(dataset)/1.0
+    bst = np.zeros(X.shape[1])
+    r_m = np.zeros((X.shape[0], X.shape[0]))
+    for j in range(0, X.shape[1]):
+        if ( criterion_type[j] == 'max'):
+            bst[j] = np.max(X[:, j])
+        elif ( criterion_type[j] == 'min'):
+            bst[j] = np.min(X[:, j])
+    for j in range(0, X.shape[1]):
+        for i in range(0, X.shape[0]):
+            if ( criterion_type[j] == 'max'):
+                X[i, j] = X[i, j]/bst[j]
+            elif ( criterion_type[j] == 'min'):
+                X[i, j] = bst[j]/X[i, j]
+    X   = X * weights
+    n_i = np.min(X, axis = 0)
+    e_i = np.sum( (X - n_i)**2, axis = 1)**(1/2)
+    t_i = np.sum( abs(X - n_i), axis = 1)
+    for j in range(0, r_m.shape[1]):
+        for i in range(0, r_m.shape[0]):
+            r_m[i, j] = (e_i[i] - e_i[j]) + lmbd*( (e_i[i] - e_i[j]) *  (t_i[i] - t_i[j]) )
+    h_i  = np.sum(r_m, axis = 1)
+    flow = np.copy(h_i)
+    flow = np.reshape(flow, (h_i.shape[0], 1))
+    flow = np.insert(flow, 0, list(range(1, h_i.shape[0]+1)), axis = 1)
+    if (verbose == True):
+        for i in range(0, flow.shape[0]):
+            print('a' + str(int(flow[i,0])) + ': ' + str(round(flow[i,1], 3))) 
+    if (graph == True):
+        flow = flow[np.argsort(flow[:, 1])]
+        flow = flow[::-1]
+        ranking(flow)
+    return flow

pyDecision/algorithm/copeland.py

@@ -0,0 +1,65 @@
+###############################################################################
+
+# Required Libraries
+import matplotlib.pyplot as plt
+import numpy as np
+
+###############################################################################
+
+# Function: Rank 
+def ranking(flow):    
+    rank_xy = np.zeros((flow.shape[0], 2))
+    for i in range(0, rank_xy.shape[0]):
+        rank_xy[i, 0] = 0
+        rank_xy[i, 1] = flow.shape[0]-i           
+    for i in range(0, rank_xy.shape[0]):
+        plt.text(rank_xy[i, 0],  rank_xy[i, 1], 'a' + str(int(flow[i,0])), size = 12, ha = 'center', va = 'center', bbox = dict(boxstyle = 'round', ec = (0.0, 0.0, 0.0), fc = (0.8, 1.0, 0.8),))
+    for i in range(0, rank_xy.shape[0]-1):
+        plt.arrow(rank_xy[i, 0], rank_xy[i, 1], rank_xy[i+1, 0] - rank_xy[i, 0], rank_xy[i+1, 1] - rank_xy[i, 1], head_width = 0.01, head_length = 0.2, overhang = 0.0, color = 'black', linewidth = 0.9, length_includes_head = True)
+    axes = plt.gca()
+    axes.set_xlim([-1, +1])
+    ymin = np.amin(rank_xy[:,1])
+    ymax = np.amax(rank_xy[:,1])
+    if (ymin < ymax):
+        axes.set_ylim([ymin, ymax])
+    else:
+        axes.set_ylim([ymin-1, ymax+1])
+    plt.axis('off')
+    plt.show() 
+    return
+
+# Function: Copeland
+def copeland_method(dataset, criterion_type, graph = True, verbose = True):
+    X = np.zeros((dataset.shape[0], dataset.shape[0]))
+    for i in range(0, dataset.shape[0]):
+        for k in range(0, dataset.shape[0]):
+            if (i != k):
+                for j in range(0, dataset.shape[1]):
+                    if (criterion_type[j] == 'max'):
+                        if (dataset[i, j] > dataset[k, j]):
+                            X[i,k] = X[i,k] + 1
+                        if (dataset[i, j] == dataset[k, j]):
+                            X[i,k] = X[i,k] + 0
+                        if (dataset[i, j] < dataset[k, j]):
+                            X[i,k] = X[i,k] - 1
+                    else:
+                        if (dataset[i, j] > dataset[k, j]):
+                            X[i,k] = X[i,k] - 1
+                        if (dataset[i, j] == dataset[k, j]):
+                            X[i,k] = X[i,k] + 0
+                        if (dataset[i, j] < dataset[k, j]):
+                            X[i,k] = X[i,k] + 1 
+    total = np.sum(X, axis = 1)
+    if (verbose == True):
+        for i in range(0, total.shape[0]):
+            print('a' + str(i+1) + ': ' + str(round(total[i], 2)))
+    if ( graph == True):
+        flow = np.copy(total)
+        flow = np.reshape(flow, (total.shape[0], 1))
+        flow = np.insert(flow, 0, list(range(1, total.shape[0]+1)), axis = 1)
+        flow = flow[np.argsort(flow[:, 1])]
+        flow = flow[::-1]
+        ranking(flow)
+    return total
+
+###############################################################################

pyDecision/algorithm/copras.py

@@ -0,0 +1,61 @@
+###############################################################################
+
+# Required Libraries
+import matplotlib.pyplot as plt
+import numpy as np
+
+###############################################################################
+
+# Function: Rank 
+def ranking(flow):    
+    rank_xy = np.zeros((flow.shape[0], 2))
+    for i in range(0, rank_xy.shape[0]):
+        rank_xy[i, 0] = 0
+        rank_xy[i, 1] = flow.shape[0]-i           
+    for i in range(0, rank_xy.shape[0]):
+        plt.text(rank_xy[i, 0],  rank_xy[i, 1], 'a' + str(int(flow[i,0])), size = 12, ha = 'center', va = 'center', bbox = dict(boxstyle = 'round', ec = (0.0, 0.0, 0.0), fc = (0.8, 1.0, 0.8),))
+    for i in range(0, rank_xy.shape[0]-1):
+        plt.arrow(rank_xy[i, 0], rank_xy[i, 1], rank_xy[i+1, 0] - rank_xy[i, 0], rank_xy[i+1, 1] - rank_xy[i, 1], head_width = 0.01, head_length = 0.2, overhang = 0.0, color = 'black', linewidth = 0.9, length_includes_head = True)
+    axes = plt.gca()
+    axes.set_xlim([-1, +1])
+    ymin = np.amin(rank_xy[:,1])
+    ymax = np.amax(rank_xy[:,1])
+    if (ymin < ymax):
+        axes.set_ylim([ymin, ymax])
+    else:
+        axes.set_ylim([ymin-1, ymax+1])
+    plt.axis('off')
+    plt.show() 
+    return
+
+# Function: COPRAS (Complex Proportional Assessment)
+def copras_method(dataset, weights, criterion_type, graph = True, verbose = True):
+    X   = np.copy(dataset)/1.0
+    X   = X/np.sum(X, axis = 0)
+    X   = X*weights
+    s_p = np.zeros(X.shape[0])
+    s_m = np.zeros(X.shape[0])
+    s_d = np.zeros(X.shape[0])
+    q_i = np.zeros(X.shape[0])
+    u_i = np.zeros(X.shape[0])
+    id1 = [i for i, j in enumerate(criterion_type) if j == 'max']
+    id2 = [i for i, j in enumerate(criterion_type) if j == 'min']
+    if (len(id1) > 0):
+        s_p = np.sum(X[:,id1], axis = 1)
+        q_i = s_p
+    if (len(id2) > 0):
+        s_m = np.sum(X[:,id2], axis = 1)
+        s_d = np.min(s_m)/s_m
+        q_i = s_p + (np.min(s_m)*np.sum(s_m))/(s_m*np.sum(s_d))
+    u_i = q_i/np.max(q_i)
+    flow = np.copy(u_i)
+    flow = np.reshape(flow, (u_i.shape[0], 1))
+    flow = np.insert(flow, 0, list(range(1, u_i.shape[0]+1)), axis = 1)
+    if (verbose == True):
+        for i in range(0, flow.shape[0]):
+            print('a' + str(int(flow[i,0])) + ': ' + str(round(flow[i,1], 3))) 
+    if (graph == True):
+        flow = flow[np.argsort(flow[:, 1])]
+        flow = flow[::-1]
+        ranking(flow)
+    return flow