PyIFDM

https://pyifdm.readthedocs.io/en/latest/
Admin
PyIFDM is a Python package for Multi-Criteria Decision Analysis (MCDA) combined with Intuitionistic...
Tokens:83,152
Snippets:511
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install pyifdm Package

Source: https://pyifdm.readthedocs.io/en/latest/readme_link.html

Use pip to install the pyifdm package. This is the primary method for obtaining the library.

```bash
pip install pyifdm

```

--------------------------------

### Install and Run Pytest for pyifdm

Source: https://pyifdm.readthedocs.io/en/latest/readme_link.html

Install the pytest library and run tests for the pyifdm package. Ensure you have the tests directory available.

```bash
pip install pytest
pytest tests

```

--------------------------------

### Intuitionistic Fuzzy EDAS Method Example

Source: https://pyifdm.readthedocs.io/en/latest/readme_link.html

Demonstrates the application of the Intuitionistic Fuzzy EDAS method using sample data. This example requires numpy for matrix operations and specific modules from pyifdm.

```python
from pyifdm.methods import ifEDAS
from pyifdm.helpers import rank
import numpy as np

if __name__ == '__main__':
    matrix = np.array([
        [[0.4745, 0.5255], [0.4752, 0.5248], [0.2981, 0.7019], [0.4374, 0.5627]],
        [[0.5346, 0.4654], [0.5532, 0.4468], [0.6300, 0.3700], [0.5901, 0.4099]],
        [[0.4324, 0.5676], [0.4030, 0.5970], [0.4298, 0.5702], [0.4361, 0.5639]],
        [[0.5235, 0.4765], [0.4808, 0.5192], [0.5667, 0.4333], [0.2913, 0.7087]],
        [[0.4168, 0.5832], [0.4923, 0.5077], [0.4732, 0.5268], [0.4477, 0.5523]]
    ])

    weights = np.array([0.2, 0.3, 0.15, 0.35])

    types = np.array([1, -1, 1, 1])

    if_edas = ifEDAS()
    pref = if_edas(matrix, weights, types)

    print(f'IF-EDAS preferences: {pref}')
    print(f'IF-EDAS ranking: {rank(pref)}')


```

--------------------------------

### Define Decision Matrix for IFS Evaluation

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Example of creating a decision matrix where rows represent alternatives and columns represent criteria. Elements must be Intuitionistic Fuzzy Sets, allowing 2 or 3 elements per set.

```python
import numpy as np

matrix = np.array([
    [[0.4745, 0.5255], [0.4752, 0.5248], [0.2981, 0.7019], [0.4374, 0.5627]],
    [[0.5346, 0.4654], [0.5532, 0.4468], [0.6300, 0.3700], [0.5901, 0.4099]],
    [[0.4324, 0.5676], [0.4030, 0.5970], [0.4298, 0.5702], [0.4361, 0.5639]],
    [[0.5235, 0.4765], [0.4808, 0.5192], [0.5667, 0.4333], [0.2913, 0.7087]],
    [[0.4168, 0.5832], [0.4923, 0.5077], [0.4732, 0.5268], [0.4477, 0.5523]]
])
```

--------------------------------

### Initialize and Use IFS Class

Source: https://pyifdm.readthedocs.io/en/latest/pyifdm.IFS.html

Demonstrates the initialization of IFS objects and the usage of common set operations like intersection, union, and complement. Also shows how to perform OWA aggregation with custom weights.

```python
# Example Usage:
ifs1 = IFS(0.6, 0.2)
ifs2 = IFS(0.8, 0.1)
intersection_result = ifs1 & ifs2
union_result = ifs1 | ifs2
complement_result = ~ifs1
owa_weights = [0.3, 0.4, 0.3]
owa_result = ifs1.owa_aggregation(owa_weights)
```

--------------------------------

### Initialize ifTOPSIS Method

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_topsis.html

Creates an Intuitionistic Fuzzy TOPSIS method object. Customize the distance and normalization functions used in calculations.

```python
from .topsis.ifs import ifs
from .ifs.distance import normalized_euclidean_distance
from ..helpers import rank

from .validator import Validator




class ifTOPSIS():


    def __init__(self, distance=normalized_euclidean_distance, normalization=None):
        """
        Creates Intuitionistic Fuzzy TOPSIS method object with normalization and distance functions

        Parameters
        ----------
            distance: callable, default=normalized_euclidean_distance
                Function used to calculate distance between two IFS
            
            normalization: callable, default=None
                Function used to normalize the decision matrix

        """

        self.normalization = normalization
        self.distance = distance
        self.__descending = True
```

--------------------------------

### Get IF-ARAS Ranking

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Calculate the ranking of alternatives after performing the IF-ARAS evaluation. This method sorts the results.

```python
if_aras.rank()
```

--------------------------------

### IF-MARCOS Method Usage

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Demonstrates the basic usage of the IF-MARCOS method, which is suitable for crisp weights. It calculates and prints the preferences and ranking of alternatives.

```python
if_marcos = methods.ifMARCOS()
print(f'Preferences: {if_marcos(matrix, crisp_weights, types)}')
print(f'Ranking: {if_marcos.rank()}')
```

--------------------------------

### Define Crisp Weights

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Example of defining crisp weights as a NumPy array. Ensure the number of weights matches the number of criteria.

```python
crisp_weights = np.array([0.2, 0.3, 0.15, 0.35])
```

