RustyNum

https://rustynum.com
Admin
RustyNum is a high-performance numerical computation library written in Rust with Python bindings,...
Tokens:16,675
Snippets:159
Trust Score:4.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install RustyNum and NumPy

Source: https://rustynum.com/benchmarks/rustynum-vs-numpy

Installs the necessary libraries for benchmarking. Ensure you have Python installed.

```bash
python -V
pip install -U rustynum numpy

```

--------------------------------

### Create and Print a NumArray

Source: https://rustynum.com/tutorials/better-matrix-operations

Initialize a simple NumArray and print its contents to verify the RustyNum setup. This is a basic step to ensure the library is installed and working correctly.

```python
import rustynum as rnp

sample = rnp.NumArray([1.0, 2.0, 3.0], dtype="float32")
print("Sample array:", sample)
```

--------------------------------

### Install RustyNum using pip

Source: https://rustynum.com/installation

Install RustyNum from PyPI using pip. This is the recommended method for most users.

```bash
pip install rustynum

```

--------------------------------

### Install NumPy and RustyNum

Source: https://rustynum.com/tutorials/replacing-numpy-for-faster-analytics

Install both NumPy and RustyNum using pip. This is a prerequisite for running the performance benchmarks.

```bash
pip install numpy rustynum

```

--------------------------------

### Verify RustyNum Installation

Source: https://rustynum.com/installation

Test your RustyNum installation by importing the library and creating a zero matrix. This code snippet verifies that the library is correctly installed and functional.

```python
import rustynum as rnp

a = rnp.zeros([2, 3])
print(a)

```

```text
[[0. 0. 0.]
 [0. 0. 0.]]

```

--------------------------------

### Install RustyNum using Poetry

Source: https://rustynum.com/installation

Add RustyNum to your project managed by Poetry.

```bash
poetry add rustynum

```

--------------------------------

### Install RustyNum and Dependencies

Source: https://rustynum.com/tutorials/streamlining-machine-learning-preprocessing

Install RustyNum along with NumPy and scikit-learn for data manipulation and model integration.

```bash
pip install rustynum

```

```bash
pip install numpy scikit-learn

```

--------------------------------

### Install RustyNum using Conda and pip

Source: https://rustynum.com/installation

Install RustyNum within a conda environment. First, activate your environment, then use pip to install.

```bash
conda activate your-environment
pip install rustynum

```

--------------------------------

### Install RustyNum using Rye

Source: https://rustynum.com/installation

Add RustyNum to your project managed by Rye.

```bash
rye add rustynum

```

--------------------------------

### rustynum.linspace(start, stop, num, dtype)

Source: https://rustynum.com/api

Create a NumArray with evenly spaced values over a specified interval. Supports specifying start, stop, number of samples, and data type.

```APIDOC
## rustynum.linspace(start, stop, num, dtype='float32')

### Description
Create an array with evenly spaced values over a specified interval.

### Parameters
#### Path Parameters
- **start** (float) - Required - Start of the interval (inclusive).
- **stop** (float) - Required - End of the interval (inclusive).
- **num** (int) - Required - Number of samples to generate.
- **dtype** (str) - Optional - Data type ('float32' or 'float64'). Defaults to 'float32'.

### Returns
- **NumArray**: New NumArray with evenly spaced values.

### Raises
- **ValueError**: If dtype is unsupported.

### Examples
```
>>> import rustynum as rn
>>> arr = rn.linspace(0, 1, 5)
>>> arr.tolist()
[0.0, 0.25, 0.5, 0.75, 1.0]
```
```

--------------------------------

### Get Shape of NumArray

Source: https://rustynum.com/api

Example of accessing the shape property of a NumArray to get its dimensions.

```python
>>> arr = NumArray([[1, 2, 3], [4, 5, 6]])
>>> arr.shape
[2, 3]
```

--------------------------------

### Create Array with Linspace

Source: https://rustynum.com/api

Creates a NumArray with a specified number of evenly spaced values over a given interval. Specify start, stop, number of samples, and optionally data type.

```python
import rustynum as rn
arr = rn.linspace(0, 1, 5)
arr.tolist()
```

--------------------------------

### rustynum.arange(start, stop, step, dtype)

Source: https://rustynum.com/api

Create a NumArray with evenly spaced values within a given interval. Supports specifying start, stop, step, and data type.

```APIDOC
## rustynum.arange(start, stop, step=1.0, dtype='float32')

### Description
Create an array with evenly spaced values within a given interval.

### Parameters
#### Path Parameters
- **start** (float) - Required - Start of the interval (inclusive).
- **stop** (float) - Required - End of the interval (exclusive).
- **step** (float) - Optional - Spacing between values. Defaults to 1.0.
- **dtype** (str) - Optional - Data type ('float32' or 'float64'). Defaults to 'float32'.

### Returns
- **NumArray**: New NumArray with evenly spaced values.

### Raises
- **ValueError**: If dtype is unsupported.

### Examples
```
>>> import rustynum as rn
>>> arr = rn.arange(0, 10, 2)
>>> arr.tolist()
[0.0, 2.0, 4.0, 6.0, 8.0]
```
```

--------------------------------

### slice(axis, start, stop)

Source: https://rustynum.com/api

Slice the NumArray along a specified axis. Allows specifying start and stop indices, with None indicating the beginning or end of the axis.

