semvec/pypi-packages huggingface dataset:
Topsis-Sarika-102203880 1.0.1
A Python package for TOPSIS decision making.

# TOPSIS Package
TOPSIS - Sarika-102203880
A Python Package for Multi-Criteria Decision Making using TOPSIS
📖 Introduction
TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) is a multi-criteria decision-making method that ranks alternatives based on their distance from an ideal solution. This package helps in decision analysis by evaluating different alternatives based on weighted criteria and selecting the best option.

⚙ Installation
To install this package from PyPI, run:

sh
Copy code
pip install TOPSIS - Sarika-102203880


📌 Usage Guide
Once installed, you can use the package in Python as follows:

1️⃣ Import the Package
python
Copy code
from Topsis.topsis import Topsis
2️⃣ Provide Input Data
python
Copy code
data = [
    [250, 16, 12, 5], 
    [200, 16, 8, 3], 
    [300, 32, 16, 4], 
    [275, 32, 8, 4], 
    [225, 16, 16, 2]
]
weights = [0.25, 0.25, 0.25, 0.25]  # Importance of each criterion
impacts = ['+', '+', '-', '+']  # '+' for beneficial criteria, '-' for non-beneficial
3️⃣ Compute the TOPSIS Score
python
Copy code
topsis = Topsis(data, weights, impacts)
scores, ranks = topsis.calculate_topsis_score()

print("TOPSIS Scores:", scores)
print("Ranks:", ranks)
4️⃣ Example Output
less
Copy code
TOPSIS Scores: [0.62, 0.44, 0.78, 0.66, 0.32]
Ranks: [3, 5, 1, 2, 4]
The alternative with Rank = 1 is the best choice.
🔬 How Does TOPSIS Work?
Normalize the Decision Matrix
Each value is divided by the square root of the sum of squares for that criterion.

Apply Weights
Each normalized value is multiplied by its corresponding weight.

Find Ideal Best & Ideal Worst Values

Ideal Best: The best value for each criterion (max for benefit, min for cost).
Ideal Worst: The worst value for each criterion (min for benefit, max for cost).
Calculate Separation Measures

Distance from Ideal Best
Distance from Ideal Worst
Compute TOPSIS Score
Higher scores mean the alternative is closer to the ideal solution.

Rank the Alternatives
The alternative with the highest TOPSIS score is Rank 1.

📜 License
This project is licensed under the MIT License. You are free to use, modify, and distribute it.

🛠 Contributing
Want to improve this package? Feel free to fork the repository and submit a pull request! 🎯

✉ Contact
For any issues or queries, reach out at: 
📧 Email: sarika090903@gmail.com
📌 GitHub: https://github.com/Sarikaa9

🎉 Enjoy Decision-Making with TOPSIS! 🚀
This version of README.md makes the package more professional and user-friendly. Let me know if you need more edits! 🚀
topsis-navneet-102203715 1.0.3
A Python package to perform TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)
Requires Python: >=3.6

# topsis_navneet_102203715

`topsis_navneet_102203715` is a Python package that implements the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS) method for multi-criteria decision analysis.

## Installation

You can install the package using pip:

```bash
pip install topsis_navneet_102203715
```

## Usage

### Input File Format

The input CSV file should have the following structure:

- The first column should contain the names of the models.
- The subsequent columns should contain the criteria values for each alternative.
- The first row should contain the headers for each column.

Example:

| model | Criteria 1 | Criteria 2 | Criteria 3 |
|-------------|------------|------------|------------|
| m1        | 250        | 16         | 12         |
| m2        | 205        | 15         | 8          |
| m3        | 310        | 22         | 15         |

### Command-line Usage

After installation, you can use the `topsis` command in the terminal:

```bash
topsis <input_file> <weights> <impacts> <output_file>
```

- `<input_file>`: Path to the input CSV file.
- `<weights>`: Comma-separated string of weights for the criteria.
- `<impacts>`: Comma-separated string of '+' or '-' indicating the desirability of the criteria.
- `<output_file>`: Path to the output CSV file to save the results.

## Example

```bash
topsis data.csv "0.4,0.3,0.3" "+,-,+" results.csv
```

This command will process the `data.csv` file using the specified weights and impacts and output the results to `results.csv`.

## NOTE

- Ensure that the input file has at least three columns: one for alternatives and at least two for criteria.
- All criteria columns should contain numeric values.
- The number of weights and impacts must match the number of criteria.
- Impacts should only be '+' or '-'.