--------------------------------

### Apply IF-MOORA Method

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Applies the IF-MOORA method to a decision matrix with fuzzy weights and types. Use this to get preferences and rankings for alternatives.

```python
if_moora = methods.ifMOORA()
print(f'Preferences: {if_moora(matrix, fuzzy_weights, types)}')
print(f'Ranking: {if_moora.rank()}')
```

--------------------------------

### Initialize and Use IF-CODAS

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Initializes the IF-CODAS method and prints the preferences and ranking. Assumes matrix, fuzzy_weights, and types are pre-defined.

```python
if_codas = methods.ifCODAS()
print(f'Preferences: {if_codas(matrix, fuzzy_weights, types)}')
print(f'Ranking: {if_codas.rank()}')
```

--------------------------------

### Define Fuzzy Weights

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Example of defining fuzzy weights for Intuitionistic Fuzzy Sets. Each row represents a criterion, and columns represent membership and non-membership values.

```python
fuzzy_weights = np.array([[0.6, 0.35], [0.8, 0.2], [0.5, 0.45], [0.2, 0.7]])
```

--------------------------------

### IF-WPM Method Implementation

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Demonstrates the application of the IF-WPM method to calculate preferences and rankings. This method, like WSM, relies on adjustable normalization and score parameters.

```python
if_wpm = methods.ifWPM()
print(f'Preferences: {if_wpm(matrix, fuzzy_weights, types)}')
print(f'Ranking: {if_wpm.rank()}')
```

--------------------------------

### IFS Criteria Bar Plot Function

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/graphs/ifs_criteria_bar_plot.html

Use this function to visualize IFS criteria weights. It requires a list of criteria weights and optionally accepts criteria names and a matplotlib Axes object. Ensure matplotlib and numpy are installed.

```python
import matplotlib.pyplot as plt
import numpy as np

def ifs_criteria_bar_plot(criteria_weights, criteria_names=None, ax=None):
    """
    Visualize a list of Intuitionistic Fuzzy Sets (IFS) as stacked bars.

    Parameters:
    - criteria_weights (list): A list of lists, where each inner list represents an IFS (membership, non-membership, uncertainty).
    - criteria_names (list, optional): A list of names for each criteria. If not provided, default names will be used.
    - ax (Axes or None): Axes object to draw on. If None, then the current axes are used.

    Returns:
        ax

    Example:
    ```
    # Example Usage:
    criteria_weights_example = [[0.6, 0.2, 0.2], [0.8, 0.1, 0.1], [0.5, 0.3, 0.2]]
    criteria_names_example = ['Criterion 1', 'Criterion 2', 'Criterion 3']
    ifs_criteria_bar_plot(criteria_weights_example, criteria_names_example)
    ```

    The stacked bar plot displays the degree of belief for membership, non-membership, and uncertainty of multiple criteria.
    """

    num_criteria = len(criteria_weights)
    num_components = len(criteria_weights[0])

    if criteria_names is None:
        criteria_names = [f'$C_{{{i + 1}}}$' for i in range(num_criteria)]

    if ax is None:
        ax = plt.gca()

    # colors
    colors = ['dodgerblue', 'red', 'gray']

    # Create stacked bar plot
    bottom_values = np.zeros(num_components)
    for i in range(num_criteria):
        values = np.array(criteria_weights[i])
        bottom_values = 0
        for idx, val in enumerate(values):
            ax.bar(criteria_names[i], val, bottom=bottom_values, alpha=0.7, color=colors[idx])
            bottom_values += val

    # Add labels and title
    ax.set_ylabel('Degree of Belief')

    # Add legend
    ax.legend(['Membership', 'Non-membership', 'Uncertainty'], bbox_to_anchor=(0, 1.02, 1, 0.2), loc="lower left",
                mode="expand", borderaxespad=0, ncol=3)

    # Add grid
    ax.grid(axis='y', linestyle='--', alpha=0.7)
    ax.set_axisbelow(True)

    # Adjust ylim
    ax.set_ylim([0, 1.05])

    plt.tight_layout()

    return ax

```

--------------------------------

### IF-MAIRCA Method with Default Settings

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Demonstrates the basic usage of the IF-MAIRCA method with default normalization and distance measures. It prints the calculated preferences and the resulting ranking.

```python
if_mairca = methods.ifMAIRCA()
print(f'Preferences: {if_mairca(matrix, fuzzy_weights, types)}')
print(f'Ranking: {if_mairca.rank()}')
```

--------------------------------

### Initialize IF-ARAS with Different Normalizations

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Demonstrates initializing the IF-ARAS method with various normalization techniques available in the library.

```python
aras = {
    'Ecer normalization': methods.ifARAS(normalization=ifs.normalization.ecer_normalization),
    'Minmax normalization': methods.ifARAS(normalization=ifs.normalization.minmax_normalization),
    'Supriya normalization': methods.ifARAS(normalization=ifs.normalization.supriya_normalization),
    'Swap normalization': methods.ifARAS(normalization=ifs.normalization.swap_normalization),
}
```

--------------------------------

### Initialize ifWPM Object

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_wpm.html

Initializes the Intuitionistic Fuzzy WPM method object. Accepts optional normalization and score functions for custom calculations.