```APIDOC
## slice(axis, start, stop)

### Description
Slice the array along a specified axis.

### Parameters
#### Path Parameters
- **axis** (int) - Required - Axis to slice along.
- **start** (Optional[int]) - Required - Starting index of the slice (None for beginning).
- **stop** (Optional[int]) - Required - Stopping index of the slice (None for end).

### Returns
- **NumArray**: New NumArray with sliced data.
```

--------------------------------

### Create Array with Arange

Source: https://rustynum.com/api

Creates a NumArray with evenly spaced values within a given interval. Specify start, stop, and optionally step and data type.

```python
import rustynum as rn
arr = rn.arange(0, 10, 2)
arr.tolist()
```

--------------------------------

### Concatenate Features with RustyNum

Source: https://rustynum.com/tutorials/streamlining-machine-learning-preprocessing

Combine multiple feature sets into a single RustyNum array along a specified axis. This example concatenates two 2D arrays horizontally.

```python
# Create two feature sets from our normalized data
features1 = normalized_data_rn[:, :2]  # First two columns (shape: [2, 2])
features2 = rnp.ones([2, 2])          # Match features1 shape: [2, 2]

# Combine them
combined = rnp.concatenate([features1, features2], axis=1)
print("Combined feature shape:", combined.shape)  # Expected: [2, 4]

```

--------------------------------

### Record Environment Details

Source: https://rustynum.com/benchmarks/rustynum-vs-numpy

Prints Python, NumPy, OS, CPU, and RustyNum versions. Useful for sharing benchmark results.

```python
import numpy as np, platform, sys, rustynum as rnp
print("Python", sys.version.split()[0])
print("NumPy", np.__version__)
print("OS", platform.platform())
print("CPU", platform.processor())
print("RustyNum", rnp.__version__)

```

--------------------------------

### Execute Benchmark Script

Source: https://rustynum.com/benchmarks/rustynum-vs-numpy

Runs the benchmark script to generate performance results. Ensure the script is saved as 'benchmarks.py' or similar.

```bash
python benchmarks.py

```

--------------------------------

### Matrix Dot Product in RustyNum

Source: https://rustynum.com/quick-start

Demonstrates creating a 2D NumArray (matrix) and computing the dot product with a vector using RustyNum.

```python
# Create a 2D NumArray
matrix = rnp.NumArray([[1.0, 2.0], [3.0, 4.0]], dtype="float32")

# Compute the dot product
vector = rnp.NumArray([1.0, 2.0], dtype="float32")
dot_product = matrix.dot(vector)

print(dot_product)

```

--------------------------------

### Initialize NumArray with Data and Dtype

Source: https://rustynum.com/api

Illustrates initializing a NumArray with explicit data and specifying the data type. Also shows dtype inference.

```python
>>> arr = NumArray([[1, 2], [3, 4]], dtype='float32')
>>> arr2 = NumArray([1.0, 2.0, 3.0])  # dtype inferred as float32
```

--------------------------------

### Create Matrix and Vector for Multiplication

Source: https://rustynum.com/tutorials/better-matrix-operations

Prepare a 4x4 matrix and a 4-element vector using RustyNum. The `reshape` method is used to transform a 1D list into the desired matrix dimensions.

```python
import rustynum as rnp

# Create a 4x4 matrix
matrix_data = [i for i in range(16)]  # 0 to 15
matrix = rnp.NumArray(matrix_data, dtype="float32").reshape([4, 4])

# Create a 4-element vector
vector_data = [1, 2, 3, 4]
vector = rnp.NumArray(vector_data, dtype="float32")

print("Matrix:\n", matrix)
print("Vector:\n", vector)
```

--------------------------------

### Create Two Matrices for Multiplication

Source: https://rustynum.com/tutorials/better-matrix-operations

Initialize two 2x2 matrices using RustyNum for demonstrating matrix-matrix multiplication. Ensure data types are consistent for the operation.

```python
import rustynum as rnp

# Create two 2D NumArrays
dataA = [1.0, 2.0, 3.0, 4.0]
dataB = [5.0, 6.0, 7.0, 8.0]

A = rnp.NumArray(dataA, dtype="float32").reshape([2, 2])
B = rnp.NumArray(dataB, dtype="float32").reshape([2, 2])

print("Matrix A:\n", A)
print("Matrix B:\n", B)
```

--------------------------------

### Benchmark Runner Script

Source: https://rustynum.com/benchmarks/rustynum-vs-numpy

A Python script to benchmark RustyNum and NumPy operations including mean, min, matrix-vector dot product, and matrix multiplication. It includes a warmup phase and reports median times.

