complex-range 1.0.0__py3-none-any.whl

complex_range/__init__.py

@@ -0,0 +1,25 @@
+"""
+complex-range - Generate ranges of complex numbers.
+
+A Python implementation of the Wolfram Language ComplexRange resource function,
+originally created by Daniele Gregori.
+
+Generates rectangular and linear ranges of complex numbers in the complex plane.
+
+Example usage:
+    >>> from complex_range import complex_range
+    >>> list(complex_range(0, 2+2j))
+    [0j, 1j, 2j, (1+0j), (1+1j), (1+2j), (2+0j), (2+1j), (2+2j)]
+    
+    >>> list(complex_range([0, 1+1j]))  # Linear range
+    [0j, (1+1j)]
+
+Author: Daniele Gregori
+"""
+
+from .core import complex_range, complex_range_iter, ComplexRangeError
+from .farey import farey_sequence
+
+__version__ = "1.0.0"
+__author__ = "Daniele Gregori"
+__all__ = ["complex_range", "complex_range_iter", "ComplexRangeError", "farey_sequence"]

complex_range/core.py

@@ -0,0 +1,549 @@
+"""
+Core implementation of the ComplexRange function.
+
+This module provides the complex_range function which generates ranges of
+complex numbers in either rectangular (grid) or linear (diagonal) patterns.
+
+Author: Daniele Gregori
+"""
+
+from fractions import Fraction
+from typing import List, Tuple, Union, Iterator, Optional, Literal
+from numbers import Number
+
+from .farey import farey_sequence
+
+
+class ComplexRangeError(Exception):
+    """Exception raised for ComplexRange-specific errors."""
+    pass
+
+
+def _farey_range_values(start: float, end: float, order: int) -> List[Union[int, float, Fraction]]:
+    """
+    Generate values for a Farey range.
+    
+    The Farey sequence of the given order is applied to each unit interval
+    in the range, and all points are combined.
+    
+    Parameters
+    ----------
+    start : float
+        Start of the range.
+    end : float
+        End of the range.
+    order : int
+        Order of the Farey sequence to use.
+        
+    Returns
+    -------
+    List
+        Sorted list of values in the range.
+    """
+    if order < 1:
+        raise ComplexRangeError(f"Farey order must be positive, got {order}")
+    
+    # Get the Farey sequence for this order
+    farey = farey_sequence(order)
+    
+    # Determine the number of unit intervals
+    span = end - start
+    num_units = int(span)
+    
+    # If span is not an integer, we need to handle fractional part
+    if span != num_units:
+        # For non-integer spans, just scale the Farey sequence
+        result = sorted(set(float(start + f * span) for f in farey))
+        return result
+    
+    # For integer spans, apply Farey to each unit interval
+    all_values = set()
+    
+    for unit in range(num_units):
+        unit_start = start + unit
+        for f in farey:
+            all_values.add(unit_start + float(f))
+    
+    # Convert to sorted list
+    result = sorted(all_values)
+    
+    # Try to keep as fractions if possible
+    if all(isinstance(x, int) or (isinstance(x, float) and x == int(x)) for x in [start, end]):
+        frac_result = []
+        for val in result:
+            try:
+                frac = Fraction(val).limit_denominator(1000)
+                if abs(float(frac) - val) < 1e-10:
+                    frac_result.append(frac)
+                else:
+                    frac_result.append(val)
+            except (ValueError, OverflowError):
+                frac_result.append(val)
+        return frac_result
+    
+    return result
+
+
+def _to_number(z: Union[complex, float, int, Fraction]) -> Union[complex, Fraction, int, float]:
+    """Convert input to appropriate numeric type, preserving exactness where possible."""
+    if isinstance(z, (int, Fraction)):
+        return z
+    if isinstance(z, float):
+        # Try to convert to Fraction if it's a "nice" number
+        try:
+            frac = Fraction(z).limit_denominator(10000)
+            if abs(float(frac) - z) < 1e-10:
+                return frac
+        except (ValueError, OverflowError):
+            pass
+        return z
+    if isinstance(z, complex):
+        return z
+    return z
+
+
+def _arange_inclusive(start: Union[int, float, Fraction], 
+                      end: Union[int, float, Fraction], 
+                      step: Union[int, float, Fraction]) -> List[Union[int, float, Fraction]]:
+    """
+    Generate a range from start to end (inclusive) with given step.
+    
+    Similar to numpy.arange but includes the endpoint if it's exactly reachable.
+    Handles both positive and negative steps.
+    """
+    if step == 0:
+        raise ComplexRangeError("Step cannot be zero")
+    
+    # Handle mismatched direction (positive step but going down, or negative step but going up)
+    if (step > 0 and start > end) or (step < 0 and start < end):
+        return []
+    
+    result = []
+    current = start
+    
+    # Use Fraction for exact arithmetic when possible
+    if isinstance(start, (int, Fraction)) and isinstance(end, (int, Fraction)) and isinstance(step, (int, Fraction)):
+        start = Fraction(start)
+        end = Fraction(end)
+        step = Fraction(step)
+        current = start
+        
+        if step > 0:
+            while current <= end:
+                result.append(current)
+                current = current + step
+        else:
+            # Negative step: go downward
+            while current >= end:
+                result.append(current)
+                current = current + step
+    else:
+        # Floating point version with tolerance
+        eps = abs(step) * 1e-14
+        if step > 0:
+            while current <= end + eps:
+                result.append(current)
+                current = current + step
+        else:
+            # Negative step: go downward
+            while current >= end - eps:
+                result.append(current)
+                current = current + step
+            
+    return result
+
+
+def _rectangular_range(
+    z1: complex,
+    z2: complex,
+    step: Union[complex, Tuple[Number, Number], None] = None,
+    increment_first: Literal['im', 're'] = 'im',
+    farey_range: bool = False
+) -> List[complex]:
+    """
+    Generate a rectangular grid of complex numbers.
+    
+    Parameters
+    ----------
+    z1 : complex
+        First corner of the rectangle (minimum real and imaginary parts).
+    z2 : complex
+        Second corner of the rectangle (maximum real and imaginary parts).
+    step : complex or tuple, optional
+        Step size. Can be a complex number (real part = real step, imag part = imag step)
+        or a tuple (real_step, imag_step). Default is 1+1j.
+    increment_first : {'im', 're'}
+        Which component to increment first in the iteration. Default is 'im'.
+    farey_range : bool
+        If True, use Farey sequence to generate intermediate points.
+        
+    Returns
+    -------
+    List[complex]
+        List of complex numbers forming a rectangular grid.
+    """
+
+    # Extract real and imaginary bounds
+    re_min = z1.real
+    re_max = z2.real
+    im_min = z1.imag
+    im_max = z2.imag
+    
+    # Determine step sizes
+    if step is None:
+        re_step = 1
+        im_step = 1
+    elif isinstance(step, (list, tuple)):
+        re_step, im_step = step
+    else:
+        # Complex number: real part is real step, imag part is imag step
+        re_step = step.real if hasattr(step, 'real') else step
+        im_step = step.imag if hasattr(step, 'imag') else step
+
+    # Check for reversed range - return empty in case
+    if ((z1.real > z2.real and (re_step > 0)) and (z1.imag > z2.imag and (im_step > 0))): ###
+        return []
+    elif ((z1.real < z2.real and (re_step < 0)) and (z1.imag < z2.imag and (im_step < 0))): ###
+        return []
+
+
+    # Handle Farey range
+    if farey_range:
+        # Farey range requires integer step
+        if not (isinstance(re_step, int) or (isinstance(re_step, float) and re_step.is_integer())):
+            raise ComplexRangeError(
+                f"No Farey range with non-integer third argument {re_step} is allowed."
+            )
+        if not (isinstance(im_step, int) or (isinstance(im_step, float) and im_step.is_integer())):
+            raise ComplexRangeError(
+                f"No Farey range with non-integer third argument {im_step} is allowed."
+            )
+        
+        re_order = int(re_step)
+        im_order = int(im_step)
+        
+        # Generate Farey-based ranges
+        # The Farey sequence is applied to each unit interval, then combined
+        re_values = _farey_range_values(re_min, re_max, re_order)
+        im_values = _farey_range_values(im_min, im_max, im_order)
+    else:
+        # Regular range
+        re_values = _arange_inclusive(re_min, re_max, re_step)
+        im_values = _arange_inclusive(im_min, im_max, im_step)
+    
+    # Handle empty ranges
+    if not re_values or not im_values:
+        return []
+    
+    # Generate the grid
+    result = []
+    if increment_first == 'im':
+        # Increment imaginary first (default): for each real, iterate through imaginaries
+        for re in re_values:
+            for im in im_values:
+                result.append(_make_complex(re, im))
+    else:
+        # Increment real first: for each imaginary, iterate through reals
+        for im in im_values:
+            for re in re_values:
+                result.append(_make_complex(re, im))
+    
+    return result
+
+
+def _make_complex(re: Union[int, float, Fraction], im: Union[int, float, Fraction]) -> complex:
+    """Create a complex number from real and imaginary parts."""
+    # Convert Fractions to float for complex number creation
+    re_val = float(re) if isinstance(re, Fraction) else re
+    im_val = float(im) if isinstance(im, Fraction) else im
+    
+    # Simplify representation
+    if im_val == 0:
+        if isinstance(re_val, float) and re_val.is_integer():
+            return complex(int(re_val), 0)
+        return complex(re_val, 0)
+    if re_val == 0:
+        if isinstance(im_val, float) and im_val.is_integer():
+            return complex(0, int(im_val))
+        return complex(0, im_val)
+    
+    return complex(re_val, im_val)
+
+
+def _linear_range(
+    z1: complex,
+    z2: complex,
+    step: Optional[Union[complex, Tuple[Number, Number]]] = None,
+    farey_range: bool = False
+) -> List[complex]:
+    """
+    Generate a linear (diagonal) range of complex numbers.
+
+    Points lie on a line from z1 to z2, with both real and imaginary
+    components incrementing together.
+
+    Parameters
+    ----------
+    z1 : complex
+        Starting point.
+    z2 : complex
+        Ending point.
+    step : complex or tuple, optional
+        Step sizes. Can be a complex number (real part = real step, imag part = imag step)
+        or a tuple (real_step, imag_step). Default is (1, 1).
+    farey_range : bool
+        If True, use Farey sequence to generate intermediate points.
+
+    Returns
+    -------
+    List[complex]
+        List of complex numbers along the line from z1 to z2.
+    """
+    if step is None:
+        re_step = 1
+        im_step = 1
+    elif isinstance(step, (list, tuple)):
+        re_step, im_step = step
+    elif isinstance(step, complex):
+        re_step = step.real
+        im_step = step.imag
+    else:
+        # Single number: use as both steps
+        re_step = step
+        im_step = step
+
+    # Get component ranges
+    re_start, re_end = z1.real, z2.real
+    im_start, im_end = z1.imag, z2.imag
+
+    # Handle Farey range
+    if farey_range:
+        # Farey range requires integer step
+        if not (isinstance(re_step, int) or (isinstance(re_step, float) and re_step.is_integer())):
+            raise ComplexRangeError(
+                f"No Farey range with non-integer third argument {re_step} is allowed."
+            )
+        if not (isinstance(im_step, int) or (isinstance(im_step, float) and im_step.is_integer())):
+            raise ComplexRangeError(
+                f"No Farey range with non-integer third argument {im_step} is allowed."
+            )
+
+        re_order = int(re_step)
+        im_order = int(im_step)
+
+        # Generate Farey-based ranges
+        re_values = _farey_range_values(re_start, re_end, re_order)
+        im_values = _farey_range_values(im_start, im_end, im_order)
+    else:
+        # Generate ranges for each component
+        re_values = _arange_inclusive(re_start, re_end, re_step)
+        im_values = _arange_inclusive(im_start, im_end, im_step)
+
+    # For linear range, we need to pair up values
+    # Take the minimum length (they should increment together)
+    n = min(len(re_values), len(im_values))
+
+    if n == 0:
+        return []
+
+    return [_make_complex(re_values[i], im_values[i]) for i in range(n)]
+
+
+def complex_range(
+    z1: Union[complex, float, int, List, Tuple],
+    z2: Optional[Union[complex, float, int]] = None,
+    step: Optional[Union[complex, float, int, List, Tuple]] = None,
+    *,
+    increment_first: Literal['im', 're'] = 'im',
+    farey_range: bool = False
+) -> List[complex]:
+    """
+    Generate a range of complex numbers.
+    
+    This function can generate either rectangular (grid) or linear (diagonal)
+    ranges of complex numbers in the complex plane.
+    
+    Parameters
+    ----------
+    z1 : complex, number, or list
+        For rectangular range: the first corner (or single endpoint if z2 is None).
+        For linear range: a list [z] or [z_start, z_end] specifying endpoints.
+    z2 : complex or number, optional
+        For rectangular range: the second corner.
+    step : complex, number, list, or tuple, optional
+        Step size(s) for the range.
+        - For rectangular range with complex step: real part = real step, imag = imag step
+        - For rectangular/linear range with list/tuple: [real_step, imag_step]
+        Default step is 1+1j for rectangular, (1, 1) for linear.
+    increment_first : {'im', 're'}, keyword-only
+        For rectangular range: which component to increment first.
+        'im' (default): increment imaginary first (column-major order)
+        're': increment real first (row-major order)
+    farey_range : bool, keyword-only
+        If True, use Farey sequence to generate intermediate points.
+        Only valid for rectangular ranges with integer step.
+        Creates a finer grid based on the Farey sequence of the given order.
+        
+    Returns
+    -------
+    List[complex]
+        A list of complex numbers.
+        
+    Raises
+    ------
+    ComplexRangeError
+        If farey_range is True but step is non-integer.
+        
+    Examples
+    --------
+    Rectangular range from origin:
+    
+    >>> complex_range(2+2j)
+    [(0+0j), 1j, 2j, (1+0j), (1+1j), (1+2j), (2+0j), (2+1j), (2+2j)]
+    
+    Rectangular range between two points:
+    
+    >>> complex_range(1+1j, 2+2j)
+    [(1+1j), (1+2j), (2+1j), (2+2j)]
+    
+    Rectangular range with step:
+    
+    >>> complex_range(0, 2+2j, 0.5+0.5j)
+    [(0+0j), 0.5j, 1j, 1.5j, 2j, (0.5+0j), ...]
+    
+    Linear range (points on a diagonal):
+    
+    >>> complex_range([0, 2+2j])
+    [(0+0j), (1+1j), (2+2j)]
+    
+    Linear range with step:
+    
+    >>> complex_range([0, 4+4j], (2, 2))
+    [(0+0j), (2+2j), (4+4j)]
+    
+    Linear range with complex step:
+    
+    >>> complex_range([0, 4+4j], 2+2j)
+    [(0+0j), (2+2j), (4+4j)]
+    
+    Descending linear range:
+    
+    >>> complex_range([2+2j, 0], -1-1j)
+    [(2+2j), (1+1j), 0j]
+    
+    Rectangular range with Farey subdivision:
+    
+    >>> complex_range(0, 1+1j, 2, farey_range=True)
+    [(0+0j), 0.5j, 1j, (0.5+0j), (0.5+0.5j), (0.5+1j), (1+0j), (1+0.5j), (1+1j)]
+    
+    See Also
+    --------
+    farey_sequence : Generate Farey sequence of a given order.
+    
+    Notes
+    -----
+    The function distinguishes between rectangular and linear ranges based on
+    the type of the first argument:
+    
+    - If z1 is a list or tuple, a linear range is generated
+    - Otherwise, a rectangular range is generated
+    
+    For rectangular ranges, the default iteration order is "imaginary first",
+    meaning for each real value, all imaginary values are enumerated before
+    moving to the next real value.
+    
+    Author: Daniele Gregori
+    """
+    # Check if this is a linear range (first argument is a list/tuple)
+    if isinstance(z1, (list, tuple)):
+        return _handle_linear_range(z1, z2, step, farey_range)
+
+    # Rectangular range
+    return _handle_rectangular_range(z1, z2, step, increment_first, farey_range)
+
+
+def _handle_linear_range(
+    z_spec: Union[List, Tuple],
+    step_or_none: Optional[Union[complex, float, int, List, Tuple]],
+    step: Optional[Union[complex, float, int, List, Tuple]],
+    farey_range: bool = False
+) -> List[complex]:
+    """Handle linear range cases."""
+    # Parse the specification
+    if len(z_spec) == 1:
+        # {z} - linear from 0 to z
+        z_start = complex(0, 0)
+        z_end = complex(z_spec[0])
+    elif len(z_spec) == 2:
+        # {z1, z2} - linear from z1 to z2
+        z_start = complex(z_spec[0])
+        z_end = complex(z_spec[1])
+    else:
+        raise ComplexRangeError(f"Linear range specification must have 1 or 2 elements, got {len(z_spec)}")
+
+    # Determine step (step_or_none is actually the step for linear ranges)
+    if step_or_none is not None:
+        if isinstance(step_or_none, (list, tuple)):
+            linear_step = tuple(step_or_none)
+        elif isinstance(step_or_none, complex):
+            # Pass complex step directly - _linear_range will handle it
+            linear_step = step_or_none
+        else:
+            raise ComplexRangeError(f"Invalid step specification: {step_or_none}")
+    else:
+        linear_step = None
+
+    return _linear_range(z_start, z_end, linear_step, farey_range)
+
+
+def _handle_rectangular_range(
+    z1: Union[complex, float, int],
+    z2: Optional[Union[complex, float, int]],
+    step: Optional[Union[complex, float, int, List, Tuple]],
+    increment_first: Literal['im', 're'],
+    farey_range: bool
+) -> List[complex]:
+    """Handle rectangular range cases."""
+    # Convert to complex
+    z1_complex = complex(z1)
+    
+    if z2 is None:
+        # Single argument: range from 0 to z1
+        z2_complex = z1_complex
+        z1_complex = complex(0, 0)
+    else:
+        z2_complex = complex(z2)
+    
+    # Handle step
+    if step is not None:
+        if isinstance(step, (list, tuple)):
+            step_tuple = tuple(step)
+        else:
+            step_val = complex(step) if not isinstance(step, complex) else step
+            step_tuple = step_val
+    else:
+        step_tuple = None
+    
+    return _rectangular_range(z1_complex, z2_complex, step_tuple, increment_first, farey_range)
+
+
+# Convenience function for iterator version
+def complex_range_iter(
+    z1: Union[complex, float, int, List, Tuple],
+    z2: Optional[Union[complex, float, int]] = None,
+    step: Optional[Union[complex, float, int, List, Tuple]] = None,
+    *,
+    increment_first: Literal['im', 're'] = 'im',
+    farey_range: bool = False
+) -> Iterator[complex]:
+    """
+    Iterator version of complex_range.
+    
+    Same as complex_range but returns an iterator instead of a list.
+    Useful for memory efficiency with large ranges.
+    
+    See complex_range for full documentation.
+    
+    Author: Daniele Gregori
+    """
+    return iter(complex_range(z1, z2, step, increment_first=increment_first, farey_range=farey_range))