```python
def __init__(self, score=chen_score_1, normalization=None):
    """
    Creates Intuitionistic Fuzzy WPM method object with normalization and score functions

    Parameters
    ----------
        score: callable, default=chen_score_1
            Function used to calculate score between two IFS
        
        normalization: callable, default=None
            Function used to normalize the decision matrix

    """

    self.normalization = normalization
    self.score = score
    self.__descending = True
```

--------------------------------

### Define and generate decision matrices

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Shows how to define a real data decision matrix and how to generate a random one using `generate_ifs_matrix` for multi-criteria evaluation.

```python
# real data matrix
matrix = np.array([
    [[0.4745, 0.5255], [0.4752, 0.5248], [0.2981, 0.7019], [0.4374, 0.5627]],
    [[0.5346, 0.4654], [0.5532, 0.4468], [0.6300, 0.3700], [0.5901, 0.4099]],
    [[0.4324, 0.5676], [0.4030, 0.5970], [0.4298, 0.5702], [0.4361, 0.5639]],
    [[0.5235, 0.4765], [0.4808, 0.5192], [0.5667, 0.4333], [0.2913, 0.7087]],
    [[0.4168, 0.5832], [0.4923, 0.5077], [0.4732, 0.5268], [0.4477, 0.5523]]
])

# randomly generated matrix
# 5 alternatives
# 4 criteria
random_matrix = generate_ifs_matrix(5, 4)
print(random_matrix)
```

--------------------------------

### ifWPM Class Initialization

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_wpm.html

Initializes the Intuitionistic Fuzzy WPM method object with optional score and normalization functions.

```APIDOC
## ifWPM(score=chen_score_1, normalization=None)

### Description
Creates an Intuitionistic Fuzzy WPM method object with specified normalization and score functions.

### Parameters
#### Parameters
- **score** (callable, optional) - Defaults to `chen_score_1`. The function used to calculate the score between two Intuitionistic Fuzzy Sets (IFS).
- **normalization** (callable, optional) - Defaults to `None`. The function used to normalize the decision matrix.
```

--------------------------------

### Initialize and Use IF-COPRAS

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Initializes the IF-COPRAS method with default settings and prints the preferences and ranking. Assumes matrix, fuzzy_weights, and types are pre-defined.

```python
if_copras = methods.ifCOPRAS()
print(f'Preferences: {if_copras(matrix, fuzzy_weights, types)}')
print(f'Ranking: {if_copras.rank()}')
```

--------------------------------

### Initialize Intuitionistic Fuzzy COPRAS Method

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_copras.html

Create an Intuitionistic Fuzzy COPRAS method object. Specify custom functions for calculating crisp scores and normalizing the decision matrix if needed.

```python
from .copras.ifs import ifs
from .ifs.score import thakur_score
from ..helpers import rank

from .validator import Validator




[docs]
class ifCOPRAS():


[docs]
    def __init__(self, score=thakur_score, normalization=None):
        """
        Create Intuitionistic Fuzzy COPRAS method object with normalization and score functions

        Parameters
        ----------
            score: callable, default=thakur_score
                Function used to calculate crisp score of IFS
            
            normalization: callable, default=None
                Function used to calculate normalized decision matrix

        """

        self.score = score
        self.normalization = normalization
        self.__descending = True
```

--------------------------------

### ifWSM Class Initialization

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_wsm.html

Initializes the Intuitionistic Fuzzy WSM method with custom score and normalization functions.

```APIDOC
## ifWSM.__init__

### Description
Creates Intuitionistic Fuzzy WSM method object with normalization and score functions.

### Parameters
#### Parameters
- **score** (callable, optional) - Function used to calculate score between two IFS. Defaults to `chen_score_1`.
- **normalization** (callable, optional) - Function used to normalize the decision matrix. Defaults to `None`.
```

--------------------------------

### IF-VIKOR Method Implementation

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Demonstrates the application of the IF-VIKOR method to a decision matrix, fuzzy weights, and types. It shows how to obtain and print the S, R, and Q preference vectors, as well as their corresponding rankings.

```python
if_vikor = methods.ifVIKOR()
res = if_vikor(matrix, fuzzy_weights, types)
print('PREFERENCES')
print(f'S: {res[0]}')
print(f'R: {res[1]}')
print(f'Q: {res[2]}')

ranks = if_vikor.rank()
print('RANKINGS')
print(f'S: {ranks[0]}')
print(f'R: {ranks[1]}')
print(f'Q: {ranks[2]}')
```

--------------------------------

### Initialize ifVIKOR Method

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_vikor.html

Creates an Intuitionistic Fuzzy VIKOR method object. Specify custom distance and normalization functions, and the strategy weight 'v'.

```python
def __init__(self, distance=hamming_distance, normalization=None, v=0.5):
        """
        Creates Intuitionistic Fuzzy VIKOR method object with normalization and distance functions

        Parameters
        ----------
            distance: callable, default=hamming_distance
                Function used to calculate distance between two IFS
            
            normalization: callable, default=None
                Function used to normalize the decision matrix

            v : float, default=0.5
                Weight of the strategy (see VIKOR algorithm explanation).
        """

        self.normalization = normalization
        self.distance = distance
        self.v = v
        self.__descending = False
```

--------------------------------

### Calculate Criteria Weights using Entropy Methods

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Illustrates the use of various entropy-based methods to objectively define criteria weights in multi-criteria problems. Requires the ifs_weights module and a decision matrix.

