Hooke’s Law Calculator

import math
from typing import Union, Optional

class HookesLawCalculator:
    """
    A comprehensive calculator for Hooke's Law calculations with unit conversions.
    Handles force, spring constant, and displacement calculations with various units.
    """

    # Unit conversion factors relative to base units (N, N/m, m)
    FORCE_UNITS = {
        'N': 1.0,              # Newtons (base unit)
        'dyn': 1e-5,           # Dynes
        'kgf': 9.80665,        # Kilogram-force
        'lbf': 4.448222,       # Pound-force
        'ozf': 0.2780139,      # Ounce-force
        'pdl': 0.138255        # Poundals
    }

    SPRING_CONSTANT_UNITS = {
        'N/m': 1.0,            # Newtons per meter (base unit)
        'lb/ft': 14.5939,      # Pounds per foot
        'lb/in': 175.127,      # Pounds per inch
        'gf/m': 0.00980665,    # Grams-force per meter
        'kgf/m': 9.80665       # Kilograms-force per meter
    }

    DISPLACEMENT_UNITS = {
        'm': 1.0,              # Meters (base unit)
        'cm': 0.01,            # Centimeters
        'mm': 0.001,           # Millimeters
        'in': 0.0254,          # Inches
        'ft': 0.3048,          # Feet
        'mi': 1609.344         # Miles
    }

    def calculate(self, solve_for: str,
                 force: Optional[tuple[float, str]] = None,
                 spring_constant: Optional[tuple[float, str]] = None,
                 displacement: Optional[tuple[float, str]] = None) -> tuple[float, str]:
        """
        Calculate force, spring constant, or displacement using Hooke's Law.

        Parameters:
            solve_for (str): What to solve for ('force', 'spring_constant', or 'displacement')
            force (tuple[float, str]): Force value and unit (e.g., (10, 'N'))
            spring_constant (tuple[float, str]): Spring constant value and unit (e.g., (100, 'N/m'))
            displacement (tuple[float, str]): Displacement value and unit (e.g., (0.1, 'm'))

        Returns:
            tuple[float, str]: Calculated value and its unit

        Raises:
            ValueError: If inputs are invalid or missing required parameters
        """
        # Convert inputs to base units if provided
        f_base = self._convert_force(*force) if force else None
        k_base = self._convert_spring_constant(*spring_constant) if spring_constant else None
        x_base = self._convert_displacement(*displacement) if displacement else None

        # Calculate based on what we're solving for
        if solve_for == 'force':
            if k_base is None or x_base is None:
                raise ValueError("Spring constant and displacement required to calculate force")
            result = -k_base * x_base
            return self._convert_force_from_base(result, force[1] if force else 'N')

        elif solve_for == 'spring_constant':
            if f_base is None or x_base is None:
                raise ValueError("Force and displacement required to calculate spring constant")
            result = -f_base / x_base
            return self._convert_spring_constant_from_base(result,
                   spring_constant[1] if spring_constant else 'N/m')

        elif solve_for == 'displacement':
            if f_base is None or k_base is None:
                raise ValueError("Force and spring constant required to calculate displacement")
            result = -f_base / k_base
            return self._convert_displacement_from_base(result,
                   displacement[1] if displacement else 'm')

        else:
            raise ValueError("Invalid solve_for parameter. Must be 'force', 'spring_constant', "
                           "or 'displacement'")

    def _convert_force(self, value: float, unit: str) -> float:
        """Convert force to base units (Newtons)"""
        if unit not in self.FORCE_UNITS:
            raise ValueError(f"Unsupported force unit: {unit}")
        return value * self.FORCE_UNITS[unit]

    def _convert_spring_constant(self, value: float, unit: str) -> float:
        """Convert spring constant to base units (N/m)"""
        if unit not in self.SPRING_CONSTANT_UNITS:
            raise ValueError(f"Unsupported spring constant unit: {unit}")
        return value * self.SPRING_CONSTANT_UNITS[unit]

    def _convert_displacement(self, value: float, unit: str) -> float:
        """Convert displacement to base units (meters)"""
        if unit not in self.DISPLACEMENT_UNITS:
            raise ValueError(f"Unsupported displacement unit: {unit}")
        return value * self.DISPLACEMENT_UNITS[unit]

    def _convert_force_from_base(self, value: float, unit: str) -> tuple[float, str]:
        """Convert force from Newtons to desired unit"""
        return (value / self.FORCE_UNITS[unit], unit)

    def _convert_spring_constant_from_base(self, value: float, unit: str) -> tuple[float, str]:
        """Convert spring constant from N/m to desired unit"""
        return (value / self.SPRING_CONSTANT_UNITS[unit], unit)

    def _convert_displacement_from_base(self, value: float, unit: str) -> tuple[float, str]:
        """Convert displacement from meters to desired unit"""
        return (value / self.DISPLACEMENT_UNITS[unit], unit)

# Create calculator instance
calculator = HookesLawCalculator()

# Example 1: Calculate force when spring is stretched
k = (100, 'N/m')    # Spring constant of 100 N/m
x = (0.05, 'm')     # Displacement of 5 cm
force = calculator.calculate(solve_for='force', spring_constant=k, displacement=x)
print(f"Force: {force[0]:.2f} {force[1]}")

# Example 2: Calculate spring constant from force and displacement
f = (25, 'N')       # Force of 25 Newtons
x = (10, 'cm')      # Displacement of 10 centimeters
k = calculator.calculate(solve_for='spring_constant', force=f, displacement=x)
print(f"Spring Constant: {k[0]:.2f} {k[1]}")

# Example 3: Calculate displacement using different units
f = (2, 'lbf')      # Force of 2 pound-force
k = (15, 'lb/in')   # Spring constant of 15 pounds per inch
x = calculator.calculate(solve_for='displacement', force=f, spring_constant=k)
print(f"Displacement: {x[0]:.3f} {x[1]}")