semvec/pypi-packages huggingface dataset:
networking-bigswitch 15.0.2
Arista Networks CCF Plugin for OpenStack Networking

Welcome!
========

This library contains the components required to integrate an
OpenStack deployment with an Arista Networks Converged Cloud Fabric.

* Source: https://opendev.org/x/networking-bigswitch
* Bugs: https://bugs.launchpad.net/networking-bigswitch


External Resources:
===================

Arista Networks Website: http://www.arista.com
rengine 0.1.5
Most used methods for recommendation engine
Requires Python: >=3
Keywords: algorithm,recommendation,engine

## About this package

Collaborative Filtering is a method that is often used as a recommendation engine. Many industries have used this algorithm to recommend their products, this library can use cosine similarity or even centered cosine similarity.

### Depedencies
* Python >= 3
* numpy

### How to use
* cos_similarity(var1, var2, centered)

### Parameters
**var1** : iterable, array, np.array

> The single arrray value you want to compare

**var2** : iterable, array, np.array

> The multi arrray values, you can convert from dataframe or table on your database

**centered** : bool

> By default it will give true, if true you will use centered cosine similarity
### Example case
* We'll try to figuring out this single matrix value, on the multi array
> [4,  0,  0,  5,  1,  0,  0]
* The example dataset that we had
> [[5,  5,  4,  0,  0,  0,  0],  
    [0,  0,  0,  2,  4,  5,  0],  
    [0,  3,  0,  0,  0,  0,  3]]
### Example of code
```
from rengine.method import CollaborativeFiltering
import numpy as np
clf =  CollaborativeFiltering()
print(clf.cos_similarity(np.array([5,  4,  0,  0]),  [[1,  0,  3,  2],  [2,  1,  1,  0],  [4,  5,  0,  1]]))
```

## Example of output
```
[-0.5, 0.866, -0.24] #row 2 in multi array data has more similarity
```

## Another of output
```
[0.092, -0.559, nan] #nan means there's a number divided by zero
```
dssystem 0.1.5
The basic concept SAW method is to find the sum of the weighted performance rating for each alternative on all attributes. SAW method requires a process of normalizing the decision matrix (X) to a scale that can be compared with all the ratings of existing alternatives.
Requires Python: >=3
Keywords: algorithm,dss,decision

## About this package

The basic concept **SAW method** is to find the sum of the weighted performance rating for each alternative on all attributes. **SAW** method requires a **process** of normalizing the decision matrix (X) to a scale that can be compared with all the ratings of existing alternatives.

### Depedencies
* Python >= 3
* numpy
* pandas

### Function

**init (data,weights, non_beneficial = None)** 

> Initializer provides 2 required parameters and 1 optional parameter, data is the dataset with DataFrame format, weights is the values that provided to get a optimal alternative, non_beneficial is the column that has type "cost", not benefit.

**getDecisionMatrix** 

> Function that return formatted matrix from dataset

**normalize** 

> Function that return normalized matrix from decision matrix

**createDecision** 

> Function that return the list of alternative's score

**getChosenOneByIndex** 

> Function that return the chosen one from the alternatives


### Example case
We will simulate "Selection of land - Water resources management" which has 4 criteria(s) : Rainfall, Drainage, Usage of land, Tophography. Usage of land is the only one non beneficial criteria.
* In this case we'll use the weight values like this : 
> [0.25, 0.25, 0.25, 0.25]
* The example dataset that we had
> [[25,  67,  7,  20],  
    [21,  78,  6,  24],  
    [19,  53,  5,  33],
    [22,  25,  2,  31]]
### Example of code
```
from dssystem.method import SimpleAdditiveWeighted
import numpy as np
import pandas as pd
dataset = pd.DataFrame({"Rainfall" : [25, 21, 19, 22],
						"Drainage" : [67, 78, 53, 25],
						"Usage of land" : [7, 6, 5, 2],
						"Tophography" : [20, 24, 33, 31]}, 
						index=["L1","L2","L3","L4"])
						
method = SimpleAdditiveWeighted(dataset, [.25, .25 , .25, .25], ["Usage of land"])
print(method.getChosenOneByIndex()) #to get chosen alternative name
print(method.getDecisionMatrix()) #to get decision matrix
print(method.normalize()) #to get normalized decision matrix
print(method.createDecision()) #to get list of alternative's score
```

## Example of output
```
L4 #L4 is the chosen one

#output of the decision matrix
[[25 67  7 20]
 [21 78  6 24]
 [19 53  5 33]
 [22 25  2 31]]

#output of normalized decision matrix
[[1.   0.86 0.29 0.61]
 [0.84 1.   0.33 0.73]
 [0.76 0.68 0.4  1.  ]
 [0.88 0.32 1.   0.94]]

#output of list of alternative's score
[0.69 0.72 0.71 0.79]
```