```python
import ifs_weights
import numpy as np

# Assuming 'matrix' is defined as a numpy array representing the decision matrix
# Example matrix definition (replace with actual data if available):
matrix = np.array([
    [[0.4745, 0.5255], [0.4752, 0.5248], [0.2981, 0.7019], [0.4374, 0.5627]],
    [[0.5346, 0.4654], [0.5532, 0.4468], [0.6300, 0.3700], [0.5901, 0.4099]],
    [[0.4324, 0.5676], [0.4030, 0.5970], [0.4298, 0.5702], [0.4361, 0.5639]],
    [[0.5235, 0.4765], [0.4808, 0.5192], [0.5667, 0.4333], [0.2913, 0.7087]],
    [[0.4168, 0.5832], [0.4923, 0.5077], [0.4732, 0.5268], [0.4477, 0.5523]]
])

weights_methods = {
    'Burillo Entropy': ifs_weights.burillo_entropy_weights,
    'Equal': ifs_weights.equal_weights,
    'Entropy': ifs_weights.entropy_weights,
    'Liu Entropy': ifs_weights.liu_entropy_weights,
    'Szmidt Entropy': ifs_weights.szmidt_entropy_weights,
    'Thakur Entropy': ifs_weights.thakur_entropy_weights,
    'Ye Entropy': ifs_weights.ye_entropy_weights,
}

for name, method in weights_methods.items():
    w = method(matrix)
    print(f'{name} 
 {w}
')
```

--------------------------------

### IF-WSM Method Implementation

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Illustrates the use of the IF-WSM method for calculating preferences and rankings. Similar to IF-WPM, it is configurable via normalization and score functions.

```python
if_wsm = methods.ifWSM()
print(f'Preferences: {if_wsm(matrix, fuzzy_weights, types)}')
print(f'Ranking: {if_wsm.rank()}')
```

--------------------------------

### Configure IF-TOPSIS with Custom Distances

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Initializes IF-TOPSIS with various predefined distance functions. This allows for flexibility in how the distance between alternatives and ideal/anti-ideal solutions is calculated.

```python
topsis = {
    'Euclidean' : methods.ifTOPSIS(distance=ifs.distance.euclidean_distance),
    'Grzegorzewski': methods.ifTOPSIS(distance=ifs.distance.grzegorzewski_distance),
    'Hamming': methods.ifTOPSIS(distance=ifs.distance.hamming_distance),
    'Luo distance': methods.ifTOPSIS(distance=ifs.distance.luo_distance),
    'Normalized Hamming': methods.ifTOPSIS(distance=ifs.distance.normalized_hamming_distance),
    'Normalized Euclidean': methods.ifTOPSIS(distance=ifs.distance.normalized_euclidean_distance),
    'Wang Xin 1': methods.ifTOPSIS(distance=ifs.distance.wang_xin_distance_1),
    'Wang Xin 2': methods.ifTOPSIS(distance=ifs.distance.wang_xin_distance_2),
    'Yang Chiclana': methods.ifTOPSIS(distance=ifs.distance.yang_chiclana_distance),
}
```

--------------------------------

### Initialize ifMAIRCA Method

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_mairca.html

Create an Intuitionistic Fuzzy MAIRCA method object. Allows customization of normalization, distance, and score functions.

```python
from .mairca.ifs import ifs
from .ifs.normalization import minmax_normalization
from .ifs.distance import normalized_euclidean_distance
from .ifs.score import liu_wang_score
from ..helpers import rank

from .validator import Validator




class ifMAIRCA():


    def __init__(self, normalization=minmax_normalization, distance=normalized_euclidean_distance, score=liu_wang_score):
        """
        Create Intuitionistic Fuzzy MAIRCA method object with normalization and distance functions

        Parameters
        ----------
            normalization: callable, default=minmax_normalization
                Function used to normalize the decision matrix

            distance: callable, default=normalized_euclidean_distance
                Function used to calculate distance between two IFS

            score: callable, default=liu_wang_score
                Function used to calculate crisp score of IFS

        """

        self.normalization = normalization
        self.distance = distance
        self.score = score
        self.__descending = True
```

--------------------------------

### IF-MAIRCA Method with Custom Distances

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Shows how to instantiate the IF-MAIRCA method with various custom distance measures. This allows for exploring the impact of different distance calculations on the results.

```python
mairca = {
    'Euclidean' : methods.ifMAIRCA(distance=ifs.distance.euclidean_distance),
    'Grzegorzewski': methods.ifMAIRCA(distance=ifs.distance.grzegorzewski_distance),
    'Hamming': methods.ifMAIRCA(distance=ifs.distance.hamming_distance),
    'Luo distance': methods.ifMAIRCA(distance=ifs.distance.luo_distance),
    'Normalized Euclidean': methods.ifMAIRCA(distance=ifs.distance.normalized_euclidean_distance),
    'Normalized Hamming': methods.ifMAIRCA(distance=ifs.distance.normalized_hamming_distance),
    'Wang Xin 1': methods.ifMAIRCA(distance=ifs.distance.wang_xin_distance_1),
    'Wang Xin 2': methods.ifMAIRCA(distance=ifs.distance.wang_xin_distance_2),
    'Yang Chiclana': methods.ifMAIRCA(distance=ifs.distance.yang_chiclana_distance),
}
```

--------------------------------

### Helpers

Source: https://pyifdm.readthedocs.io/en/latest/modules.html

Utility functions for generating matrices and ranking data.

