Python - Adjacent Coordinates in N dimension

When working with scientific, mathematical, and programming applications, navigating and exploring points in multi-dimensional space is crucial. Whether analyzing data, processing images, or conducting simulations, understanding adjacent coordinates in N-dimensional space becomes indispensable.

N-dimensional space refers to an abstract mathematical space with a variable number of dimensions. Points are represented by coordinates consisting of N values, where each value corresponds to a specific dimension. This concept finds applications in machine learning, physics simulations, and computer graphics.

What are Adjacent Coordinates?

Adjacent coordinates are points that are directly connected to a given point within N-dimensional space. They play a crucial role in computational tasks including breadth-first search algorithms, neighbor-based data analysis, and spatial exploration.

For example, in 2D space, a point at (1,2) has 4 adjacent coordinates: (0,2), (2,2), (1,1), and (1,3). In 3D space, the same concept extends to 6 adjacent coordinates.

Basic Implementation

Python with NumPy provides an efficient way to compute adjacent coordinates. Here's a straightforward implementation ?

import numpy as np

def adjacent_coordinates(point):
    dimensions = len(point)
    adjacent_coords = []
    
    for i in range(dimensions):
        # Create coordinate by incrementing dimension i
        coord_plus = np.copy(point)
        coord_plus[i] += 1
        adjacent_coords.append(coord_plus)
        
        # Create coordinate by decrementing dimension i
        coord_minus = np.copy(point)
        coord_minus[i] -= 1
        adjacent_coords.append(coord_minus)
    
    return adjacent_coords

# Example with 3D point
point = np.array([1, 2, 3])
adjacent_coords = adjacent_coordinates(point)

print("Original point:", point)
print("Adjacent coordinates:")
for i, coord in enumerate(adjacent_coords):
    print(f"  {i+1}: {coord}")

Original point: [1 2 3]
Adjacent coordinates:
  1: [2 2 3]
  2: [0 2 3]
  3: [1 3 3]
  4: [1 1 3]
  5: [1 2 4]
  6: [1 2 2]

Visualizing Adjacent Coordinates

For 2D space, we can visualize adjacent coordinates using Matplotlib ?

import numpy as np
import matplotlib.pyplot as plt

def adjacent_coordinates(point):
    dimensions = len(point)
    adjacent_coords = []
    
    for i in range(dimensions):
        coord_plus = np.copy(point)
        coord_plus[i] += 1
        adjacent_coords.append(coord_plus)
        
        coord_minus = np.copy(point)
        coord_minus[i] -= 1
        adjacent_coords.append(coord_minus)
    
    return adjacent_coords

def plot_adjacent_coordinates(point, adjacent_coords):
    x_coords = [coord[0] for coord in adjacent_coords]
    y_coords = [coord[1] for coord in adjacent_coords]
    
    plt.figure(figsize=(8, 6))
    plt.scatter(x_coords, y_coords, color='blue', s=100, label='Adjacent points')
    plt.scatter(point[0], point[1], color='red', s=150, label='Original point')
    
    # Add grid and labels
    plt.grid(True, alpha=0.3)
    plt.xlabel('X coordinate')
    plt.ylabel('Y coordinate')
    plt.title('Adjacent Coordinates in 2D Space')
    plt.legend()
    plt.axis('equal')
    plt.show()

# Example usage
point_2d = np.array([2, 3])
adjacent_coords_2d = adjacent_coordinates(point_2d)
plot_adjacent_coordinates(point_2d, adjacent_coords_2d)

Performance Considerations

Computing adjacent coordinates in high-dimensional space can become computationally intensive. Here's an optimized version that uses vectorized operations ?

import numpy as np

def adjacent_coordinates_optimized(point):
    """Optimized version using vectorized operations"""
    dimensions = len(point)
    
    # Create identity matrix for direction vectors
    directions = np.eye(dimensions, dtype=int)
    
    # Create both positive and negative directions
    all_directions = np.vstack([directions, -directions])
    
    # Add directions to original point
    adjacent_coords = point + all_directions
    
    return adjacent_coords

# Compare performance with large dimensions
point_10d = np.array([5] * 10)  # 10-dimensional point
adjacent_coords = adjacent_coordinates_optimized(point_10d)

print(f"10D point: {point_10d}")
print(f"Number of adjacent coordinates: {len(adjacent_coords)}")
print("First few adjacent coordinates:")
for i in range(4):
    print(f"  {adjacent_coords[i]}")

10D point: [5 5 5 5 5 5 5 5 5 5]
Number of adjacent coordinates: 20
First few adjacent coordinates:
  [6 5 5 5 5 5 5 5 5 5]
  [5 6 5 5 5 5 5 5 5 5]
  [5 5 6 5 5 5 5 5 5 5]
  [5 5 5 6 5 5 5 5 5 5]

Practical Applications

Grid-Based Pathfinding

Adjacent coordinates are essential in pathfinding algorithms like A* or Dijkstra's algorithm ?

import numpy as np

def get_valid_neighbors(position, grid_shape):
    """Get adjacent coordinates within grid boundaries"""
    neighbors = []
    directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]  # up, down, right, left
    
    for dx, dy in directions:
        new_x, new_y = position[0] + dx, position[1] + dy
        
        # Check if within grid boundaries
        if 0 <= new_x < grid_shape[0] and 0 <= new_y < grid_shape[1]:
            neighbors.append((new_x, new_y))
    
    return neighbors

# Example: 5x5 grid, current position at (2,2)
grid_shape = (5, 5)
current_pos = (2, 2)
valid_neighbors = get_valid_neighbors(current_pos, grid_shape)

print(f"Current position: {current_pos}")
print(f"Valid neighbors: {valid_neighbors}")

Current position: (2, 2)
Valid neighbors: [(2, 3), (2, 1), (3, 2), (1, 2)]

Comparison of Approaches

Conclusion

Adjacent coordinates in N-dimensional space are fundamental for many computational tasks. Python with NumPy provides efficient tools to compute and work with these coordinates, from simple loop-based approaches to optimized vectorized operations.