```python
import time, math, numpy as np
import rustynum as rnp
from statistics import median

def bench(fn, repeats=7, warmup=2):
    for _ in range(warmup):
        fn()
    times = []
    for _ in range(repeats):
        t0 = time.perf_counter()
        fn()
        times.append(time.perf_counter() - t0)
    return median(times)

def as_rn(x):
    if x.dtype == np.float32:
        return rnp.NumArray(x.flatten().tolist(), dtype="float32").reshape(list(x.shape))
    elif x.dtype == np.float64:
        return rnp.NumArray(x.flatten().tolist(), dtype="float64").reshape(list(x.shape))
    else:
        raise ValueError("Use float32 or float64")

def run_suite(n=1_000_000, m=1000):
    results = []

    # 1) mean over vector
    vec32 = np.random.rand(n).astype(np.float32)
    vec32_rn = as_rn(vec32)

    t_np = bench(lambda: float(np.mean(vec32)))
    t_rn = bench(lambda: float(vec32_rn.mean().item()))
    results.append(("mean", f"{n}", t_rn, t_np, t_np / t_rn if t_rn > 0 else math.nan))

    # 2) minimum over vector
    t_np = bench(lambda: float(np.min(vec32)))
    t_rn = bench(lambda: float(vec32_rn.min()))
    results.append(("min", f"{n}", t_rn, t_np, t_np / t_rn if t_rn > 0 else math.nan))

    # 3) matrix vector dot
    mat = np.random.rand(m, m).astype(np.float32)
    vec = np.random.rand(m).astype(np.float32)
    mat_rn = as_rn(mat)
    vec_rn = as_rn(vec)

    t_np = bench(lambda: np.dot(mat, vec))
    t_rn = bench(lambda: mat_rn.dot(vec_rn))
    results.append(("matrix@vector", f"{m}x{m} · {m}", t_rn, t_np, t_np / t_rn if t_rn > 0 else math.nan))

    # 4) matrix matrix
    a = np.random.rand(m, m).astype(np.float32)
    b = np.random.rand(m, m).astype(np.float32)
    a_rn = as_rn(a)
    b_rn = as_rn(b)

    t_np = bench(lambda: a @ b)
    t_rn = bench(lambda: a_rn @ b_rn)
    results.append(("matrix@matrix", f"{m}x{m}", t_rn, t_np, t_np / t_rn if t_rn > 0 else math.nan))

    print("\nOperation, Size, RustyNum s, NumPy s, Speedup NumPy/RustyNum")
    for op, size, trn, tnp, sp in results:
        print(f"{op}, {size}, {trn:.6f}, {tnp:.6f}, {sp:.2f}x")

if __name__ == "__main__":
    run_suite(n=1_000_000, m=1000)

```

--------------------------------

### Create RustyNum Arrays

Source: https://rustynum.com/quick-start

Demonstrates creating various types of arrays using RustyNum: an array of zeros, an array with evenly spaced values, and an array with values over a specified interval.

```python
import rustynum as rnp

# Create an array of zeros
zeros_array = rnp.zeros([3, 3])

# Create an array with evenly spaced values
arange_array = rnp.arange(0, 10, 2)

# Create an array with evenly spaced values over a specified interval
linspace_array = rnp.linspace(0, 1, 5)

print(zeros_array)
print(arange_array)
print(linspace_array)

```

--------------------------------

### Print Results Comparison

Source: https://rustynum.com/tutorials/replacing-numpy-for-faster-analytics

Displays a comparison of computed dot product results between NumPy and RustyNum, highlighting any minor differences due to underlying algorithms. Use this to verify the accuracy of computations.

```python
print("Results Comparison:")
print("-" * 40)
print(f"NumPy dot[0]:    {dot_np[0]:.8f}")
print(f"RustyNum dot[0]: {dot_rn[0]:.8f}")
print("\nPerformance:")
print("-" * 40)
print(f"NumPy time:    {numpy_duration:.6f} seconds")
print(f"RustyNum time: {rustynum_duration:.6f} seconds")
print(f"Speedup:       {numpy_duration/rustynum_duration:.2f}x")
```

--------------------------------

### Compare NumPy and RustyNum Multiplication Performance

Source: https://rustynum.com/tutorials/better-matrix-operations

Set up matrices and vectors for both NumPy and RustyNum to perform a side-by-side comparison of their multiplication operations and measure execution time.

```python
import numpy as np
import rustynum as rnp
import time

# NumPy multiplication
matrix_np = np.arange(16, dtype=np.float32).reshape((4, 4))
vector_np = np.array([1, 2, 3, 4], dtype=np.float32)

start_np = time.time()
result_np = np.dot(matrix_np, vector_np)
end_np = time.time()
numpy_time = end_np - start_np
```

--------------------------------

### Load and Convert Data to RustyNum

Source: https://rustynum.com/tutorials/streamlining-machine-learning-preprocessing

Generate sample data using NumPy and convert it into RustyNum's NumArray format for preprocessing. Ensures data is in float32 format and reshapes it.

```python
import numpy as np
import rustynum as rnp
import math
from sklearn.linear_model import LogisticRegression

# Generate random data with shape (100, 3)
data_np = np.random.rand(100, 3).astype(np.float32)

# Convert to RustyNum's NumArray
data_rn = rnp.NumArray(data_np.flatten().tolist(), dtype="float32").reshape([100, 3])

print("RustyNum data shape:", data_rn.shape)

```

--------------------------------

### Calculate and Time Dot Product with NumPy and RustyNum

Source: https://rustynum.com/tutorials/replacing-numpy-for-faster-analytics

Compares the performance of calculating the dot product of a matrix and a vector using NumPy and RustyNum. RustyNum's optimized implementation can lead to significant speedups.