```APIDOC
## generate_ifs_matrix()
### Description
Generates an intuitionistic fuzzy set matrix.
### Method
N/A
### Endpoint
N/A
```

```APIDOC
## rank()
### Description
Ranks a given set of values.
### Method
N/A
### Endpoint
N/A
```

--------------------------------

### ifCODAS Class Initialization

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_codas.html

Initializes the Intuitionistic Fuzzy CODAS method with specified normalization functions, distance metrics, and a threshold parameter.

```APIDOC
## ifCODAS(normalization=swap_normalization, distance_1=euclidean_distance, distance_2=hamming_distance, tau=0.05)

### Description
Create Intuitionistic Fuzzy CODAS method object with normalization function and distances metrics.

### Parameters
#### Path Parameters
- **normalization** (callable) - Optional - Function used to calculate normalized decision matrix
- **distance_1** (callable) - Optional - Function used to calculate distance between two IFS
- **distance_2** (callable) - Optional - Function used to calculate distance between two IFS
- **tau** (float) - Optional - Threshold parameter
```

--------------------------------

### Initialize ifCODAS Method

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_codas.html

Create an Intuitionistic Fuzzy CODAS method object. Specify normalization functions, distance metrics, and the threshold parameter.

```python
class ifCODAS():
    def __init__(self, normalization=swap_normalization, distance_1=euclidean_distance, distance_2=hamming_distance, tau=0.05):
        """
        Create Intuitionistic Fuzzy CODAS method object with normalization function and distances metrics

        Parameters
        ----------
            normalization: callable, default=swap_normalization
                Function used to calculate normalized decision matrix

            distance_1: callable, default=euclidean_distance
                Function used to calculate distance between two IFS

            distance_2: callable, default=hamming_distance
                Function used to calculate distance between two IFS

            tau: float, default=0.05
                Threshold parameter

        """

        self.normalization = normalization
        self.distance_1 = distance_1
        self.distance_2 = distance_2
        self.tau = tau
        self.__descending = True
```

--------------------------------

### IF-VIKOR Distance Method Variations

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Illustrates how to instantiate the IF-VIKOR method with different distance metrics. This allows for flexibility in how the similarity or difference between fuzzy sets is calculated.

```python
vikor = {
    'Euclidean' : methods.ifVIKOR(distance=ifs.distance.euclidean_distance),
    'Grzegorzewski': methods.ifVIKOR(distance=ifs.distance.grzegorzewski_distance),
    'Hamming': methods.ifVIKOR(distance=ifs.distance.hamming_distance),
    'Luo distance': methods.ifVIKOR(distance=ifs.distance.luo_distance),
    'Normalized Euclidean': methods.ifVIKOR(distance=ifs.distance.normalized_euclidean_distance),
    'Normalized Hamming': methods.ifVIKOR(distance=ifs.distance.normalized_hamming_distance),
    'Wang Xin 1': methods.ifVIKOR(distance=ifs.distance.wang_xin_distance_1),
    'Wang Xin 2': methods.ifVIKOR(distance=ifs.distance.wang_xin_distance_2),
    'Yang Chiclana': methods.ifVIKOR(distance=ifs.distance.yang_chiclana_distance),
}
```

--------------------------------

### Initialize ifMABAC Object

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_mabac.html

Create an Intuitionistic Fuzzy MAIRCA method object with customizable normalization, distance, and score functions. Parameters `p` and `g` adjust distance calculation.

```python
from .mabac.ifs import ifs
from .ifs.normalization import swap_normalization
from .ifs.score import liu_wang_score
from .ifs.distance import luo_distance
from ..helpers import rank

from .validator import Validator




class ifMABAC():


    def __init__(self, normalization=swap_normalization, distance=luo_distance, score=liu_wang_score, p=2.25, g=0.88):
        """
        Create Intuitionistic Fuzzy MAIRCA method object with normalization and score functions

        Parameters
        ----------
            normalization: callable, default=swap_normalization
                Function used to normalize the decision matrix

            distance: callable, default=lou_distance
                Function used to calculate distance between two IFS

            score: callable, default=liu_wang_score
                Function used to calculate crisp score of IFS

            p: float, default=2.25
                Adjust parameter for distance calculation

            g: float, default=0.88
                Adjust parameter for distance calculation
        """

        self.normalization = normalization
        self.distance = distance
        self.score = score
        self.p = p
        self.g = g
        self.__descending = True

```

--------------------------------

### Initialize IFS Object

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/IFS/ifs.html

Instantiates an IFS object with membership, non-membership, and optional uncertainty values. Uncertainty is calculated if not provided.

```python
ifs1 = IFS(0.6, 0.2)
ifs2 = IFS(0.8, 0.1)
```

--------------------------------

### Calculate Alternative Preferences

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_wpm.html

Calculates the preferences for alternatives using the Intuitionistic Fuzzy WPM method. Requires a decision matrix, weights, and criteria types. Data is validated before calculation.

```python
def __call__(self, matrix, weights, types):
    """
    Calculates the alternatives preferences

    Parameters
    ----------
        matrix : ndarray
            Decision matrix / alternatives data.
            Alternatives are in rows and Criteria are in columns.

        weights : ndarray
            Vector of criteria weights in a crisp or Intuitionistic Fuzzy form

        types : ndarray
            Types of criteria, 1 profit, -1 cost.
            Criteria types cannot be all profit or all cost.

    Returns
    ----------
        ndarray:
            Preference calculated for alternatives. Greater values are placed higher in ranking
    """
    # validate data
    Validator.ifs_validation(matrix, weights, types)

    self.preferences = ifs(matrix, weights, types, self.normalization, self.score).astype(float)
    return self.preferences
```