complex_range/dev.py

@@ -0,0 +1,41 @@
+"""
+Development/testing utilities for complex-range.
+
+This module exposes internal functions for interactive testing and debugging.
+Import with: from complex_range.dev import *
+
+Author: Daniele Gregori
+"""
+
+from .core import (
+    complex_range,
+    complex_range_iter,
+    ComplexRangeError,
+    _rectangular_range,
+    _linear_range,
+    _arange_inclusive,
+    _make_complex,
+    _farey_range_values,
+    _handle_linear_range,
+    _handle_rectangular_range,
+    _to_number,
+)
+from .farey import farey_sequence, scaled_farey_sequence
+
+__all__ = [
+    # Public API
+    "complex_range",
+    "complex_range_iter",
+    "ComplexRangeError",
+    "farey_sequence",
+    # Internal functions (for testing)
+    "_rectangular_range",
+    "_linear_range", 
+    "_arange_inclusive",
+    "_make_complex",
+    "_farey_range_values",
+    "_handle_linear_range",
+    "_handle_rectangular_range",
+    "_to_number",
+    "scaled_farey_sequence",
+]

complex_range/farey.py

@@ -0,0 +1,84 @@
+"""
+Farey sequence implementation for complex-range.
+
+The Farey sequence F_n is the sequence of completely reduced fractions,
+between 0 and 1, which have denominators less than or equal to n,
+arranged in order of increasing size.
+
+Author: Daniele Gregori
+"""
+
+from fractions import Fraction
+from typing import List
+
+
+def farey_sequence(n: int) -> List[Fraction]:
+    """
+    Generate the Farey sequence of order n.
+    
+    The Farey sequence F_n is the sequence of completely reduced fractions
+    between 0 and 1, with denominators less than or equal to n, arranged
+    in increasing order.
+    
+    Parameters
+    ----------
+    n : int
+        The order of the Farey sequence. Must be a positive integer.
+        
+    Returns
+    -------
+    List[Fraction]
+        A list of Fraction objects representing the Farey sequence.
+        
+    Raises
+    ------
+    ValueError
+        If n is not a positive integer.
+        
+    Examples
+    --------
+    >>> farey_sequence(1)
+    [Fraction(0, 1), Fraction(1, 1)]
+    
+    >>> farey_sequence(3)
+    [Fraction(0, 1), Fraction(1, 3), Fraction(1, 2), Fraction(2, 3), Fraction(1, 1)]
+    
+    >>> farey_sequence(5)
+    [Fraction(0, 1), Fraction(1, 5), Fraction(1, 4), Fraction(1, 3), 
+     Fraction(2, 5), Fraction(1, 2), Fraction(3, 5), Fraction(2, 3), 
+     Fraction(3, 4), Fraction(4, 5), Fraction(1, 1)]
+    """
+    if not isinstance(n, int) or n < 1:
+        raise ValueError(f"Order n must be a positive integer, got {n}")
+    
+    # Generate all fractions with denominator <= n
+    fractions_set = set()
+    for denom in range(1, n + 1):
+        for numer in range(0, denom + 1):
+            fractions_set.add(Fraction(numer, denom))
+    
+    # Sort and return
+    return sorted(fractions_set)
+
+
+def scaled_farey_sequence(n: int, start: float, end: float) -> List[Fraction]:
+    """
+    Generate a scaled Farey sequence between start and end.
+    
+    Parameters
+    ----------
+    n : int
+        The order of the Farey sequence.
+    start : float
+        The starting value.
+    end : float
+        The ending value.
+        
+    Returns
+    -------
+    List[Fraction]
+        Farey sequence scaled to [start, end] interval.
+    """
+    farey = farey_sequence(n)
+    span = end - start
+    return [Fraction(start) + f * Fraction(span) for f in farey]

