Principles and Python Implementation of Linear Number Range Mapping Algorithm

Algorithm Principles and Mathematical Foundation

Linear number range mapping is a fundamental numerical transformation technique that scales values from a source range to a target range while preserving proportional relationships. This transformation adapts numerical values to different scales while maintaining their relative positions.

The core mapping formula can be expressed as:

NewValue = (((OldValue - OldMin) * (NewMax - NewMin)) / (OldMax - OldMin)) + NewMin

For improved code readability, the formula can be decomposed into multiple steps:

OldRange = (OldMax - OldMin)
NewRange = (NewMax - NewMin)
NewValue = (((OldValue - OldMin) * NewRange) / OldRange) + NewMin

Boundary Conditions and Exception Handling

In practical applications, special consideration must be given to the case where the source range is zero. When OldMin equals OldMax, the source range becomes zero, requiring special handling to avoid division by zero errors.

A complete algorithm implementation should include boundary checking:

OldRange = (OldMax - OldMin)
if (OldRange == 0)
    NewValue = NewMin
else
{
    NewRange = (NewMax - NewMin)
    NewValue = (((OldValue - OldMin) * NewRange) / OldRange) + NewMin
}

When the source range is zero, the algorithm defaults to setting the target value to NewMin. Depending on specific application requirements, alternative default values such as NewMax or (NewMin + NewMax) / 2 may be more appropriate.

Python Implementation and Code Analysis

Based on the algorithm principles, we can implement a generic Python function:

def linear_map(value, old_min, old_max, new_min, new_max):
    """
    Linearly map a value from source range to target range
    
    Parameters:
    value: The value to be transformed
    old_min: Minimum value of source range
    old_max: Maximum value of source range
    new_min: Minimum value of target range
    new_max: Maximum value of target range
    
    Returns:
    The mapped value in target range
    """
    old_range = old_max - old_min
    
    # Handle zero source range case
    if old_range == 0:
        return new_min
    
    new_range = new_max - new_min
    normalized_value = (value - old_min) / old_range
    return normalized_value * new_range + new_min

This implementation employs clear step decomposition: first calculating the source range, then handling boundary conditions, followed by normalization computation, and finally completing the linear mapping. This approach enhances code readability and facilitates debugging and maintenance.

Practical Application Scenarios

Number range mapping technology finds extensive applications across multiple domains:

Image Processing: As mentioned in the original problem, mapping image pixel values from [-16000.00, 16000.00] to integer range [0, 100]. This transformation can be used for data compression, visualization, or standardization.

# Image data mapping example
image_values = [-12000.5, 8000.25, -500.75, 15000.0]
mapped_values = [linear_map(val, -16000.0, 16000.0, 0, 100) for val in image_values]
print(f"Original values: {image_values}")
print(f"Mapped values: {mapped_values}")

Sensor Data Processing: Mapping raw sensor readings to standardized ranges for comparative analysis and data fusion from different sensors.

Data Normalization: In machine learning and data analysis, mapping feature values to uniform ranges to improve model training effectiveness.

Algorithm Characteristics Analysis

The linear mapping algorithm possesses several important characteristics:

Proportional Preservation: Relative positions within the source range are maintained in the target range. If the positional ratio between value1 and value2 remains constant in the source range, this proportional relationship will be preserved in the target range.

Boundary Correspondence: The minimum value of the source range necessarily maps to the minimum value of the target range, and the maximum value of the source range necessarily maps to the maximum value of the target range.

Linearity: The mapping function is linear, satisfying homogeneity and additivity properties. This means numerical changes maintain linear relationships before and after mapping.

Extensions and Optimizations

In practical applications, the basic algorithm can be extended based on specific requirements:

Batch Processing Optimization: For mapping large datasets, vectorized operations using libraries like NumPy can be employed:

import numpy as np

def batch_linear_map(values, old_min, old_max, new_min, new_max):
    """Batch linear mapping function"""
    values = np.array(values)
    old_range = old_max - old_min
    
    if old_range == 0:
        return np.full_like(values, new_min, dtype=float)
    
    new_range = new_max - new_min
    normalized = (values - old_min) / old_range
    return normalized * new_range + new_min

Data Type Handling: Data type conversion can be added based on target range requirements:

def linear_map_with_type(value, old_min, old_max, new_min, new_max, output_type=float):
    """Linear mapping with specified output type"""
    result = linear_map(value, old_min, old_max, new_min, new_max)
    return output_type(result)

Error Handling and Validation

Robust implementations should include input validation and error handling:

def robust_linear_map(value, old_min, old_max, new_min, new_max):
    """Linear mapping function with comprehensive validation"""
    
    # Input validation
    if not (isinstance(value, (int, float)) and 
            isinstance(old_min, (int, float)) and 
            isinstance(old_max, (int, float)) and 
            isinstance(new_min, (int, float)) and 
            isinstance(new_max, (int, float))):
        raise TypeError("All parameters must be numerical types")
    
    if old_min > old_max:
        raise ValueError("Source range minimum cannot be greater than maximum")
    
    if new_min > new_max:
        raise ValueError("Target range minimum cannot be greater than maximum")
    
    # Perform mapping
    return linear_map(value, old_min, old_max, new_min, new_max)

This comprehensive implementation ensures correct behavior under various boundary conditions, providing reliable guarantees for practical applications.

Performance Considerations

The linear mapping algorithm exhibits O(1) time complexity and O(1) space complexity, demonstrating high computational efficiency. This performance advantage becomes particularly significant when processing large datasets.

Through proper implementation and optimization, the linear mapping algorithm can be widely applied in real-time systems, big data processing, embedded devices, and various other computational environments.