```python
import numpy as np
import rustynum as rnp
import time

# Create test data
matrix_np = np.random.rand(1000, 1000).astype(np.float32)
vector_np = np.random.rand(1000).astype(np.float32)
matrix_rn = rnp.NumArray(matrix_np.flatten().tolist(), dtype="float32").reshape([1000, 1000])
vector_rn = rnp.NumArray(vector_np.tolist(), dtype="float32")

# NumPy timing
start_np = time.time()
dot_np = np.dot(matrix_np, vector_np)
end_np = time.time()
numpy_duration = end_np - start_np

# RustyNum timing
start_rn = time.time()
dot_rn = matrix_rn.dot(vector_rn)
end_rn = time.time()
rustynum_duration = end_rn - start_rn

```

--------------------------------

### Compute Mean of a RustyNum Array

Source: https://rustynum.com/quick-start

Demonstrates creating a NumArray, performing scalar addition, and computing the mean. Use this for basic numerical computations.

```python
import rustynum as rnp

# Create a NumArray
a = rnp.NumArray([1.0, 2.0, 3.0, 4.0], dtype="float32")

# Add a scalar
a = a + 2

# Compute the mean
mean_value = a.mean().item()

print(mean_value)  # Output: 4.5

```

--------------------------------

### Create and Print Shape of NumArray

Source: https://rustynum.com/api

Demonstrates how to create a 2D NumArray and access its shape.

```python
>>> # Create a 2D array
>>> arr = NumArray([[1.0, 2.0], [3.0, 4.0]])
>>> print(arr.shape)
[2, 2]
```

--------------------------------

### Calculate and Time Minimum with NumPy and RustyNum

Source: https://rustynum.com/tutorials/replacing-numpy-for-faster-analytics

Compares the performance of finding the minimum value in a large array using NumPy and RustyNum. RustyNum's implementation can be faster.

```python
import numpy as np
import rustynum as rnp
import time

# Create test data
data_np = np.random.rand(100_000).astype(np.float32)
data_rn = rnp.NumArray(data_np.tolist(), dtype="float32")

# NumPy timing
start_np = time.time()
min_np = np.min(data_np)
end_np = time.time()
numpy_duration = end_np - start_np

# RustyNum timing
start_rn = time.time()
min_rn = data_rn.min()
end_rn = time.time()
rustynum_duration = end_rn - start_rn

# Print results
print("Results Comparison:")
print("-" * 40)
print(f"NumPy min:     {min_np:.8f}")
print(f"RustyNum min:  {min_rn:.8f}")
print("\nPerformance:")
print("-" * 40)
print(f"NumPy time:    {numpy_duration:.6f} seconds")
print(f"RustyNum time: {rustynum_duration:.6f} seconds")
print(f"Speedup:       {numpy_duration/rustynum_duration:.2f}x")

```

--------------------------------

### Matrix Multiplication Comparison (RustyNum vs NumPy)

Source: https://rustynum.com/tutorials/better-matrix-operations

Performs matrix multiplication using both RustyNum and NumPy, then prints the results and execution times. This snippet is useful for benchmarking RustyNum against NumPy.

```python
matrix_rn = rnp.NumArray(matrix_np.flatten().tolist(), dtype="float32").reshape([4, 4])
vector_rn = rnp.NumArray(vector_np.tolist(), dtype="float32")

start_rn = time.time()
result_rn = matrix_rn.dot(vector_rn)
end_rn = time.time()
rustynum_time = end_rn - start_rn

print("NumPy result:", result_np)
print("RustyNum result:", result_rn)
print(f"NumPy time: {numpy_time:.6f} seconds")
print(f"RustyNum time: {rustynum_time:.6f} seconds")
```

--------------------------------

### Min-Max Scaling Function with RustyNum

Source: https://rustynum.com/tutorials/streamlining-machine-learning-preprocessing

Implement a min-max scaling function using RustyNum to scale each column of an array to a [0, 1] range. Handles division by zero by defaulting to 1.0.

```python
# Create a reusable scaling function
def min_max_scale(array):
    # Step 1: Compute column-wise min and max
    col_mins = []
    col_maxes = []
    for col_idx in range(array.shape[1]):
        col_data = array[:, col_idx]
        col_mins.append(col_data.min())
        col_maxes.append(col_data.max())

    # Step 2 & 3: Scale each column
    scaled_data = []
    for col_idx in range(array.shape[1]):
        col_data = array[:, col_idx]
        numerator = col_data - col_mins[col_idx]
        denominator = col_maxes[col_idx] - col_mins[col_idx] or 1.0
        scaled_col = numerator / denominator
        scaled_data.append(scaled_col.tolist())

    # Concatenate scaled columns
    return rnp.concatenate(
        [rnp.NumArray(col, dtype="float32").reshape([array.shape[0], 1]) for col in scaled_data],
        axis=1
    )

# Scale our data
scaled_data_rn = min_max_scale(data_rn)
print("Scaled data shape:", scaled_data_rn.shape)
print("First row after scaling:", scaled_data_rn[0, :].tolist())

```

--------------------------------

### Perform Matrix-Matrix Multiplication using .dot()

Source: https://rustynum.com/tutorials/better-matrix-operations

Execute matrix-matrix multiplication using the `.dot()` method in RustyNum. This method is versatile and handles various numerical operations.

```python
result_matrix = A.dot(B)
print("Matrix-Matrix Multiplication Result:\n", result_matrix)
```

--------------------------------