--------------------------------

### Initialize Intuitionistic Fuzzy WSM Method

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_wsm.html

Initializes the Intuitionistic Fuzzy WSM method with custom score and normalization functions. The score function is used to calculate the score between two Intuitionistic Fuzzy Sets (IFS), and the normalization function is used to normalize the decision matrix.

```python
from .wsm.ifs import ifs
from .ifs.score import chen_score_1
from ..helpers import rank

from .validator import Validator



[docs]
class ifWSM():


[docs]
    def __init__(self, score=chen_score_1, normalization=None):
        """
        Creates Intuitionistic Fuzzy WSM method object with normalization and score functions

        Parameters
        ----------
            score: callable, default=chen_score_1
                Function used to calculate score between two IFS
            
            normalization: callable, default=None
                Function used to normalize the decision matrix

        """

        self.normalization = normalization
        self.score = score
        self.__descending = True
```

--------------------------------

### ifCOPRAS Initialization

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_copras.html

Initializes the Intuitionistic Fuzzy COPRAS method with optional score and normalization functions.

```APIDOC
## ifCOPRAS()

### Description
Create Intuitionistic Fuzzy COPRAS method object with normalization and score functions.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **score** (callable, optional) - Function used to calculate crisp score of IFS. Defaults to `thakur_score`.
- **normalization** (callable, optional) - Function used to calculate normalized decision matrix. Defaults to `None`.
```

--------------------------------

### pyifdm.IFS.ifs.IFS methods

Source: https://pyifdm.readthedocs.io/en/latest/genindex.html

Documentation for the special methods available in the IFS class.

```APIDOC
## __add__()

### Description
Represents the addition operation for IFS objects.

### Method
`__add__()`

### Parameters
None explicitly documented.

### Response
Returns an IFS object representing the result of the addition.
```

```APIDOC
## __and__()

### Description
Represents the AND operation for IFS objects.

### Method
`__and__()`

### Parameters
None explicitly documented.

### Response
Returns an IFS object representing the result of the AND operation.
```

```APIDOC
## __call__()

### Description
Allows the IFS object to be called as a function.

### Method
`__call__()`

### Parameters
None explicitly documented.

### Response
Returns a result based on the IFS object's internal state.
```

```APIDOC
## __eq__()

### Description
Represents the equality comparison for IFS objects.

### Method
`__eq__()`

### Parameters
None explicitly documented.

### Response
Returns a boolean indicating if two IFS objects are equal.
```

```APIDOC
## __init__()

### Description
Initializes an IFS object.

### Method
`__init__()`

### Parameters
None explicitly documented.

### Response
Creates and returns a new IFS object.
```

```APIDOC
## __invert__()

### Description
Represents the inversion operation for IFS objects.

### Method
`__invert__()`

### Parameters
None explicitly documented.

### Response
Returns an IFS object representing the inverted IFS.
```

```APIDOC
## __mul__()

### Description
Represents the multiplication operation for IFS objects.

### Method
`__mul__()`

### Parameters
None explicitly documented.

### Response
Returns an IFS object representing the result of the multiplication.
```

```APIDOC
## __or__()

### Description
Represents the OR operation for IFS objects.

### Method
`__or__()`

### Parameters
None explicitly documented.

### Response
Returns an IFS object representing the result of the OR operation.
```

```APIDOC
## __pow__()

### Description
Represents the power operation for IFS objects.

### Method
`__pow__()`

### Parameters
None explicitly documented.

### Response
Returns an IFS object representing the result of the power operation.
```

```APIDOC
## __repr__()

### Description
Returns a string representation of the IFS object.

### Method
`__repr__()`

### Parameters
None explicitly documented.

### Response
Returns a string that can be used to recreate the object.
```

```APIDOC
## __str__()

### Description
Returns a user-friendly string representation of the IFS object.

### Method
`__str__()`

### Parameters
None explicitly documented.

### Response
Returns a string representing the IFS object.
```

```APIDOC
## __sub__()

### Description
Represents the subtraction operation for IFS objects.

### Method
`__sub__()`

### Parameters
None explicitly documented.

### Response
Returns an IFS object representing the result of the subtraction.
```

```APIDOC
## __truediv__()

### Description
Represents the true division operation for IFS objects.

### Method
`__truediv__()`

### Parameters
None explicitly documented.

### Response
Returns an IFS object representing the result of the true division.
```

```APIDOC
## dominance()

### Description
Calculates the dominance relationship for IFS objects.

### Method
`dominance()`

### Parameters
None explicitly documented.

### Response
Returns a representation of the dominance relationship.
```

```APIDOC
## fuzzy_relation()

### Description
Calculates the fuzzy relation for IFS objects.

### Method
`fuzzy_relation()`

### Parameters
None explicitly documented.

### Response
Returns the fuzzy relation.
```

--------------------------------

### Initialize ifWASPAS Method

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_waspas.html

Creates an Intuitionistic Fuzzy WASPAS method object. Allows customization of score and normalization functions, and the decision precision coefficient.

```python
ifWASPAS(score=chen_score_1, normalization=None, v=0.5)
```

--------------------------------