## License

This project is licensed under the MIT License. See the LICENSE file for details.
newpro-autoloader 0.0.1
Interface to NewPro's TEM/SEM Autoloader
Requires Python: >=3.8

# autoloader
The autoloader from NewPro LLC is a device that attaches to the side loading port of a TEM or SEM.  Instead of the normal sample holder, which is loaded manually one sample at a time, the autoloader is a motorized device that can load a dozen or more (depends on configuration) samples at the touch of a button.

# The Library
This project is a native Python library for commanding the autoloader.  It can be integrated into other applications to coordinate the loading of samples with the operation of the microscope.  A .NET assembly is also available which serves the same purpose.

# Example
Refer to `basic_test.py`.
topsis-Navyaa-102203276 1.0.0
A Python package to perform TOPSIS (Technique for Order Preference by Similarity to Ideal Solution).
Requires Python: >=3.6

# TOPSIS Implementation in Python

This Python package implements the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS). It ranks alternatives based on multiple criteria while considering their weights (importance) and impacts (benefit or cost).

## Features

- **Input Validation**: Ensures the dataset, weights, and impacts are correctly formatted.
- **Error Handling**: Handles invalid data, incorrect parameters, and file-related issues gracefully.
- **Outputs**: Generates a CSV file with scores, rankings, and original data columns.

---

## How to Use

1. Clone the repository and navigate to the project directory.
2. Ensure Python is installed with the required libraries.
3. Run the program using the following command:
   ```bash
   python -m topsis_Navyaa_102203376.topsis <InputDataSet.csv> <Weights> <Impacts> <ResultFile.csv>

   ## Input dataset
![TOPSIS Example](images/ss1.png)

## Weights used
[1,1,1,1,1]

## Impacts used
[0,1,1,0,1]
### 1 for benifit
### 0 for cost

## Output
![Result](images/ss2.png)
Topsis-KetakiAloni-102217076 0.1.0
A Python package for TOPSIS decision-making method
Requires Python: >=3.6

# **Topsis Package**

This Python package implements the **TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)** method for multi-criteria decision-making problems. It helps in ranking and selecting from a set of alternatives based on weights and impacts of the given criteria.

---

## **What is TOPSIS?**
TOPSIS is a multi-criteria decision-making (MCDM) method. It ranks alternatives based on their similarity to the ideal solution (highest value) and their distance from the negative ideal solution (lowest value). The method is widely used for decision analysis across various domains.

---

## **Features**
- Computes TOPSIS scores and rankings for alternatives.
- Accepts custom weights and impacts for criteria.
- Supports command-line execution and integration into Python programs.
- Outputs results as a CSV file with scores and ranks.

---

## **Installation**
To install the package, use the following command:

```bash
pip install topsis_package
topsis-Saurabh-102203677 1.0.0
A Python package to perform TOPSIS (Technique for Order Preference by Similarity to Ideal Solution).
Requires Python: >=3.6

# TOPSIS Implementation in Python

This project demonstrates the implementation of the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS) algorithm in Python. The method is used to rank alternatives based on multiple criteria, considering their respective weights and impacts (benefit or cost).

## Key Features

- **Robust Input Validation**: Ensures the correctness of input parameters, file formats, and consistency in weights and impacts.
- **Comprehensive Error Handling**: Handles issues such as invalid data, incorrect file formats, and mismatched inputs gracefully.
- **Detailed Outputs**: Generates a CSV file containing the computed scores, rankings, and the original dataset columns.

---

You can access the package through this [link](https://pypi.org/project/topsis-Saurabh-102203677/#description).

## How to Use

1. Clone the repository and navigate to the project folder.
2. Ensure Python and required libraries are installed on your system.
3. Run the program using the following command:
   ```bash
   python -m topsis_Saurabh_102203677.topsis <InputDataSet.csv> <Weights> <Impacts> <ResultFile.csv>
   ```

## Example Input Dataset
![TOPSIS Example](images/ss1.png)
## Weights Example
Weights for criteria:
```python
[1, 1, 1, 1, 1]
```

## Impacts Example
Impacts for criteria:
```python
['-', '+', '+', '-', '+']
```
- `+` indicates a benefit criterion.
- `-` indicates a cost criterion.

## Example Output
![Result](images/ss2.png)
---
Topsis-Prabhjot-102203767 1.0.2
A Python package to perform TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)
Requires Python: >=3.6

