semvec/pypi-packages huggingface dataset:
Topsis-Soumya-102203802 1.0.2
A Python package for implementing the TOPSIS algorithm.
Requires Python: >=3.6


# Topsis-Soumya-102203802

## Overview

**Topsis-Soumya-102203802** is a Python package that implements the **TOPSIS** (Technique for Order of Preference by Similarity to Ideal Solution) method for multi-criteria decision-making. It is designed to help users rank alternatives based on their proximity to an ideal best and worst solution.

This package is built to assist decision-makers in evaluating multiple alternatives using several criteria, offering a simple interface for performing the TOPSIS analysis with flexibility for custom weights and impacts for decision criteria.


## Installation

You can install **Topsis-Soumya-102203802** from PyPI using `pip`:

```bash
pip install Topsis-Soumya-102203802
```

Additionally, make sure you have the required dependencies installed:

```bash
pip install pandas numpy pyexcel
```

## Features

- **TOPSIS Ranking**: Computes the rankings for alternatives based on their similarity to the ideal solution.
- **Custom Weights**: Supports custom weights for each decision criterion.
- **Custom Impacts**: Allows specifying the impact of each criterion (maximize or minimize).
- **CSV/Excel Input**: Accepts input datasets in CSV or Excel format.
- **Output**: The package generates an output CSV or Excel file with two additional columns: **Topsis Score** and **Rank**.
- **Command-Line and Programmatic Usage**: Available both as a command-line tool and as a Python package for use in scripts.

## Usage
## Command Line Interface
```bash
topsis.py <InputDataFile> <Weights> <Impacts> <ResultFileName>
```
##Parameters:

**InputDataFile**: Path to input dataset (CSV/XLSX)
**Weights**: Comma-separated criterion weights (e.g., "1,2,3")
**Impacts**: Comma-separated criterion impacts ('+' for maximize, '-' for minimize)
**ResultFileName**: Output file path for results

##Input Data Format
##File Requirements
1. Must contain at least 3 columns
2. First column: Names of alternatives
3. Columns 2 onwards: Numeric values for criteria

##Output Format
#The package generates a CSV file with the original data plus two additional columns:

1. Topsis Score: Calculated similarity to ideal solution
2. Rank: Final ranking of alternatives

##Prerequisites
#Python 3.6 or higher
##Dependencies:
pandas
numpy
pyexcel
##License
MIT License

##Author
Soumya (GitHub Profile)
Topsis-Samkit-102203285 1.0.0
A Python package for performing TOPSIS analysis.
Requires Python: >=3.6

# TOPSIS Python Package

This package implements the TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) method for multi-criteria decision-making.

## Installation

Install the package using pip:

```
pip install Topsis-Samkit-102203285
```

## Usage

Run the following command after importing the package:

```python
from topsis import Topsis

Topsis.calculate('input_file.csv', '1,1,1,2', '+,+,-,+', 'output_file.csv')
```
102203236-Topsis 0.0.1
A Python package for TOPSIS multi-criteria decision making
Requires Python: >=3.6

# 102203236_Topsis

## Overview
**TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)** is a multi-criteria decision-making (MCDM) method used for ranking and selecting alternatives based on multiple criteria. This Python package allows users to easily apply the TOPSIS method to their datasets.

## Features
- Reads data from an Excel file.
- Automatically normalizes the data.
- Applies user-defined weights and impacts to criteria.
- Computes the TOPSIS score and ranks alternatives.
- Outputs the final decision-making table with rankings.

## Installation
Install the package using pip:
```sh
pip install 102203236_Topsis
```

## Usage
### Import the package
```python
from topsis import Topsis
```

### Example
```python
# Importing the package
from topsis import Topsis

# Define the input parameters
filename = "data.xlsx"
impacts = ['+','+','+','-','+']
weights = [0.25, 0.25, 0.25, 0.25, 0.25]

# Run TOPSIS
result = Topsis(filename, impacts, weights).get_result()

# Print the ranked result
print(result)
```

### Expected Input Format
The input Excel file should contain numeric data for decision-making criteria. An example format:
| Fund Name | Criterion 1 | Criterion 2 | Criterion 3 | Criterion 4 | Criterion 5 |
|-----------|------------|------------|------------|------------|------------|
| Fund A    | 250        | 3.5        | 1200       | 8          | 85         |
| Fund B    | 275        | 4.0        | 1150       | 7          | 90         |
| Fund C    | 260        | 3.8        | 1250       | 6          | 88         |

### Output Format
The output DataFrame includes the original data with additional columns:
- **Score**: Computed TOPSIS score.
- **Rank**: Final ranking based on the score.

