semvec/pypi-packages huggingface dataset:
Topsis-Navjot-102217046 1.0.3
Implementation of Topsis
Keywords: Topsis, Topsis-Navjot-102217046, Navjot, Topsis-Navjot, 102217046

# TOPSIS Implementation

This repository contains a Python implementation of the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS). TOPSIS is a powerful multi-criteria decision-making method that assists in ranking a set of alternatives based on their proximity to the ideal solution.

## Table of Contents

1. [Introduction](#introduction)
2. [Usage](#usage)
3. [Command-line Arguments](#command-line-arguments)
6. [Requirements](#requirements)

## Introduction

The Technique for Order Preference by Similarity to Ideal Solution (TOPSIS) is a well-established method for decision-making. This Python implementation allows you to easily apply TOPSIS to your decision matrix and obtain a ranked list of alternatives.

### Key Concepts:

- Decision Matrix: Represents alternatives and criteria.
- Weights: Assign importance to criteria.
- Impacts: Indicate whether higher or lower values are favorable.
- Normalization: Ensures all criteria are on a similar scale.
- Ideal and Worst Solutions: Represent best and worst possible outcomes.
- Similarity and Dissimilarity Measures: Calculate proximity to ideal and dissimilarity to worst.
- TOPSIS Score: Combines similarity and dissimilarity measures.
- Ranking: Alternatives are ranked based on TOPSIS scores.

## Usage

1. Ensure you have Python installed on your system.

2. Clone this repository to your local machine:

   ```bash
   git clone https://github.com/dhruvRajoria/Topsis_Dhruv

3. Navigate to the project directory:

      ```bash
   git clone https://github.com/dhruvRajoria/Topsis_Dhruv

   
4. Run the TOPSIS script with the required command-line arguments:

   
      python 102217050.py 102217050-data.csv "1,1,1,2" "+,+,-,+" result.csv



5. The TOPSIS analysis will be performed, and the result will be saved to the specified CSV file.

## Command-line Arguments

- `<InputDataFile>`: Path to the input CSV file containing the decision matrix.

- `<Weights>`: Comma-separated weights for each criterion.

- `<Impacts>`: Comma-separated impact signs for each criterion (use '+' for beneficial criteria and '-' for non-beneficial criteria).

- `<ResultFileName>`: Desired name for the output CSV result file.



## Requirements

- Python 3.x
- pandas
- numpy
Topsis-Tanvi-102213024 1.0.2
A Python package to perform TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)
Requires Python: >=3.6

# Topsis_Tanvi_102213024

`Topsis_Tanvi_102213024`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_Tanvi_102213024
```

## 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.
Abhijeet-102217186 0.1.0
TOPSIS Python Package
Requires Python: >=3.6

# TOPSIS Package

This package implements the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) method for decision-making.

## Installation
```bash
pip install topsis

## To run file :
pyhton topsis.py <input_file_location> "weights" "impacts" <output_file_location.csv>


Where:
<input_file> is the path to the CSV file containing the decision matrix.
<weights> is a comma-separated list of weights for the criteria (e.g., 1,1,1,1).
<impacts> is a comma-separated list of impact directions for the criteria (e.g., +,+,-,- where + indicates a benefit criterion and - indicates a cost criterion).
<output_file> is the path where the results will be saved, including the TOPSIS score and rank for each alternative.
topsis-ANANYA-102216114 1.0.3
A Python package for performing TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) to rank the entries in a dataset.
Requires Python: >=3.7

# Topsis PyPi Package (CLI)

Submitted By: **Ananya Gaur 102216114**

A Python package that can be used as a CLI tool for implementing Topsis method used for multi-criteria decision analysis by calculating performance and ranks. Topsis stands for '**T**echnique for **O**rder of **P**reference by **S**imilarity to **I**deal **S**olution'.
<br>
Checkout the package ðŸ‘‰: <https://pypi.org/project/topsis-ANANYA-102216114/>

> CLI scripts takes `csv/excel` files as input!

## Installation of the package
```
$ pip install topsis-ANANYA-102216114
```

## Command Line Usage
```
$ topsis-ANANYA-102216114 input_filePath weights impacts output_filePath
```
### Arguments
| Arguments | Description |
|------------| -----------------|
| input_file |  Input CSV file path |
| weights | Comma separated string of numbers(weights) |
| impacts | Comma separated string of '+' or '-' |
| output_file | Output CSV file path |

### Output
Creates a csv *output_file*, that contains the original data alongwith additional cloumns of Topsis Performance score and rank.

Example:
```bash
$topsis-ANANYA-102216114 data.csv "1,0.25,1,1" "+,-,+,-,+" output.csv 
```

<br>

## Sample dataset

### 1. Structure of the Decision Matrix
- The file must contain **three or more columns**.
- The **first column** contains the names or identifiers of the Model/Product alternatives (e.g., M1, M2, etc.).
- The **remaining columns** (from the second column onwards) contain **Numeric** or **Nominal** values representing the criteria for evaluation.

**Example Decision Matrix:**
Model | Cost | Quality | Durability | Ease of use
------------ | ------------- | ------------ | ------------- | ------------
M1 |	250 | 8.5	| 7.0 | 9.0
M2 |    300 | 7.8	| 8.5 | 8.0
M3 |	200 | 9.0	| 6.5 | 7.5
M4 |	290 | 8.2	| 7.8 | 8.8
M5 |	350 | 9.5	| 8.2 | 7.9

<br>


## License
Licensed under the [MIT License](https://github.com/ananyagr02/topsis-ANANYA-102216114/blob/main/LICENSE).
Topsis-Akshit-102217075 0.1.1
A Python package for TOPSIS analysis.
Requires Python: >=3.6

# Topsis-Akshit-102217075

This package implements the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) method for multi-criteria decision analysis.

## Installation 

```bash
pip install Topsis-Akshit-102217075

```
## Usage

```bash
topsis <input_file> <weights> <impacts> <result_file>
```

## Example

```bash
topsis data.csv "1,1,1,1" "+,+,-,+" result.csv
```

## LICENSE

This package is licensed under the MIT License.
terryology 0.1.3
A Python package implementing Terry's unique mathematical system
Requires Python: >=3.8
Keywords: education, mathematics, terryology

# Terryology

A Python package implementing Terry's unique mathematical system, where multiplication is defined as `a × b = a + b copies of a`.

## Installation

Using uv:
```bash
uv pip install terryology
```

Using pip:
```bash
pip install terryology
```

## Basic Usage

```python
from terryology import multiply, power

# Terry multiplication
result = multiply(2, 3)  # Returns 8 (2 + 3*2)

# Terry power
result = power(2, 2)    # Returns 6 (2 + 2*2)
```

## Extending Terry's Mathematics

The package exposes the `use_terryology` decorator, allowing you to create your own Terry-style mathematical operations:

```python
from terryology import use_terryology

# Create a new operation using Terry multiplication
@use_terryology
def square(a, b):
    # In Terry's system, squaring is the same as multiply(x, x)
    return a * a

# Create more complex expressions
@use_terryology
def complex_operation(a, b):
    # This will use Terry's multiplication and power rules
    return math.pow(a * b, 2)

# You can also use it for your own mathematical insights
@use_terryology
def my_terry_formula(a, b):
    return a * b + math.pow(a, b)
```

### How the Decorator Works

The `use_terryology` decorator transforms mathematical operations within a function to follow Terry's system:
- Regular multiplication (`*`) becomes `a + (b * a)`
- `math.pow(a, b)` is redefined according to Terry's multiplication rules

## Contributing

Contributions are welcome! If you have discovered new insights into Terry's mathematical system, please feel free to submit a pull request.

## License

MIT License
Topsis-Garv-102203753 0.1
A Python package implementing TOPSIS method for MCDM
Requires Python: >=3.6

# TOPSIS Implementation by Garv

A Python package that implements the Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS) method.

Submitted by: Garv
Roll Number: 102203753

## Installation

```bash
pip install Topsis-Garv-102203753
```

## Usage

From command line:
```bash
topsis input.csv "1,1,1,2" "+,+,-,+" output.csv
```

From Python:
```python
from topsis import calculate_topsis
calculate_topsis("input.csv", "1,1,1,2", "+,+,-,+", "output.csv")
```

## Input Format

1. Input file must be a CSV file with 3 or more columns
2. First column is the object/variable name
3. From 2nd column onwards should contain only numeric values
4. Weights should be comma-separated numbers (e.g. "1,1,1,2")
5. Impacts should be comma-separated +/- symbols (e.g. "+,+,-,+")

## Output

The program will create a result CSV file containing:
- All columns from input file
- Two additional columns: 'Topsis Score' and 'Rank'

## Error Handling

The program will check for:
- Correct number of parameters
- File existence
- Input file format
- Number of weights/impacts matching number of criteria
- Valid impact symbols (+/-)

## License

Â© 2024 Garv
This project is licensed under the MIT License - see the LICENSE file for details.
topsis-prak-3844 1.0.1
A Python package to implement the TOPSIS method for multi-criteria decision-making.
Requires Python: >=3.6

<<<<<<< HEAD
 
# TOPSIS-PRAK-3844

This Python package implements the **TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)** method for multi-criteria decision-making.