### Matrix Multiplication with NumArray

Source: https://rustynum.com/api

Shows how to perform matrix multiplication using the '@' operator on NumArray objects.

```python
>>> # Matrix multiplication
>>> result = arr @ arr
>>> print(result.tolist())
[[7.0, 10.0], [15.0, 22.0]]
```

--------------------------------

### Perform Matrix-Vector Multiplication using .dot()

Source: https://rustynum.com/tutorials/better-matrix-operations

Execute matrix-vector multiplication using the `.dot()` method in RustyNum. This method dynamically handles different multiplication types based on input shapes.

```python
result_vec = matrix.dot(vector)
print("Matrix-Vector Multiplication Result:\n", result_vec)
```

--------------------------------

### Calculate and Time Mean with NumPy and RustyNum

Source: https://rustynum.com/tutorials/replacing-numpy-for-faster-analytics

Compares the performance of calculating the mean of a large array using NumPy and RustyNum. RustyNum may offer a speedup due to its optimized Rust backend.

```python
import numpy as np
import rustynum as rnp
import time

# Create test data
data_np = np.random.rand(1_000_000).astype(np.float32)
data_rn = rnp.NumArray(data_np.tolist(), dtype="float32")

# NumPy timing
start_np = time.time()
mean_np = np.mean(data_np)
end_np = time.time()
numpy_duration = end_np - start_np

# RustyNum timing
start_rn = time.time()
mean_rn = data_rn.mean().item()
end_rn = time.time()
rustynum_duration = end_rn - start_rn

# Print results
print("Results Comparison:")
print("-" * 40)
print(f"NumPy mean:    {mean_np:.8f}")
print(f"RustyNum mean: {mean_rn:.8f}")
print("\nPerformance:")
print("-" * 40)
print(f"NumPy time:    {numpy_duration:.6f} seconds")
print(f"RustyNum time: {rustynum_duration:.6f} seconds")
print(f"Speedup:       {numpy_duration/rustynum_duration:.2f}x")

```

--------------------------------

### Matrix Multiplication with RustyNum

Source: https://rustynum.com/tutorials/streamlining-machine-learning-preprocessing

Perform matrix multiplication using the @ operator, similar to NumPy. Initialize matrices with compatible dtypes for accurate results.

```python
# Matrix multiplication example
a = rnp.NumArray([[1.0, 2.0], [3.0, 4.0]], dtype="float32")
b = rnp.NumArray([[5.0, 6.0], [7.0, 8.0]], dtype="float32")
product = a @ b
print("Matrix multiplication result:", product.tolist())
```

--------------------------------

### tolist()

Source: https://rustynum.com/api

Converts the NumArray to a nested Python list.

```APIDOC
## tolist()

### Description
Convert the NumArray to a nested Python list.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **nested_list** (List[Any]) - Nested list representation of the array data.

### Request Example
```
>>> arr = NumArray([[1, 2], [3, 4]])
>>> arr.tolist()
[[1.0, 2.0], [3.0, 4.0]]
```

#### Response Example
```json
{
  "nested_list": "[[1.0, 2.0], [3.0, 4.0]]"
}
```
```

--------------------------------

### rustynum.NumArray

Source: https://rustynum.com/api

Initializes a high-performance numerical array backed by Rust. Supports multiple data types and NumPy-like operations.

```APIDOC
## rustynum.NumArray(data, dtype=None)

### Description
A high-performance numerical array implementation backed by Rust. Provides NumPy-like functionality with optimized operations for numerical computing. Supports multiple data types including float32, float64, and uint8.

### Parameters
#### Path Parameters
- **data** (Union[List[Any], NumArray]) - Required - Nested list of numerical data or existing NumArray.
- **dtype** (Optional[str]) - Optional - Data type ('float32', 'float64', 'uint8'). If None, dtype is inferred. Default: None

### Raises
- **ValueError**: If dtype is unsupported or data is invalid.
- **NotImplementedError**: If dtype is not yet implemented.

### Examples
```python
>>> # Create a 2D array
>>> arr = NumArray([[1.0, 2.0], [3.0, 4.0]])
>>> print(arr.shape)
[2, 2]

>>> # Matrix multiplication
>>> result = arr @ arr
>>> print(result.tolist())
[[7.0, 10.0], [15.0, 22.0]]

>>> arr = NumArray([[1, 2], [3, 4]], dtype='float32')
>>> arr2 = NumArray([1.0, 2.0, 3.0])  # dtype inferred as float32
```
```

--------------------------------

### Convert RustyNum to NumPy for ML Libraries

Source: https://rustynum.com/tutorials/streamlining-machine-learning-preprocessing

Convert preprocessed RustyNum data back to NumPy arrays for use with scikit-learn and other ML libraries. This snippet demonstrates creating dummy labels and training a simple Logistic Regression model.

```python
# Convert our preprocessed data back to NumPy
X_train = np.array(normalized_data_rn.tolist(), dtype=np.float32)

# Create dummy labels
y_train = np.random.randint(0, 2, size=(100,))

# Train a simple model
model = LogisticRegression()
model.fit(X_train, y_train)

print("Model coefficients:", model.coef_)
```

--------------------------------

### Create NumPy Array

Source: https://rustynum.com/quick-start

Standard method for creating a NumPy array with a specified data type.

