# Tomasz Kuczyński Raport - mcda

### Opis podprojektu
Podprojekt ma za zadanie wybrać określoną liczbę najlepszych produktów z dostawy.
Wykorzystuj on zmodyfikowaną motodę MCDA - Multiple Criteria Decision Analysis.

#### Uczenie modelu
Zbiór uczenia składa się z zdefiniowania wartości atrybutów:

```javascript
color = {'black': 16, 'gold': 10, 'purple': 5, 'brown': 7, 'blue': 12, 'white': 14, 'red': 13, 'orange': 11}  
shape = {'rectangle': 15, 'pack': 19, 'square': 9, 'jar': 7}  
size = {'small': 7, 'medium': 16, 'big': 13}
```
oraz ich wyliczenia:
```javascript
def sizeValue(X):  
  if X.size == 'small':  
        return X.mass/5  
  if X.size == 'medium':  
        return X.mass/10  
  if X.size == 'big':  
        return X.mass/20
```

Składa się róznierz z parametrów:

`weights` - waga danego parametru

`q` - współczynik pomyłki (granicy błędu) pomiędzy atrybutami

`p` - maksymalna dopuszczalna różnica pomiędy atrybutami 

```javascript
parameters = {  
  'color': {'weights': 3, 'q': 1, 'p': 5},  
  'shape': {'weights': 4, 'q': 1, 'p': 6},  
  'mass': {'weights': 0.5, 'q': 2, 'p': 10},  
  'size': {'weights': 1, 'q': 1, 'p': 8}
}
```

#### Opis kodu w wspólnym projekcie
W wspólnym projekcie w pliku main.py wywołuje funkcję wybierania 5 produktów z dostawy:

```javascript
produsctsFromSupply = choseProducts(5)
```

próbna dostawa jest zapisana w pliku supply.py:

```javascript
def create_data_products():  
    allProducts = []  
  
    product = Product('black', 'rectangle', 51, 'small')  
    allProducts.append(product)  
    product = Product('black', 'rectangle', 51, 'small')  
    allProducts.append(product)  
    product = Product('gold', 'pack', 100, 'big')  
    allProducts.append(product)
    ...
    return allProducts

```

Cały algorytm selekcji produktów znajduje się w pliku mcda.py.

Funkcja `getConcordance(gA, gB, q, p):` ma za zadanie wyliczyć `Concordance` czyli jakość produktu A względem produktu B,  za pomocą wartości atrybutów A, B odpowiednio gA, gB oraz parametrów tego atrybutu q, p i zwrócić liczbę z zakresu [0,1].

```javascript
def getConcordance(gA, gB, q, p):  
  if gB <= gA + q:  
        return 1  
  if gB <= gA + p:  
        return (p - gB + gA) / (p - q)  
    return 0
```

Funkcja `getAllTypeConcordance(A, B)`  ma za zadanie wyliczyć wszystkie typy `Concordance`  oraz wyliczyć ich średnią ważoną:

```javascript
def getAllTypeConcordance(A, B):  
    concordance = 0.0  
    weight_sum = 0  
  
    parameter = parameters['color']  
    w, q, p = parameter['weights'], parameter['q'], parameter['p']  
    concordance += getConcordance(color[A.color], color[B.color], q, p) * w  
    weight_sum += w  
  
    parameter = parameters['shape']  
    w, q, p = parameter['weights'], parameter['q'], parameter['p']  
    concordance += getConcordance(shape[A.shape], shape[B.shape], q, p) * w  
    weight_sum += w
    ...
    concordance /= weight_sum  
    return concordance
```

Funkcja `getConcordanceAllProducts()` ma za zadanie przy pomocy funkcji `getAllTypeConcordance(A, B)` wyliczyć  `Concordance` dla wszystkich produktów i zwrócić wynik w postaci listy:

```javascript
def getConcordanceAllProducts():  
    C = []  
    
    for i in range(len(allProducts)):  
        c = 0  
        for j in range(len(allProducts)):  
            if j==i:  
                continue  
            else:  
                c += getAllTypeConcordance(allProducts[i], allProducts[j])  
        c /= len(allProducts)-1  
        C.append(c)  
    return C
```

Funkcja `choseProducts(number)` ma za zadanie wybrać `number` produktów z dostawy na podstawie listy  `Concordance` zwróconej przez funkcję `getConcordanceAllProducts()`.

```javascript
def choseProducts(number):  
    C = getConcordanceAllProducts()  
    products = []  
    prev = -1  
    if number > len(allProducts):  
        return allProducts  
    while number > 0:  
        max = -1  
        if prev == -1:  
            max = 0  
        for j in range(len(allProducts)):  
            if prev == -1:  
                if C[max]<C[j]:  
                    max = j  
            elif max == -1:  
                if C[prev]>C[j]:  
                    max = j  
            elif C[max] < C[j] and C[j] < C[prev]:  
                max = j  
        prev = max  
        for j in range(len(allProducts)):  
            if C[max] == C[j]:  
                products.append(allProducts[j])  
                print(C[j])  
                number -= 1  
            if number == 0:  
                break  
    print(C)  
    return products
```

`print(C[j])` oraz `print(C)` służy do sprawdzenia poprawności algorytmu.

### Uruchomienie algorytmu i jego działanie
Film przedstawiający uruchomienie aplikacji:
https://www.youtube.com/watch?v=DmwDlJkjtjs

Parametry pojawiające się w terminalu:

1.Concordance `number` najlepszych produktów (`print(C[j])`).

2.Lista wszystkich Concordance ( `print(C)`).