complex_range-1.0.0.dist-info/METADATA

@@ -0,0 +1,330 @@
+Metadata-Version: 2.4
+Name: complex-range
+Version: 1.0.0
+Summary: Generate ranges of complex numbers - rectangular grids and linear sequences in the complex plane
+Author-email: Daniele Gregori <dangregori@gmail.com>
+Maintainer-email: Daniele Gregori <dangregori@gmail.com>
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/complex-range
+Project-URL: Documentation, https://resources.wolframcloud.com/FunctionRepository/resources/ComplexRange/
+Project-URL: Repository, https://github.com/Daniele-Gregori/PyPI-packages
+Project-URL: Issues, https://github.com/Daniele-Gregori/PyPI-packages/issues
+Project-URL: Changelog, https://github.com/Daniele-Gregori/PyPI-packages/blob/main/CHANGELOG.md
+Keywords: complex,numbers,range,grid,mathematics,farey,sequence,complex-plane
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: isort>=5.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: flake8>=6.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=6.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == "docs"
+Dynamic: license-file
+
+# complex-range
+
+[![PyPI version](https://badge.fury.io/py/complex-range.svg)](https://badge.fury.io/py/complex-range)
+[![Python versions](https://img.shields.io/pypi/pyversions/complex-range.svg)](https://pypi.org/project/complex-range/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+Generate ranges of complex numbers in Python - rectangular grids and linear sequences in the complex plane.
+
+
+## Installation
+
+```bash
+pip install complex-range
+```
+
+## Quick Start
+
+```python
+from complex_range import complex_range
+
+# Rectangular grid from origin to 2+2j
+grid = complex_range(0, 2+2j)
+# [0j, 1j, 2j, (1+0j), (1+1j), (1+2j), (2+0j), (2+1j), (2+2j)]
+
+# Linear range along a diagonal
+line = complex_range([0, 3+3j])
+# [0j, (1+1j), (2+2j), (3+3j)]
+```
+
+## Features
+
+- **Rectangular ranges**: Generate 2D grids of complex numbers
+- **Linear ranges**: Generate points along a line in the complex plane
+- **Flexible step sizes**: Control spacing independently for real and imaginary axes
+- **Negative steps**: Support for descending ranges with negative step values
+- **Farey sequence subdivision**: Create refined grids using number-theoretic sequences
+- **Iteration order control**: Choose whether to iterate real or imaginary component first
+- **Pure Python**: No dependencies required
+
+## Usage
+
+### Rectangular Ranges
+
+Generate a grid of complex numbers between two corners:
+
+```python
+from complex_range import complex_range
+
+# Basic rectangular range
+complex_range(0, 2+2j)
+# Returns: [0j, 1j, 2j, (1+0j), (1+1j), (1+2j), (2+0j), (2+1j), (2+2j)]
+
+# Single argument: range from 0 to z
+complex_range(2+3j)
+# Returns grid from 0 to 2+3j (3×4 = 12 points)
+
+# With custom step size (complex number)
+complex_range(0, 2+2j, 0.5+0.5j)
+# Real step = 0.5, Imaginary step = 0.5
+
+# With separate real and imaginary steps
+complex_range(0, 4+6j, [2, 3])
+# Real step = 2, Imaginary step = 3
+```
+
+### Linear Ranges
+
+Generate points along a line (diagonal) in the complex plane:
+
+```python
+# Linear from 0 to endpoint
+complex_range([3+3j])
+# Returns: [0j, (1+1j), (2+2j), (3+3j)]
+
+# Linear between two points
+complex_range([-1-1j, 2+2j])
+# Returns: [(-1-1j), 0j, (1+1j), (2+2j)]
+
+# Linear with custom step
+complex_range([0, 4+4j], [2, 2])
+# Returns: [0j, (2+2j), (4+4j)]
+
+# Linear with complex step
+complex_range([0, 4+4j], 2+2j)
+# Returns: [0j, (2+2j), (4+4j)]
+
+# Descending linear range with negative step
+complex_range([2+2j, 0], -1-1j)
+# Returns: [(2+2j), (1+1j), 0j]
+```
+
+### Options
+
+#### `increment_first`
+
+Control the iteration order for rectangular ranges:
+
+```python
+# Default: increment imaginary first
+complex_range(0, 2+2j, 1+1j, increment_first='im')
+# [0j, 1j, 2j, (1+0j), (1+1j), (1+2j), (2+0j), (2+1j), (2+2j)]
+
+# Increment real first
+complex_range(0, 2+2j, 1+1j, increment_first='re')
+# [0j, (1+0j), (2+0j), 1j, (1+1j), (2+1j), 2j, (1+2j), (2+2j)]
+```
+
+#### `farey_range`
+
+Use Farey sequence to create a finer subdivision of the grid:
+
+```python
+# Regular grid
+regular = complex_range(0, 4+4j, 2+2j)
+# Returns 9 points
+
+# Farey subdivision (step must be integer)
+farey = complex_range(0, 4+4j, 2+2j, farey_range=True)
+# Returns 81 points using Farey sequence F_2
+
+# Farey sequence of order n creates fractions 0, 1/n, ..., 1
+from complex_range import farey_sequence
+farey_sequence(3)
+# [Fraction(0,1), Fraction(1,3), Fraction(1,2), Fraction(2,3), Fraction(1,1)]
+```
+
+## API Reference
+
+### `complex_range(z1, z2=None, step=None, *, increment_first='im', farey_range=False)`
+
+Generate a range of complex numbers.
+
+**Parameters:**
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `z1` | `complex`, `list`, or `tuple` | First corner (rectangular) or endpoint specification (linear) |
+| `z2` | `complex`, optional | Second corner for rectangular range |
+| `step` | `complex`, `list`, or `tuple`, optional | Step size(s). Default: `1+1j` |
+| `increment_first` | `'im'` or `'re'` | Which component to iterate first. Default: `'im'` |
+| `farey_range` | `bool` | Use Farey sequence subdivision. Default: `False` |
+
+**Returns:** `List[complex]` - List of complex numbers
+
+**Raises:** `ComplexRangeError` - If `farey_range=True` with non-integer step
+
+### `farey_sequence(n)`
+
+Generate the Farey sequence of order n.
+
+**Parameters:**
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `n` | `int` | Order of the Farey sequence (must be positive) |
+
+**Returns:** `List[Fraction]` - Sorted list of fractions in [0, 1]
+
+## Understanding the Ranges
+
+### Rectangular Range
+
+A rectangular range generates all points on a 2D grid:
+
+```
+Im ↑
+ 3 │  ·  ·  ·
+ 2 │  ·  ·  ·
+ 1 │  ·  ·  ·
+ 0 │  ·  ·  ·
+   └──────────→ Re
+      0  1  2
+```
+
+With `increment_first='im'` (default), points are generated column by column:
+`(0,0), (0,1), (0,2), (0,3), (1,0), (1,1), ...`
+
+### Linear Range
+
+A linear range generates points along a diagonal:
+
+```
+Im ↑
+ 3 │        ·
+ 2 │     ·
+ 1 │  ·
+ 0 │·
+   └──────────→ Re
+   0  1  2  3
+```
+
+Points increment along both axes simultaneously.
+
+## Examples
+
+### Visualizing a Rectangular Grid
+
+```python
+import matplotlib.pyplot as plt
+from complex_range import complex_range
+
+points = complex_range(0, 3+3j)
+x = [p.real for p in points]
+y = [p.imag for p in points]
+
+plt.scatter(x, y)
+plt.xlabel('Real')
+plt.ylabel('Imaginary')
+plt.title('Rectangular Complex Range')
+plt.grid(True)
+plt.show()
+```
+
+### Creating a Refined Grid with Farey Sequence
+
+```python
+from complex_range import complex_range
+
+# Coarse grid: 3×3 = 9 points
+coarse = complex_range(0, 2+2j, 1+1j)
+
+# Refined grid using Farey sequence
+refined = complex_range(0, 2+2j, 2+2j, farey_range=True)
+print(f"Coarse: {len(coarse)} points, Refined: {len(refined)} points")
+```
+
+### Iterating Over Complex Regions
+
+```python
+from complex_range import complex_range
+
+# Evaluate a function over a region of the complex plane
+def mandelbrot_escape(c, max_iter=100):
+    z = 0
+    for i in range(max_iter):
+        z = z*z + c
+        if abs(z) > 2:
+            return i
+    return max_iter
+
+# Create a grid and evaluate
+grid = complex_range(-2-1.5j, 1+1.5j, [0.1, 0.1])
+escapes = [mandelbrot_escape(c) for c in grid]
+```
+
+## Author
+
+**Daniele Gregori**
+
+- Original [Wolfram Language ComplexRange](https://resources.wolframcloud.com/FunctionRepository/resources/ComplexRange/) function
+- Python implementation
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+```bash
+# Clone the repository
+git clone https://github.com/Daniele-Gregori/PyPI-packages.git
+cd PyPI-packages/packages/complex-range
+
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run type checking
+mypy src/complex_range
+
+# Format code
+black src tests
+isort src tests
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+Original [Wolfram Language ComplexRange](https://resources.wolframcloud.com/FunctionRepository/resources/ComplexRange/) resource function contributed by Daniele Gregori and reviewed by the Wolfram Review Team.
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a list of changes.

complex_range-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+complex_range/__init__.py,sha256=hZC54Rv4f2Zvha7IDM-DngPqqwDYFugErkzGSLir7-Y,779
+complex_range/core.py,sha256=pgq185F5KX3hjju7k4bGJoeMegarncoAHx2-Y20wd-Y,18196
+complex_range/dev.py,sha256=I2uaDDWVMJoDfdRPZin-0XTKElRz3ianknT_7oOrPws,929
+complex_range/farey.py,sha256=xDcZSJi1h2vMtghkP8TbaEc2dqHbGc4_C7UaD1H6qS0,2305
+complex_range/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+complex_range-1.0.0.dist-info/licenses/LICENSE,sha256=S2_QCHbwpFs9uShfKzzbIYGKLwPhrlcUUVZnpieCdDU,1072
+complex_range-1.0.0.dist-info/METADATA,sha256=zcL9a78XhglVg2qIR1emviUJr7h8ey1tJFxtM-Kh-b4,9311
+complex_range-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+complex_range-1.0.0.dist-info/top_level.txt,sha256=AjyB3ZnFm0s9ReE4FvZzVKfwOJ62TI7NU_ieImIlutk,14
+complex_range-1.0.0.dist-info/RECORD,,

complex_range-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

complex_range-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Daniele Gregori
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

complex_range-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+complex_range