```python
import numpy as np

a = np.array([1.0, 2.0, 3.0], dtype="float32")

```

--------------------------------

### rustynum.log(a)

Source: https://rustynum.com/api

Compute the natural logarithm of all elements in the input. Accepts a NumArray or scalar input and returns a new NumArray with the natural logarithm values.

```APIDOC
## rustynum.log(a)

### Description
Compute the natural logarithm of all elements in the input.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
- **a** (Union[NumArray, int, float]) - Required - Input array or scalar value.

### Returns
- **NumArray** - New NumArray with natural logarithm of all elements.

### Raises
- **TypeError** - If input type is unsupported.
```

--------------------------------

### Create RustyNum Array

Source: https://rustynum.com/quick-start

Standard method for creating a RustyNum NumArray with a specified data type.

```python
import rustynum as rnp

a = rnp.NumArray([1.0, 2.0, 3.0], dtype="float32")

```

--------------------------------

### Perform Matrix-Matrix Multiplication using @ operator

Source: https://rustynum.com/tutorials/better-matrix-operations

Perform matrix-matrix multiplication using Python's `@` operator, the preferred method in RustyNum for its clarity and consistency with NumPy.

```python
result_matrix = A @ B
print("Matrix-Matrix Multiplication Result:\n", result_matrix)
```

--------------------------------

### Reshape NumArray

Source: https://rustynum.com/api

Shows how to change the shape of a NumArray using the `reshape` method.

```python
>>> arr = NumArray([1, 2, 3, 4])
>>> reshaped = arr.reshape([2, 2])
>>> reshaped.shape
[2, 2]
```

--------------------------------

### log()

Source: https://rustynum.com/api

Computes the natural logarithm of all elements in the array, returning a new NumArray.

```APIDOC
## log()

### Description
Compute the natural logarithm of all elements.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **log_array** (NumArray) - New NumArray with natural logarithm of all elements.

#### Response Example
```json
{
  "log_array": "[new NumArray with log values]"
}
```
```

--------------------------------

### rustynum.exp(a)

Source: https://rustynum.com/api

Compute the exponential of all elements in the input. Accepts a NumArray or scalar input and returns a new NumArray with the exponential values.

```APIDOC
## rustynum.exp(a)

### Description
Compute the exponential of all elements in the input.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
- **a** (Union[NumArray, int, float]) - Required - Input array or scalar value.

### Returns
- **NumArray** - New NumArray with exponential of all elements.

### Raises
- **TypeError** - If input type is unsupported.

### Example
```python
>>> import rustynum as rn
>>> arr = rn.NumArray([0, 1, 2])
>>> result = rn.exp(arr)
>>> # result contains [1.0, 2.718..., 7.389...]
```
```

--------------------------------

### __add__(other)

Source: https://rustynum.com/api

Adds another NumArray or scalar to this array, returning a new NumArray with the result.

```APIDOC
## __add__(other)

### Description
Add another NumArray or scalar to this array.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **other** (Union[NumArray, int, float]) - Required - NumArray or scalar to add.

### Raises
- **ValueError** - If dtypes don't match between arrays.
- **TypeError** - If operand type is unsupported.

### Response
#### Success Response (200)
- **result** (NumArray) - New NumArray with the result of the addition.

#### Response Example
```json
{
  "result": "[new NumArray]"
}
```
```

--------------------------------

### exp()

Source: https://rustynum.com/api

Computes the exponential of all elements in the array, returning a new NumArray.

```APIDOC
## exp()

### Description
Compute the exponential of all elements.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **exp_array** (NumArray) - New NumArray with exponential of all elements.

### Request Example
```
>>> arr = NumArray([0, 1, 2])
>>> result = arr.exp()
>>> # result contains [1.0, 2.718..., 7.389...]
```

#### Response Example
```json
{
  "exp_array": "[new NumArray with exponential values]"
}
```
```

--------------------------------

### Perform Matrix-Vector Multiplication using @ operator

Source: https://rustynum.com/tutorials/better-matrix-operations

Perform matrix-vector multiplication using Python's `@` operator, which is the recommended and idiomatic way in RustyNum, mirroring NumPy's syntax.

```python
result_vec = matrix @ vector
print("Matrix-Vector Multiplication Result:\n", result_vec)
```

--------------------------------

### rustynum.min(a)

Source: https://rustynum.com/api

Return the minimum value of array elements. Accepts a NumArray or scalar input and returns the minimum value.

```APIDOC
## rustynum.min(a)

### Description
Return the minimum value of array elements.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
- **a** (Union[NumArray, int, float]) - Required - Input array or scalar value.

### Returns
- **Union[NumArray, float]** - The minimum value as NumArray or float.

### Raises
- **TypeError** - If input type is unsupported.
```

--------------------------------

### __truediv__(other)

Source: https://rustynum.com/api

Divides this array by another NumArray or scalar, returning a new NumArray with the result.

```APIDOC
## __truediv__(other)

### Description
Divide this array by another NumArray or scalar.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **other** (Union[NumArray, int, float]) - Required - NumArray or scalar to divide by.

### Raises
- **ValueError** - If dtypes don't match between arrays.
- **TypeError** - If operand type is unsupported.

### Response
#### Success Response (200)
- **result** (NumArray) - New NumArray with the result of the division.

#### Response Example
```json
{
  "result": "[new NumArray]"
}
```
```