# Topsis_Prabhjot_102203767

`Topsis_Prabhjot_102203767`is a Python package for implementing the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS). It is a popular multi-criteria decision-making method used to rank alternatives based on their relative closeness to the ideal solution.

## Installation

You can install the package using pip:

```bash
pip install Topsis_Prabhjot_102203767
```

## Usage

### Input File Format

The input CSV file must follow this structure:

- The first column should contain the names of the alternatives (e.g., products, models, or options).
- Subsequent columns should contain the numerical values of the criteria for each alternative.
- The first row should provide headers for all columns.

### Example

Suppose you have an input CSV file named `data.csv` with the following content:

| Model | Price | Battery Life | Performance | Portability |
| ----- | ----- | ------------ | ----------- | ----------- |
| m1    | 300   | 10           | 8           | 6           |
| m2    | 250   | 8            | 7           | 9           |
| m3    | 400   | 9            | 9           | 5           |

You want to apply the TOPSIS method with the following parameters:

- Weights for the criteria: `Price` (0.5), `Battery Life` (0.3), `Performance` (0.2)
- Impacts for the criteria: `Price` (-), `Battery Life` (+), `Performance` (+)

The command would be:

````bash
topsis data.csv "0.5,0.3,0.2" "-,+,+" results.csv


### Command-line Usage

After installation, you can use the `topsis` command in the terminal:

```bash
topsis <input_file> <weights> <impacts> <output_file>
````

- `<input_file>`: Path to the input CSV file.
- `<weights>`: Comma-separated string of weights for the criteria.
- `<impacts>`: Comma-separated string of '+' or '-' indicating the desirability of the criteria.
- `<output_file>`: Path to the output CSV file to save the results.

## Example

```bash
topsis data.csv "0.5,0.3,0.2" "+,-,+" results.csv
```

This command will process the `data.csv` file using the specified weights and impacts and output the results to `results.csv`.

## NOTE

- Ensure the input file contains at least three columns: one for alternatives and at least two for criteria.
- All criteria values should be numerical.
- The number of weights and impacts should match the number of criteria columns.
- Impacts must only include + (beneficial) or - (non-beneficial).

## License

This project is licensed under the MIT License. See the LICENSE file for details.
Topsis-Shreeya-102203815 1.0.0
A Python package implementing TOPSIS method for MCDM problems
Requires Python: >=3.6

# Topsis-Shreeya Kesarwani-102203815

A Python package for implementing the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) method.

## Installation

```bash
pip install Topsis-Shreeya-102203815
```

## Usage

The package can be used through command line:

```bash
topsis <InputDataFile> <Weights> <Impacts> <ResultFileName>
```

### Example

```bash
topsis data.xlsx "1,1,1,2,1" "+,+,-,+,+" output.csv
```

### Input Format
* Input file (CSV/Excel) should contain numeric values for all columns except the first one.
* First column is the object/variable name.
* Second to last columns contain numeric values only.

### Parameters
1. `<InputDataFile>`: Input file name including path (csv/xlsx)
2. `<Weights>`: Comma separated weight values for each column
3. `<Impacts>`: Comma separated impacts (+/-) for each column
4. `<ResultFileName>`: Output file name including path

### Output
The output file contains all the columns of input file along with two additional columns having TOPSIS Score and Rank.

## License
MIT License

## Author
Shreeya Kesarwani
topsis.3883 0.1
a package to calculate topsis

# topsis python package
a python package to choose the best alternative from a finite set of decision alternatives using TOPSIS.

## overview
the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) library provides an implementation of the TOPSIS decision-making method. this technique is used to rank alternatives based on multiple criteria by comparing their distance from an ideal best and an ideal worst solution.

## features
<ul>
  <li>normalize decision matrices</li>
  <li>apply weights and impacts to criteria</li>
  <li>calculate performance scores and rankings</li>
</ul>

## usage
```python 102203883.py <input_file> <weights> <impacts>```
topsis.102203883 0.1
a package to calculate topsis

# topsis python package
a python package to choose the best alternative from a finite set of decision alternatives using TOPSIS.

## overview
the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) library provides an implementation of the TOPSIS decision-making method. this technique is used to rank alternatives based on multiple criteria by comparing their distance from an ideal best and an ideal worst solution.

## features
<ul>
  <li>normalize decision matrices</li>
  <li>apply weights and impacts to criteria</li>
  <li>calculate performance scores and rankings</li>
</ul>

## usage
```python 102203883.py <input_file> <weights> <impacts>```
Topsis-Harsh-102203964 1.0.0
A Python package for implementing TOPSIS

---

# **Topsis-Harsh-102203964**

A Python package for implementing the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) method. This method is used for multi-criteria decision-making.

---

## **Installation**

Install the package using `pip`:

```bash
pip install Topsis-Harsh-102203964
```

---

## **Usage**

### **Command-Line Interface**

After installation, you can use the `topsis` command to calculate rankings for your dataset.

#### **Command Syntax**
```bash
topsis <InputDataFile> <Weights> <Impacts> <ResultFileName>
```

- `<InputDataFile>`: Path to the input CSV file.
- `<Weights>`: Comma-separated list of weights for each criterion (e.g., `2,1,3,2,1`).
- `<Impacts>`: Comma-separated list of impacts for each criterion (`+` for positive, `-` for negative).
- `<ResultFileName>`: Path to save the output CSV file.

---

### **Input File Format**
- The input file must be a CSV with at least 3 columns.
- The **first column** should contain the names of the objects (e.g., M1, M2, ...).
- The remaining columns should contain **numeric criteria values**.

#### Example Input (`data.csv`):
```csv
Object,Criteria1,Criteria2,Criteria3,Criteria4
M1,250,16,12,5
M2,200,16,8,3
M3,300,32,16,4
M4,275,16,8,4
M5,225,32,16,2
```

---

### **Example Usage**
1. Prepare the input CSV file (e.g., `data.csv`).
2. Run the following command:

```bash
topsis data.csv 2,1,3,2,1 +,-,+,+,+ result.csv
```

3. The result will be saved in the specified output file (e.g., `result.csv`).

#### Example Output (`result.csv`):
```csv
Object,Criteria1,Criteria2,Criteria3,Criteria4,Topsis Score,Rank
M1,250,16,12,5,0.75,2
M2,200,16,8,3,0.45,4
M3,300,32,16,4,0.85,1
M4,275,16,8,4,0.55,3
M5,225,32,16,2,0.30,5
```

---

## **Requirements**

This package requires the following Python libraries:
- `numpy`
- `pandas`

These dependencies are automatically installed with the package.

---

## **License**

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

---
102383077-Shresth-Topsis 1.0.0
A Python implementation of the TOPSIS algorithm for multi-criteria decision analysis.

# TOPSIS Implementation

## 1. Methodology
- **Step 1**: Data Collection  
- **Step 2**: Data Pre-Processing (Normalization and Validation)  
- **Step 3**: Weighted Normalization  
- **Step 4**: Calculation of Ideal Best and Ideal Worst Solutions  
- **Step 5**: Calculation of Separation Measures  
- **Step 6**: Calculation of Relative Closeness (TOPSIS Score)  
- **Step 7**: Ranking  

## 2. Description
- **Objective**: To implement the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) method for multi-criteria decision analysis.  
- **Inputs**:  
  - A CSV file containing alternatives and their performance across criteria.  
  - Weights for criteria and their respective impacts (benefit or cost).  
- **Outputs**:  
  - A CSV file with TOPSIS scores and ranks for the alternatives.  
- **Error Handling**:  
  - File existence and format validation.  
  - Ensures impacts are '+' (benefit) or '-' (cost).  
  - Ensures the number of weights and impacts matches the criteria count.

## 3. Input / Output
### **Input File Example**: `<RollNumber>-data.csv`

| Alternative | Criterion 1 | Criterion 2 | Criterion 3 |
|-------------|-------------|-------------|-------------|
| A1          | 50          | 60          | 70          |
| A2          | 60          | 80          | 90          |
| A3          | 70          | 85          | 80          |

### **Output File Example**: `<RollNumber>-result.csv`

| Alternative | Criterion 1 | Criterion 2 | Criterion 3 | TOPSIS Score | Rank |
|-------------|-------------|-------------|-------------|--------------|------|
| A1          | 50          | 60          | 70          | 0.556        | 2    |
| A2          | 60          | 80          | 90          | 0.890        | 1    |
| A3          | 70          | 85          | 80          | 0.467        | 3    |

## 4. Usage Instructions
Run the program from the command line with the following format:  
```bash
python <RollNumber>.py <InputDataFile> <Weights> <Impacts> <ResultFileName>
Topsis-Gautam-102217084 1.0.0
A python package for implementing topsis