## Installation

```bash
pip install topsis-prak-3844
=======
# topsis-prak-3844
A Python package for implementing the TOPSIS method
>>>>>>> 374167f57386326dce7764945ec10ecfa0535a22
topsis102203635 0.1.4
Package to perform TOPSIS Analysis
Requires Python: >=3.6

# TOPSIS Method for Decision Analysis
This Python package provides an efficient implementation of the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) method. It's a straightforward tool to evaluate alternatives based on multiple criteria and rank them according to their relative performance.

## How to Install
To install the package, use pip as follows:

pip install topsis102203635

## Quick Start Guide
Import the Library and Set Up Data
Here's an example to help you get started with this package:

import pandas as pd
from topsis102203635 import Topsis


data = {
    'P1': [0.88, 0.91, 0.79, 0.94],
    'P2': [0.77, 0.83, 0.62, 0.88],
    'P3': [6.5, 7.0, 4.8, 3.6],
    'P4': [51.5, 31.7, 46.7, 62.2],
    'P5': [14.91, 10.11, 13.23, 16.91]
}

df = pd.DataFrame(data)

weights = [0.2, 0.2, 0.2, 0.2, 0.2]
impacts = ['+', '+', '-', '+', '+']

topsis = Topsis(df, weights, impacts)

result = topsis.calculate()

print(result)

# Key Features
Ease of Use: Simplified syntax for implementing the TOPSIS method.
Flexible Criteria: Support for any number of criteria with user-defined weights and impacts.
Customizable: Easily modify input data, weights, and the direction (impact) of each criterion.
smartg4f 1.2
Smart g4f provider selector
Requires Python: >=3.6

# SmartG4F
View on [GitHub](https://github.com/grandguyjs/smartg4f)

A python package that selects g4f providers for you.

Use `pip install smartg4f` to install the package

Instead of supplying a provider, enter `get_provider()`.
This function will validate each g4f provider and return a RetryProvider list

## Synchronous client

Note: With the synchronous client, you cannot set a custom timeout!

```
import g4f
from smartg4f import get_provider