--------------------------------

### rustynum.median(a)

Source: https://rustynum.com/api

Compute the median of array elements. Accepts a NumArray or scalar input and returns the median value.

```APIDOC
## rustynum.median(a)

### Description
Compute the median of array elements.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
- **a** (Union[NumArray, int, float]) - Required - Input array or scalar value.

### Returns
- **Union[NumArray, float]** - The median value as NumArray or float.

### Raises
- **TypeError** - If input type is unsupported.
```

--------------------------------

### Create Array with Zeros

Source: https://rustynum.com/api

Creates a new NumArray filled with zeros. Specify the shape and optionally the data type.

```python
import rustynum as rn
arr = rn.zeros([2, 3])
arr.shape
arr.tolist()
```

--------------------------------

### rustynum.sigmoid(a)

Source: https://rustynum.com/api

Compute the sigmoid function of all elements in the input. Accepts a NumArray or scalar input and returns a new NumArray with the sigmoid values.

```APIDOC
## rustynum.sigmoid(a)

### Description
Compute the sigmoid function of all elements in the input.
The sigmoid function is defined as: 1 / (1 + exp(-x))

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
- **a** (Union[NumArray, int, float]) - Required - Input array or scalar value.

### Returns
- **NumArray** - New NumArray with sigmoid of all elements.

### Raises
- **TypeError** - If input type is unsupported.

### Example
```python
>>> import rustynum as rn
>>> arr = rn.NumArray([-1, 0, 1])
>>> result = rn.sigmoid(arr)
>>> # result contains [0.268..., 0.5, 0.731...]
```
```

--------------------------------

### rustynum.dot(a, b)

Source: https://rustynum.com/api

Compute the dot product of two arrays or scalars. Accepts two NumArray or scalar inputs and returns the dot product result.

```APIDOC
## rustynum.dot(a, b)

### Description
Compute dot product of two arrays or scalars.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
- **a** (Union[NumArray, int, float]) - Required - First input array or scalar.
- **b** (Union[NumArray, int, float]) - Required - Second input array or scalar.

### Returns
- **Union[float, NumArray]** - Dot product result as NumArray or scalar.

### Raises
- **TypeError** - If input types are unsupported.

### Example
```python
>>> import rustynum as rn
>>> a = rn.NumArray([1, 2, 3])
>>> b = rn.NumArray([4, 5, 6])
>>> result = rn.dot(a, b)
>>> # result is 1*4 + 2*5 + 3*6 = 32
```
```

--------------------------------

### median(axis=None)

Source: https://rustynum.com/api

Computes the median along specified axes. If no axis is specified, it computes the median of all elements in the array.

```APIDOC
## median(axis=None)

### Description
Compute the median along specified axis.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **axis** (Optional[Union[int, Sequence[int]]]) - Optional - Axis or axes along which to compute the median. If None, compute median of all elements.

### Response
#### Success Response (200)
- **median_values** (Union[NumArray, float]) - NumArray with median values along specified axis, or scalar if axis is None.

#### Response Example
```json
{
  "median_values": "[median_value]"
}
```
```

--------------------------------

### NumArray.__getitem__

Source: https://rustynum.com/api

Accesses elements or slices of the NumArray using indexing. Supports slicing with a step of -1 for reversal.

```APIDOC
#### __getitem__(key)

### Description
Get item(s) at the specified index or slice. Supports single-axis flipping using slice with step=-1.

### Parameters
#### Path Parameters
- **key** (Union[int, slice, Tuple[Any, ...]]) - Required - Index, slice, or tuple of indices/slices for access.

### Returns
- **NumArray**: New NumArray with the sliced data.

### Raises
- **IndexError**: If index is out of bounds.
- **TypeError**: If index type is unsupported.
- **NotImplementedError**: If slice step is not supported.
```

--------------------------------

### min(axis=None)

Source: https://rustynum.com/api

Returns the minimum value along specified axes. If no axis is specified, it returns the minimum of all elements in the array.

```APIDOC
## min(axis=None)

### Description
Return the minimum along specified axis.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **axis** (Optional[Union[int, Sequence[int]]]) - Optional - Axis or axes along which to find the minimum. If None, return minimum of all elements.

### Response
#### Success Response (200)
- **min_value** (Union[NumArray, float]) - NumArray with minimum values along specified axis, or scalar if axis is None.

#### Response Example
```json
{
  "min_value": "[min_value]"
}
```
```

--------------------------------

### Element-wise Operations on RustyNum Arrays

Source: https://rustynum.com/tutorials/streamlining-machine-learning-preprocessing

Apply mathematical functions like sigmoid, exponential, and logarithm element-wise to RustyNum NumArray objects. Ensure data is initialized with a compatible dtype.

```python
# Element-wise operations example
data = rnp.NumArray([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype="float32")
print("Original data:", data.tolist())

# Apply the sigmoid function
sigmoid_data = data.sigmoid()
print("After applying sigmoid:", sigmoid_data.tolist())

# Compute the exponential and logarithm of each element
exp_data = data.exp()
log_data = data.log()
print("Exponential:", exp_data.tolist())
print("Logarithm:", log_data.tolist())
```

--------------------------------

### Create Array with Ones

Source: https://rustynum.com/api