### Rank Alternatives based on Preferences

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_codas.html

Calculate the ranking of alternatives based on the previously obtained preferences. Raises an error if preferences have not been calculated yet.

```python
def rank(self):
        """
            Calculates the alternatives ranking based on the obtained preferences

            Returns
            ----------
                ndarray:
                    Ranking of alternatives
        """
        try:
            return rank(self.preferences, self.__descending)
        except AttributeError:
            raise AttributeError('Cannot calculate ranking before assessment')
        except:
            raise ValueError('Error occurred in ranking calculation')
```

--------------------------------

### Intuitionistic Fuzzy Set Operations and Metrics

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Demonstrates basic mathematical operations (addition, subtraction, multiplication, division, power, intersection, union, complement) and advanced metrics (OWA aggregation, dominance, Jaccard similarity, fuzzy relation) for Intuitionistic Fuzzy Sets (IFS). Requires the IFS class to be imported.

```python
from PyIFDM.intuitionistic_fuzzy_sets import IFS

ifs1 = IFS(0.6, 0.2)
ifs2 = IFS(0.8, 0.1)

# Addition
addition_result = ifs1 + ifs2
print("Addition result:", addition_result)

# Subtraction
subtraction_result = ifs1 - ifs2
print("Subtraction result:", subtraction_result)

# Multiplication
multiplication_result = ifs1 * ifs2
print("Multiplication result:", multiplication_result)

# Division
division_result = ifs1 / ifs2
print("Division result:", division_result)

# Power
power_result = ifs1 ** 2
print("Power result:", power_result)

# Intersection
intersection_result = ifs1 & ifs2
print("Intersection result:", intersection_result)

# Union
union_result = ifs1 | ifs2
print("Union result:", union_result)

# Complement
complement_result = ~ifs1
print("Complement result:", complement_result)

# Ordered Weighted Averaging (OWA) Aggregation
o wa_weights = [0.3, 0.4, 0.3]
o wa_result = ifs1.owa_aggregation(owa_weights)
print("OWA Aggregation result:", owa_result)

# Dominance
is_dominating = ifs1.dominance(ifs2)
print("Is Dominating:", is_dominating)

# Jaccard Similarity
jaccard_similarity = ifs1.similarity_jaccard(ifs2)
print("Jaccard Similarity:", jaccard_similarity)

# Fuzzy Relation

fuzzy_relation_matrix = ifs1.fuzzy_relation(ifs2)
print("Fuzzy Relation Matrix:")
print(fuzzy_relation_matrix)

```

--------------------------------

### Initialize ifMARCOS Object

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_marcos.html

Creates an object for the Intuitionistic Fuzzy MARCOS method. The `__descending` attribute is initialized to True, indicating that higher preference values will be ranked higher.

```python
class ifMARCOS():

    def __init__(self):
        """
        Create Intuitionistic Fuzzy MARCOS method object

        """

        self.__descending = True
```

--------------------------------

### Initialize ifOCRA Method

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_ocra.html

Create an Intuitionistic Fuzzy OCRA method object. Accepts a callable score function for calculating the crisp score of Intuitionistic Fuzzy Sets (IFS).

```python
from .ocra.ifs import ifs
from .ifs.score import chen_score_1
from ..helpers import rank

from .validator import Validator



[docs]
class ifOCRA():


[docs]
    def __init__(self, score=chen_score_1):
        """
        Create Intuitionistic Fuzzy OCRA method object with normalization and score functions

        Parameters
        ----------
            score: callable, default=chen_score_1
                Function used to calculate crisp score of IFS

        """

        self.score = score
        self.__descending = True
```

--------------------------------

### Apply various normalization methods to a decision matrix

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Demonstrates the application of different normalization techniques (Ecer, Max, Min-Max, Supriya, Swap) to a decision matrix. The `types` array specifies whether higher or lower values are preferred for each criterion.

```python
normalizations = {
    'Ecer normalization': ifs.normalization.ecer_normalization,
    'Max normalization': ifs.normalization.max_normalization,
    'Min-Max normalization': ifs.normalization.minmax_normalization,
    'Supriya normalization': ifs.normalization.supriya_normalization,
    'Swap normalization': ifs.normalization.swap_normalization,
}

types = np.array([1, -1, 1, -1])

for name, norm in normalizations.items():
    nmatrix = norm(matrix, types)
    print(f'{name}\n\n {nmatrix[:2]}\n')
```

--------------------------------

### Initialize ifMOORA Object

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_moora.html

Create an Intuitionistic Fuzzy MOORA method object. Specify custom score and normalization functions if needed. The default score function is zhang_xu_score_2.

```python
ifMOORA(score=zhang_xu_score_2, normalization=None)
```

--------------------------------

### Rank Alternatives

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_vikor.html

Calculates the ranking of alternatives based on the previously obtained preferences. Raises an error if preferences have not been calculated yet.

```python
def rank(self):
        """
            Calculates the alternatives ranking based on the obtained preferences

            Returns
            ----------
                ndarray:
                    Ranking of alternatives for the S, R, Q approaches
        """
        try:
            return np.array([rank(pref, self.__descending) for pref in self.preferences])
        except AttributeError:
            raise AttributeError('Cannot calculate ranking before assessment')
        except:
            raise ValueError('Error occurred in ranking calculation')
```

--------------------------------

### Calculate Alternatives Preferences with ifCODAS

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_codas.html

