tessl/pypi-dlib

A modern C++ toolkit containing machine learning algorithms and tools for creating complex software to solve real world problems

—

Pending

Overview

Eval results

Files

Linear Algebra

Name: tessl/pypi-dlib
Author: tessl

Core mathematical data structures and operations for numerical computing, including dense matrices, vectors, points, and linear algebra functions.

Capabilities

Matrix Operations

Dense 2D matrix class for floating point numerical computations with support for various initialization methods and basic operations.

class matrix:
    """Dense 2D matrix of floating point numbers."""
    
    def __init__(self, rows: int, cols: int): 
        """Create matrix with specified dimensions."""
    
    def __init__(self, data: list):
        """Create matrix from list of lists."""
    
    def set_size(self, rows: int, cols: int):
        """Resize matrix to new dimensions."""
    
    def nr(self) -> int:
        """Get number of rows."""
    
    def nc(self) -> int:
        """Get number of columns."""
    
    def serialize(self, filename: str):
        """Save matrix to file."""
    
    def deserialize(self, filename: str):
        """Load matrix from file."""
    
    @property
    def shape(self) -> tuple:
        """Matrix dimensions as (rows, cols)."""

Usage Example:

import dlib

# Create a 3x3 matrix
m = dlib.matrix(3, 3)

# Create from data
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
m2 = dlib.matrix(data)

print(f"Matrix shape: {m2.shape}")  # (3, 3)
print(f"Rows: {m2.nr()}, Cols: {m2.nc()}")  # Rows: 3, Cols: 3

Vector Operations

Column vector class for mathematical operations with support for dynamic sizing and various initialization methods.

class vector:
    """Column vector for mathematical operations."""
    
    def __init__(self, size: int = 0):
        """Create vector with specified size."""
    
    def __init__(self, data: list):
        """Create vector from list."""
    
    def set_size(self, size: int):
        """Resize vector to new size."""
    
    def resize(self, size: int):
        """Resize vector (alias for set_size)."""
    
    @property
    def shape(self) -> tuple:
        """Vector dimensions."""

Array Operations

1D array class for floating point numbers, essentially a wrapper around std::vector<double>.

class array:
    """1D array of floating point numbers."""
    
    def __init__(self, size: int = 0):
        """Create array with specified size."""
    
    def __init__(self, data: list):
        """Create array from list."""
    
    def clear(self):
        """Remove all elements."""
    
    def resize(self, size: int):
        """Resize array to new size."""
    
    def extend(self, data: list):
        """Append elements from list."""

Point Types

2D point classes for integer and floating point coordinates with basic geometric operations.

class point:
    """2D point with integer coordinates."""
    
    def __init__(self, x: int, y: int):
        """Create point with integer coordinates."""
    
    def __init__(self, dpoint_obj: dpoint):
        """Create from dpoint."""
    
    x: int  # X coordinate
    y: int  # Y coordinate
    
    def normalize(self) -> point:
        """Return unit normalized copy."""

class dpoint:
    """2D point with floating point coordinates."""
    
    def __init__(self, x: float, y: float):
        """Create point with floating coordinates."""
    
    def __init__(self, point_obj: point):
        """Create from integer point."""
    
    x: float  # X coordinate  
    y: float  # Y coordinate
    
    def normalize(self) -> dpoint:
        """Return unit normalized copy."""

Usage Example:

import dlib

# Integer points
p1 = dlib.point(10, 20)
p2 = dlib.point(30, 40)

# Floating point
dp1 = dlib.dpoint(10.5, 20.7)
dp2 = dlib.dpoint(p1)  # Convert from integer point

# Operations
p3 = p1 + p2  # Addition
distance = dlib.length(p1)  # Distance from origin
dot_product = dlib.dot(p1, p2)  # Dot product

Point Containers

Container classes for managing collections of points.

class points:
    """Array of point objects."""
    
    def clear(self):
        """Remove all points."""
    
    def resize(self, size: int):
        """Resize container."""
    
    def extend(self, point_list: list):
        """Add points from list."""

class dpoints:
    """Array of dpoint objects."""
    
    def clear(self):
        """Remove all points."""
    
    def resize(self, size: int):
        """Resize container."""
    
    def extend(self, dpoint_list: list):
        """Add points from list."""

Linear Algebra Functions

Core mathematical functions for vector and point operations.