# Topsis-Gautam-102217084

Assignment(UCS654)<br>
Submitted by: Gautam Garg<br>
Roll no: 102217084<br>
Group: 3Q14

## Description

This is a python package used to implement TOPSIS(Technique of Order Preference Similarity to the Ideal Solution) for MCDA(Multiple criteria decision analysis)

<br>

## How to use this package:

## Installation

pip install Topsis-Gautam-102217084

## Example:

## Sample dataset

|P1|P2|P3|P4|P5|
|---|---|---|---|---|
|0\.84|0\.71|6\.7|42\.1|12\.59|
|0\.91|0\.83|7\.0|31\.7|10\.11|
|0\.79|0\.62|4\.8|46\.7|13\.23|
|0\.78|0\.61|6\.4|42\.4|12\.55|
|0\.94|0\.88|3\.6|62\.2|16\.91|
|0\.88|0\.77|6\.5|51\.5|14\.91|
|0\.66|0\.44|5\.3|48\.9|13\.83|
|0\.93|0\.86|3\.4|37\.0|10\.55|
## Input

### In Command Prompt

Enter filename followed by .csv or .xlsx extension, then enter values of weights separated by commas like "1,1,1,2,2",then enter values of impacts separated by commas like "+,+,-,-,+" without giving space in between comma value, then enter name of file where you want to save output followed by .csv extension

```
python -m Topsis-Gautam-102217084 data.xlsx "1,1,1,1,1" "+,-,+,-,+" output.csv
```

## Output

This will be in our Output csv file
|P1|P2|P3|P4|P5|Topsis Score|Rank|
|---|---|---|---|---|---|---|
|0\.84|0\.71|6\.7|42\.1|12\.59|0\.5945517248616172|2|
|0\.91|0\.83|7\.0|31\.7|10\.11|0\.5662461787825045|3|
|0\.79|0\.62|4\.8|46\.7|13\.23|0\.4853941230447056|6|
|0\.78|0\.61|6\.4|42\.4|12\.55|0\.6127758823558636|1|
|0\.94|0\.88|3\.6|62\.2|16\.91|0\.36155091758331526|8|
|0\.88|0\.77|6\.5|51\.5|14\.91|0\.5387640655736284|5|
|0\.66|0\.44|5\.3|48\.9|13\.83|0\.560458620506467|4|
|0\.93|0\.86|3\.4|37\.0|10\.55|0\.38966293040831607|7|




## Published Package on pypi.org

https://pypi.org/project/Topsis-Gautam-102217084/
Topsis-Kartik-102203789 1.0.0
TOPSIS implementation
Requires Python: >=3.6

# Topsis-KartikSidana-102203789

A Python implementation for Multi-Criteria Decision Making (MCDM) using the TOPSIS method (Technique for Order of Preference by Similarity to Ideal Solution). This package helps decision makers evaluate alternatives based on multiple criteria with different weights and impacts.

## Installation

To install the package, run:
bash
pip install Topsis-KartikSidana-102203789


## Usage

Execute the package through command line:
bash
topsis <input_file> <weights> <impacts> <output_file>


Example:
bash
topsis data.xlsx "1,1,1,1,1" "+,+,+,+,+" output.csv


## Input Requirements

- Input file (CSV/Excel) must contain numeric values except for the first column
- First column should contain the names of alternatives
- All other columns should contain numerical data
- At least 3 columns required for meaningful results

## Parameters

1. <input_file>: Path to your dataset file (supports .csv and .xlsx)
2. <weights>: Weighted importance of each criterion (comma-separated numbers)
3. <impacts>: Nature of each criterion (comma-separated '+' or '-')
   - '+' indicates benefit criterion (higher values desired)
   - '-' indicates cost criterion (lower values desired)
4. <output_file>: Name of file to store results

## Output Format

The output file includes:
- All columns from input file
- TOPSIS Score: Calculated similarity to ideal solution
- Rank: Position of each alternative based on TOPSIS score

## Error Handling

The package includes robust error checking for:
- Incorrect number of weights or impacts
- Invalid file formats
- Non-numeric values in criteria columns
- Missing or incomplete data

## License
MIT License

## Author
Kartik Sidana
Roll Number:Â 102203789