Creates a new NumArray filled with ones. Specify the shape and optionally the data type.

```python
import rustynum as rn
arr = rn.ones([2, 2])
arr.tolist()
```

--------------------------------

### Matrix Multiplication using matmul Method

Source: https://rustynum.com/api

Performs matrix multiplication between two NumArray objects using the `matmul` method.

```python
>>> a = NumArray([[1, 2], [3, 4]])
>>> b = NumArray([[5, 6], [7, 8]])
>>> result = a.matmul(b)
>>> result.tolist()
[[19, 22], [43, 50]]
```

--------------------------------

### __mul__(other)

Source: https://rustynum.com/api

Multiplies this array by another NumArray or scalar, returning a new NumArray with the result.

```APIDOC
## __mul__(other)

### Description
Multiply this array by another NumArray or scalar.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **other** (Union[NumArray, int, float]) - Required - NumArray or scalar to multiply by.

### Raises
- **ValueError** - If dtypes don't match between arrays.
- **TypeError** - If operand type is unsupported.

### Response
#### Success Response (200)
- **result** (NumArray) - New NumArray with the result of the multiplication.

#### Response Example
```json
{
  "result": "[new NumArray]"
}
```
```

--------------------------------

### Add Scalar to Array (NumPy and RustyNum)

Source: https://rustynum.com/quick-start

Performs element-wise addition of a scalar to an array. This syntax is identical for both NumPy and RustyNum.

```python
a = a + 2

```

--------------------------------

### sigmoid()

Source: https://rustynum.com/api

Compute the sigmoid function of all elements in a NumArray. The sigmoid function is defined as 1 / (1 + exp(-x)).

```APIDOC
## sigmoid()

### Description
Compute the sigmoid function of all elements.

### Returns
- **NumArray**: New NumArray with sigmoid of all elements.

### Note
Sigmoid function: 1 / (1 + exp(-x))
```

--------------------------------

### Element-Wise Operations in RustyNum

Source: https://rustynum.com/quick-start

Performs element-wise addition and multiplication of a scalar to an existing RustyNum array.

```python
# Perform element-wise addition
result = arange_array + 2

# Perform element-wise multiplication
result = arange_array * 2

```

--------------------------------

### rustynum.ones(shape, dtype)

Source: https://rustynum.com/api

Create a new NumArray filled with ones. Supports specifying the shape and data type.

```APIDOC
## rustynum.ones(shape, dtype='float32')

### Description
Create a new array filled with ones.

### Parameters
#### Path Parameters
- **shape** (List[int]) - Required - Shape of the new array as a list of integers.
- **dtype** (str) - Optional - Data type ('float32' or 'float64'). Defaults to 'float32'.

### Returns
- **NumArray**: New NumArray filled with ones.

### Raises
- **ValueError**: If dtype is unsupported.

### Examples
```
>>> import rustynum as rn
>>> arr = rn.ones([2, 2])
>>> arr.tolist()
[[1.0, 1.0], [1.0, 1.0]]
```
```

--------------------------------

### rustynum.max(a)

Source: https://rustynum.com/api

Return the maximum value of array elements. Accepts a NumArray or scalar input and returns the maximum value.

```APIDOC
## rustynum.max(a)

### Description
Return the maximum value of array elements.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
- **a** (Union[NumArray, int, float]) - Required - Input array or scalar value.

### Returns
- **Union[NumArray, float]** - The maximum value as NumArray or float.

### Raises
- **TypeError** - If input type is unsupported.
```

--------------------------------

### NumArray.dot

Source: https://rustynum.com/api

Computes the dot product between the current NumArray and another NumArray.

```APIDOC
#### dot(other)

### Description
Compute dot product with another NumArray.

### Parameters
#### Path Parameters
- **other** (NumArray) - Required - Another NumArray for dot product computation.

### Returns
- **NumArray**: New NumArray containing the result of the dot product.

### Raises
- **ValueError**: If dtypes don't match or operation is unsupported.
```

--------------------------------

### rustynum.mean(a)

Source: https://rustynum.com/api

Compute the arithmetic mean of array elements. Accepts a NumArray or scalar input and returns the mean value.

```APIDOC
## rustynum.mean(a)

### Description
Compute the arithmetic mean of array elements.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
- **a** (Union[NumArray, int, float]) - Required - Input array or scalar value.

### Returns
- **Union[NumArray, float]** - The mean value as NumArray or float.

### Raises
- **TypeError** - If input type is unsupported.

### Example
```python
>>> import rustynum as rn
>>> arr = rn.NumArray([1, 2, 3, 4])
>>> rn.mean(arr)
2.5
```
```

--------------------------------

### __sub__(other)

Source: https://rustynum.com/api

Subtracts another NumArray or scalar from this array, returning a new NumArray with the result.

```APIDOC
## __sub__(other)

### Description
Subtract another NumArray or scalar from this array.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **other** (Union[NumArray, int, float]) - Required - NumArray or scalar to subtract.

### Raises
- **ValueError** - If dtypes don't match between arrays.
- **TypeError** - If operand type is unsupported.

### Response
#### Success Response (200)
- **result** (NumArray) - New NumArray with the result of the subtraction.

#### Response Example
```json
{
  "result": "[new NumArray]"
}
```
```
Tokens:
Raw