## Dependencies
This package requires:
- `pandas`
- `numpy`

These dependencies will be automatically installed when using `pip install 102203236_Topsis`.

## License
This project is licensed under the MIT License.

## Contributing
Pull requests are welcome! If you have suggestions or improvements, feel free to submit an issue or PR.

## Author
- Name: Pranav Khurana
- GitHub: https://github.com/PranavKhurana117?tab=repositories
- Email: pranavkhurana117@gmail.com

---
Enjoy using the TOPSIS package! ðŸš€
topsis-102217014 1.0.1
Topsis

# TOPSIS Score Calculation

This project calculates the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) score for a given dataset. TOPSIS is a multi-criteria decision-making method.

## Requirements

- Python 3.x
- pandas
- numpy

Install the required packages using pip:

```bash
pip install pandas numpy
```

## Usage

To run the script, use the following command:

```bash
python3 main.py <input> <weights> <impacts> <output>
```

### Parameters

- `input`: Input CSV file containing the dataset.
- `weights`: String of weights for each criterion, separated by commas.
- `impacts`: String of impacts for each criterion (`+` for beneficial, `-` for non-beneficial), separated by commas.
- `output`: Output CSV file for saving the results.

## Example

```bash
python3 main.py data.csv '2,1,1,1,1' '+,-,+,+,+' out.csv
```

## Input Data Format

The input CSV file should have the following format:

| Criteria1 | Criteria2 | Criteria3 | Criteria4 | Criteria5 |
|-----------|-----------|-----------|-----------|-----------|
| Value1    | Value2    | Value3    | Value4    | Value5    |
| ...       | ...       | ...       | ...       | ...       |

## Output

The output CSV file will contain the original data along with the calculated TOPSIS scores and rankings.
vsbasicvsrpp 3.0.0
BasicVSR++ function for VapourSynth
Requires Python: >=3.10
Keywords: BasicVSR++, PyTorch, VapourSynth

# BasicVSR++
Improving Video Super-Resolution with Enhanced Propagation and Alignment, based on https://github.com/ckkelvinchan/BasicVSR_PlusPlus.


## Dependencies
- [PyTorch](https://pytorch.org/get-started/) 2.5.1 or later
- [VapourSynth](http://www.vapoursynth.com/) R66 or later


## Installation
```
pip install -U vsbasicvsrpp
```

If you want to download all models at once, run `python -m vsbasicvsrpp`. If you prefer to only download the model you
specified at first run, set `auto_download=True` in `basicvsrpp()`.


## Usage
```python
from vsbasicvsrpp import basicvsrpp

ret = basicvsrpp(clip)
```

See `__init__.py` for the description of the parameters.
Topsis-Ruhani-102203833 0.1
TOPSIS algorithm implementation

# Topsis-Ruhani-102203833

This package provides an implementation of the **TOPSIS** (Technique for Order of Preference by Similarity to Ideal Solution) algorithm. TOPSIS is a decision-making method that helps in ranking and selecting the best alternative based on a set of criteria. It evaluates the alternatives based on their relative distance to the ideal and worst-case solutions.

## What is TOPSIS?

**TOPSIS** is a popular method in Multi-Criteria Decision Analysis (MCDA) used for solving decision-making problems. The basic idea is to choose the alternative that is closest to the ideal solution and farthest from the worst solution. This method is widely used in various fields, such as operations research, business, and engineering.

### Steps Involved in TOPSIS:

1. **Construct the Decision Matrix**: Represent the alternatives and criteria in a matrix format.
2. **Normalize the Decision Matrix**: Normalize the data to make the units consistent.
3. **Apply Weights to the Criteria**: Each criterion is assigned a weight based on its importance.
4. **Determine the Ideal and Worst Alternatives**: Identify the best and worst values for each criterion.
5. **Calculate the Distance**: Calculate the Euclidean distance of each alternative from the ideal and worst alternatives.
6. **Calculate the TOPSIS Score**: Compute the score based on the ratio of the distance from the worst and the sum of the distances from both ideal and worst alternatives.
7. **Rank the Alternatives**: Rank the alternatives based on their TOPSIS score.

## Installation

To install the `Topsis-FirstName-RollNumber` package, follow these steps:

### Step 1: Install using pip

You can install the package directly from PyPI using `pip`:

```bash
pip install Topsis-Ruhani-102203833
```

### Step 2: Verify Installation
topsis --version
### Step 2: Usage Example
topsis <InputDataFile> <Weights> <Impacts> <ResultFileName>


This will calculate the TOPSIS score and ranks and save the result in `result.csv`.

## License

MIT License