response = g4f.ChatCompletion.create(
    model=model,
    provider=get_provider(),
    messages=messages,
)
```

```
get_provider(
    prompt: String #Prompt that tests the providers (Default: "Say hello")
    validation: Function #Validation function (Default: returns True if the output is of type str)
    model: ModelType #(Default: gpt-4o)
    log: Boolean #Log providers
)

# Example usage
get_provider(
    prompt="How is the weather today?",
    model="gpt-4",
    log=False,
)
```

## Asynchronous client

```
import g4f
from smartg4f import async_get_provider

response = g4f.ChatCompletion.create(
    model=model,
    provider=await async_get_provider(),
    messages=messages,
)
```

```
async_get_provider(
    prompt: String #Prompt that tests the providers (Default: "Say hello")
    validation: Function #Validation function (Default: returns True if the output is of type str)
    model: ModelType #(Default: gpt-4o)
    timeout: Integer #When a provider is too slow (Default: 15 seconds)
    log: Boolean #Log providers
)

# Example usage
await async_get_provider(
    prompt="How is the weather today?",
    model="gpt-4",
    timeout=5,
    log=False,
)
```

## Troubleshooting
1. Use `await async_get_provider(*args)` and `get_provider(*args)`
2. If you use the `await async_get_provider()` method **inside** a function, you need async.
3. If you use the `await async_get_provider()` method **outside** a function, you need `asyncio.run()`.
4. Make sure you have **g4f** installed