Calculate the preference values for alternatives using the Intuitionistic Fuzzy CODAS method. Requires a decision matrix, criteria weights, and criteria types. Data validation is performed before calculation.

```python
def __call__(self, matrix, weights, types):
        """
        Calculates the alternatives preferences

        Parameters
        ----------
            matrix : ndarray
                Decision matrix / alternatives data.
                Alternatives are in rows and Criteria are in columns.

            weights : ndarray
                Vector of criteria weights in a crisp or Intuitionistic Fuzzy form

            types : ndarray
                Types of criteria, 1 profit, -1 cost.
                Criteria types cannot be all profit or all cost.
                
        Returns
        ----------
            ndarray:
                Preference calculated for alternatives. Greater values are placed higher in ranking
        """
        # validate data
        Validator.ifs_validation(matrix, weights, types, mixed_types=True)

        self.preferences = ifs(matrix, weights, types, self.normalization, self.distance_1, self.distance_2, self.tau).astype(float)
        return self.preferences
```

--------------------------------

### IFS Initialization

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/IFS/ifs.html

Initializes an Intuitionistic Fuzzy Set (IFS) with membership and non-membership degrees. Uncertainty is automatically computed if not explicitly given.

```python
def __init__(self, membership, non_membership, uncertainty=None):
    self.membership = membership
    self.non_membership = non_membership
    if uncertainty is not None:
        self.uncertainty = uncertainty
    else:
        self.uncertainty = 1 - membership - non_membership
```

--------------------------------

### Using IF-EDAS Method

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Instantiates the IF-EDAS method and prints the calculated preferences and ranking. This is the default usage without custom parameters.

```python
if_edas = methods.ifEDAS()
print(f'Preferences: {if_edas(matrix, fuzzy_weights, types)}')
print(f'Ranking: {if_edas.rank()}')
```

--------------------------------

### Calculate Alternative Preferences

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_marcos.html

Calculates the preferences for alternatives using the Intuitionistic Fuzzy MARCOS method. It requires a decision matrix, criteria weights, and criteria types. The method validates the input data before performing the calculation.

```python
def __call__(self, matrix, weights, types):
        """
        Calculates the alternatives preferences

        Parameters
        ----------
            matrix : ndarray
                Decision matrix / alternatives data.
                Alternatives are in rows and Criteria are in columns.

            weights : ndarray
                Vector of criteria weights in a crisp or Intuitionistic Fuzzy form

            types : ndarray
                Types of criteria, 1 profit, -1 cost

        Returns
        ----------
            ndarray:
                Preference calculated for alternatives. Greater values are placed higher in ranking
        """
        # validate data
        Validator.ifs_validation(matrix, weights, types, mixed_types=True)

        self.preferences = ifs(matrix, weights, types).astype(float)
        return self.preferences
```

--------------------------------

### Initialize ifEDAS Method

Source: https://pyifdm.readthedocs.io/en/latest/_modules/pyifdm/methods/if_edas.html

Creates an Intuitionistic Fuzzy EDAS method object. Accepts custom normalization and scoring functions.

```python
class ifEDAS():
    def __init__(self, normalization=swap_normalization, score=liu_wang_score):
        """
        Create Intuitionistic Fuzzy EDAS method object with normalization function

        Parameters
        ----------
            normalization: callable, default=swap_normalization
                Function used to calculate normalized decision matrix

            score: callable, default=liu_wang_score
                Function used to calculate crisp score of IFS

        """

        self.normalization = normalization
        self.score = score
        self.__descending = True
```

--------------------------------

### Displaying IF-VIKOR Results with Tabulate

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Presents the preference results from multiple IF-VIKOR method variations in a formatted table using the 'tabulate' library. This aids in comparing the outcomes of different distance metrics.

```python
print(tabulate([[name, *np.round(pref[0], 2)] for name, pref in results.items()],
    headers=['Method'] + [f'A{i+1}' for i in range(matrix.shape[0])]))
```

--------------------------------

### IF-WASPAS Method Implementation

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Shows the usage of the IF-WASPAS method, including obtaining the preference vector and its corresponding ranking. The WASPAS method uses normalization and score functions, with default settings for both.

```python
if_waspas = methods.ifWASPAS()
print(f'Preferences: {if_waspas(matrix, fuzzy_weights, types)}')
print(f'Ranking: {if_waspas.rank()}')
```

--------------------------------

### Calculate Similarity Measures for Intuitionistic Fuzzy Sets

Source: https://pyifdm.readthedocs.io/en/latest/example/examples.html

Shows how to apply different similarity measures to compare two Intuitionistic Fuzzy Sets (IFS). Requires numpy and the ifs.similarity module.

```python
import numpy as np
import ifs.similarity

similarity_measures = {
    'Chen similarity': ifs.similarity.chen_similarity,
    'Fan-Zhang similarity': ifs.similarity.fan_zhang_similarity,
    'Hong-Kim similarity': ifs.similarity.hong_kim_similarity,
    'Li similarity': ifs.similarity.li_similarity,
    'Li-Xu similarity': ifs.similarity.li_xu_similarity,
    'Ye similarity': ifs.similarity.ye_similarity,
}

x = np.array([0.8, 0.15])
y = np.array([0.7, 0.28])

for name, similarity in similarity_measures.items():
    d = similarity(x, y)
    print(f'{name}: {d}')
```
Tokens:
Raw