def dot(a, b):
    """
    Compute dot product of vectors or points.
    
    Args:
        a: First vector/point
        b: Second vector/point
    
    Returns:
        Dot product value
    """

def length(point_obj) -> float:
    """
    Compute distance from origin (L2 norm).
    
    Args:
        point_obj: Point object
    
    Returns:
        Distance as float
    """

def polygon_area(points_list) -> float:
    """
    Calculate area of polygon using shoelace formula.
    
    Args:
        points_list: List of point objects forming polygon
    
    Returns:
        Polygon area
    """

Projective Transformations

2D projective transformation class for geometric transformations.

class point_transform_projective:
    """Projective transformation for 2D points."""
    
    def __init__(self):
        """Create identity transformation."""
    
    def __init__(self, matrix_3x3):
        """Create from 3x3 transformation matrix."""
    
    @property
    def m(self):
        """3x3 transformation matrix."""
    
    def __call__(self, point_obj) -> point:
        """Apply transformation to point."""

def inv(transform: point_transform_projective) -> point_transform_projective:
    """
    Compute inverse of projective transformation.
    
    Args:
        transform: Projective transformation
    
    Returns:
        Inverse transformation
    """

def find_projective_transform(from_points, to_points) -> point_transform_projective:
    """
    Find projective transform mapping one set of points to another.
    
    Args:
        from_points: Source points
        to_points: Target points
    
    Returns:
        Projective transformation
    """

Usage Example:

import dlib

# Create transformation from point correspondences
src_points = [dlib.point(0, 0), dlib.point(100, 0), dlib.point(100, 100), dlib.point(0, 100)]
dst_points = [dlib.point(10, 10), dlib.point(90, 20), dlib.point(80, 80), dlib.point(20, 90)]

transform = dlib.find_projective_transform(src_points, dst_points)

# Apply transformation
transformed_point = transform(dlib.point(50, 50))

# Compute inverse
inv_transform = dlib.inv(transform)

Container Types for Advanced Data Structures

Additional container types for complex data organization.

class vectors:
    """Array of vector objects."""
    
    def clear(self): ...
    def resize(self, size: int): ...
    def extend(self, vector_list: list): ...

class vectorss:
    """Array of arrays of vector objects."""
    
    def clear(self): ...
    def resize(self, size: int): ...
    def extend(self, vectors_list: list): ...

class range:
    """Represents a range of elements."""
    
    def __init__(self, begin: int, end: int):
        """Create range [begin, end)."""
    
    def __init__(self, end: int):
        """Create range [0, end)."""
    
    begin: int  # Start index
    end: int    # End index (exclusive)

class ranges:
    """Array of range objects."""
    
    def clear(self): ...
    def resize(self, size: int): ...
    def extend(self, range_list: list): ...

class rangess:
    """Array of arrays of range objects."""
    
    def clear(self): ...
    def resize(self, size: int): ...
    def extend(self, ranges_list: list): ...

Sparse Vector Support

Sparse vector representation using index/value pairs for memory-efficient storage of sparse data.

class pair:
    """Index/value pair for sparse vectors."""
    
    def __init__(self, index: int, value: float):
        """Create index/value pair."""
    
    first: int    # Index
    second: float # Value

class sparse_vector:
    """Sparse column vector using index/value pairs."""
    
    def clear(self):
        """Remove all elements."""
    
    def resize(self, size: int):
        """Resize container."""
    
    def extend(self, pair_list: list):
        """Add pairs from list."""

class sparse_vectors:
    """Array of sparse_vector objects."""
    
    def clear(self): ...
    def resize(self, size: int): ...
    def extend(self, sparse_vector_list: list): ...

class sparse_vectorss:
    """Array of arrays of sparse_vector objects."""
    
    def clear(self): ...
    def resize(self, size: int): ...
    def extend(self, sparse_vectors_list: list): ...

def make_sparse_vector(sparse_vec: sparse_vector) -> sparse_vector:
    """
    Sort and deduplicate sparse vector.
    
    Args:
        sparse_vec: Input sparse vector
    
    Returns:
        Sorted and deduplicated sparse vector
    """

Usage Example:

import dlib

# Create sparse vector
sparse_vec = dlib.sparse_vector()
sparse_vec.extend([
    dlib.pair(0, 1.5),
    dlib.pair(5, 2.3), 
    dlib.pair(10, -0.8)
])

# Clean up sparse vector
clean_vec = dlib.make_sparse_vector(sparse_vec)

Install with Tessl CLI