semvec/pypi-packages huggingface dataset:
smart-notation 0.0.1
A packages for a mathmatical nations in a data-structure
Requires Python: >=3.7

# smart_notation

smart_notation - smart_notation Expression Evaluator  
*A lightweight Python package for evaluating mathematical expressions in both prefix and postfix (RPN) smart_notation with automatic detection.*

---

## Features
- 🔍 Auto-Detection: Automatically identifies prefix or postfix smart_notation
- ⚡ Fast Evaluation: Efficient stack-based algorithm
- ➕ Operators Supported: `+`, `-`, `*`, `/` (integer division)
- 🐍 Pure Python: No external dependencies

---

## Installation
```bash
pip install smart_notation
```

## USAGE

```bash
from smart_notation import smartEval

result1 = smartEval(["2", "3", "+", "4", "*"])

result2 = smartEval(["*", "+", "2", "3", "4"])

print(f"Results: {result1}, {result2}")

```
rox-control 0.4.0
Controllers for path following
Requires Python: >=3.11

# rox-control

Controllers for path tracking.

This repository provides pure python implementations of controllers for path tracking and basic simulation and visualisation tools.

The goal is to provide simple, yet production ready controllers that are easy to understand, integrate and maintain.

Why this repo?

1. Because [PythonRobotics](https://github.com/AtsushiSakai/PythonRobotics) (which is great btw) has a purely educational purpose.
2. Because ROS2 controllers (Nav2 etc.) are C++ centered and require a lot of complexity.

## What's in the repo

**rox-control** provides production-ready path tracking controllers for robotics applications:

- **Controllers**: `PurePursuitA` - Pure pursuit path tracking controller with lookahead-based steering
- **Track Management**: `Track` class for waypoint/path management and interpolation
- **Simulation Tools**: Bicycle kinematics model, visualization, and plotting utilities (optional `[tools]` extra)
- **Examples**: Ready-to-run demonstrations of controller usage

The package focuses on simplicity and production readiness, unlike educational implementations. Core controllers are packaged separately from simulation/visualization tools.

## Quick start

### Installation

Choose your installation based on your needs:

```bash
# Production use: Core controllers only (minimal dependencies)
pip install rox-control

# Development/Research: Include simulation and visualization tools  
pip install rox-control[tools]
```

For local development from source:

```bash
git clone <repository-url>
cd rox-control
invoke create-venv  # Creates venv and installs all dependencies
```

### Basic usage

```python
from rox_control import Track
from rox_control.controllers import PurePursuitA

# Create a track from waypoints
track = Track([(0, 0), (10, 0), (10, 10), (0, 10)])

# Set up controller
controller = PurePursuitA(
    look_ahead_distance=2.0,
    target_speed=5.0
)
controller.set_track(track)

# Use in control loop
control_output = controller.control(robot_state)
```

### Examples

Run the included examples to see the controllers in action (requires `[tools]` installation):

```bash
python examples/01_basic_simulation.py     # Basic bicycle model simulation
python examples/02_pure_pursuit_a.py       # Pure pursuit path tracking
```

## Package Structure

* **Core package**: `src/rox_control/` - Controllers and track management (always available)
* **Tools package**: `src/rox_control/tools/` - Simulation and visualization tools (optional `[tools]` extra)
* **Examples**: `examples/` - Ready-to-run demonstrations


## References

* [PythonRobotics](https://github.com/AtsushiSakai/PythonRobotics) - Python code collection and a textbook of robotics algorithms.
* [Robot Kinematics](https://control.ros.org/rolling/doc/ros2_controllers/doc/mobile_robot_kinematics.html) - an introduction to mobile robot kinematics and the nomenclature
* [Automatic Steering Methods for Path Tracking](docs/Automatic_Steering_Methods_for_Autonomous_Automobile_Path_Tracking.pdf)


## Development

see [DEVELOPMENT.md](DEVELOPMENT.md)
notation-calc 0.0.1
A packages for a mathmatical nations in a data-structure
Requires Python: >=3.7

# notation_calc

notation_calc - Smart notation_calc Expression Evaluator  
*A lightweight Python package for evaluating mathematical expressions in both prefix and postfix (RPN) notation_calcs with automatic detection.*

---

## Features
- 🔍 Auto-Detection: Automatically identifies prefix or postfix notation_calc
- ⚡ Fast Evaluation: Efficient stack-based algorithm
- ➕ Operators Supported: `+`, `-`, `*`, `/` (integer division)
- 🐍 Pure Python: No external dependencies

---

## Installation
```bash
pip install notex
```

## USAGE

```bash
from notex import smartEval

# Postfix (RPN) evaluation
result1 = smartEval(["2", "3", "+", "4", "*"])  # Output: 20

# Prefix evaluation  
result2 = smartEval(["*", "+", "2", "3", "4"])  # Output: 20

print(f"Results: {result1}, {result2}")

```