semvec/pypi-packages huggingface dataset:
clustering-eval 0.1.1
A package for evaluating clustering algorithms using NCQI.
Requires Python: >=3.6

# Clustering Evaluation (NCQI)

A Python package for evaluating clustering algorithms using the **Normalized Clustering Quality Index (NCQI)**. This package is designed for researchers and practitioners working with **unsupervised clustering** techniques, providing a **quantitative measure** for cluster quality assessment.

## 📌 Installation
To install the package, run:
```bash
pip install git+https://github.com/Mojtaba-jahanian/Cosine-Clustering-Index-CCI-.git
```

## 📖 Reference Paper
This implementation is based on the research paper:
🔗 ["Cosine Clustering Index (CCI) for Deep Clustering Evaluation"](https://link.springer.com/article/10.1007/s42979-024-02970-7)

📌 **Authors:** Mojtaba Jahanian, [Other Authors]

## 🚀 Usage
```python
from clustering_eval.ncqi import normalized_clustering_quality_index
import numpy as np

# Generate random data and labels
X = np.random.rand(100, 10)
labels = np.random.randint(0, 3, size=100)

# Compute NCQI Score
ncqi_score = normalized_clustering_quality_index(X, labels)
print("NCQI Score:", ncqi_score)
```

## 🏆 Features
- **Evaluates clustering quality** using a novel metric based on cohesion and separation.
- **Supports multiple clustering algorithms** including KMeans, Agglomerative Clustering, DBSCAN, and Spectral Clustering.
- **Scalable** for large datasets such as CIFAR-10.
- **Easy integration** into machine learning workflows.

## 📊 Example: Clustering CIFAR-10
```bash
python examples/cifar10_clustering.py
```
This example performs clustering on the CIFAR-10 dataset and evaluates the clustering results using **NCQI**.

## 🔹 Creating and Publishing the Package
### **Step 1: Build the Package**
```bash
python setup.py sdist bdist_wheel
```
✅ This command creates `dist/` and `build/` folders containing the final package files.

### **Step 2: Upload to PyPI**
```bash
twine upload dist/*
```
🔹 Enter your **PyPI username and password** when prompted.

### **Step 3: Install from PyPI**
```bash
pip install clustering_eval
```

## 📜 License
This project is licensed under the MIT License.

📥 **Download the package:** [clustering_eval_package.zip](sandbox:/mnt/data/clustering_eval_package.zip)
termstyler 2.1.1
A terminal styling library with colors, backgrounds, and text effects
Requires Python: >=3.6


# TermStyler 🎨✨  
A lightweight Python library for adding **colors, backgrounds, and text styles** to terminal output.  

## 🌟 Features  
✅ Supports **16 colors** (normal & bright)  
✅ **RGB colors** for custom styling  
✅ **Text styles** (bold, italic, underline, etc.)  
✅ **Background colors**  
✅ Works on **Windows, Linux, and macOS**  

## Installation:
```md
pip install termstyler
```

## Usage  
### **Importing the Library**
```python
from termstyler import TermStyler
```
### **Basic Colors**
```python
print(TermStyler.color("Hello in bright blue!", "bright_blue"))
print(TermStyler.color("This is red text!", "red"))
print(TermStyler.color("Cyan colored text!", "cyan"))
```
### **Text Styles**
```python
print(TermStyler.style("Bold text!", "bold"))
print(TermStyler.style("Italic text!", "italic"))
print(TermStyler.style("Underlined text!", "underline"))
```
### **Background Colors**
```python
print(TermStyler.background("Text with red background!", "red"))
print(TermStyler.background("Blue background!", "blue"))
```
### **RGB Colors**
```python
print(TermStyler.rgb(255, 165, 0, "Orange Text!"))
print(TermStyler.bg_rgb(0, 255, 0, "Green Background!"))
```
## 🛠 Full API Reference  
### **`TermStyler.color(text, color)`**  
✔ Changes the color of the text  
✔ **Example:**  
```python
TermStyler.color("Hello", "blue")
```
### **`TermStyler.background(text, bg_color)`**  
✔ Changes the background color of text  
✔ **Example:**  
```python
TermStyler.background("Text with red background", "red")
```
### **`TermStyler.style(text, style)`**  
✔ Applies a text style (bold, italic, etc.)  
✔ **Example:**  
```python
TermStyler.style("Bold text!", "bold")
```
### **`TermStyler.rgb(r, g, b, text)`**  
✔ Sets text color using RGB values  
✔ **Example:**  
```python
TermStyler.rgb(255, 165, 0, "Orange Text!")
```
### **`TermStyler.bg_rgb(r, g, b, text)`**  
✔ Sets background color using RGB values  
✔ **Example:**  
```python
TermStyler.bg_rgb(0, 255, 0, "Green Background!")
```
## 🎭 Available Styles & Colors  
| Type          | Options |
|--------------|----------------------------------------|
| **Colors**   | `black, red, green, yellow, blue, magenta, cyan, white` (also `bright_` versions) |
| **Text Styles** | `bold, dim, italic, underline, blink, reverse, hidden` |
| **Backgrounds** | Same as text colors |

## 📜 License  
This project is licensed under the **MIT License**.  

## 🤝 Contributing  
Pull requests are welcome! If you have ideas, feel free to open an issue.
cppmath 1.0.5
C++
Requires Python: >=3.6

# cppmath

A fast library of mathematical algorithms in C++, optimized for Olympiad problems and high-performance computing.

## Installation

```bash
pip install cppmath
```

## Usage

```python
import cppmath

# High Precision Initialization
config = cppmath.initialize_precision(precision_bits=128, optimize_cache=True)

# Linear Algebra
matrix = [[1, 2], [3, 4]]
result = cppmath.fast_matrix_power(matrix, 10)
eigenvalues ​​= cppmath.eigenvalue_approximation(matrix)

# Optimization
objective = [1, 2, 3]
constraints = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
result = cppmath.optimization_solver(objective, constraints, method="genetic")

# Differential equations
coeffs = [1, 0.5, 0.25]
initial = [1.0, 0.0]
solution = cppmath.differential_equation_solver(coeffs, initial, step_size=0.01, num_steps=100)

# Numerical integration
function_coeffs = [1, 2, 3] # f(x) = 1 + 2x + 3x^2
integral = cppmath.numerical_integration(function_coeffs, 0, 1, intervals=1000)

# Monte Carlo simulation
points = cppmath.monte_carlo_simulation(dimensions=3, samples=1000, seed=42)
```

## Functionality

- High-performance linear algebras
- Optimization methods (genetic algorithms, simplex method)
- Solving differential equations
- Numerical integration
- Monte Carlo simulations
- Fast Fourier transform
- Distributed caching of computations

## Requirements

- Python 3.6+
- NumPy (optional, for better performance)
- requests (for distributed caching)

## License

MIT