qnty 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

qnty/__init__.py

@@ -1,3 +1,172 @@
-from .variables import Dimensionless, Length, Pressure
+"""
+Qnty - High-Performance Unit System for Engineering
+====================================================
+
+A fast, type-safe unit system library for Python with dimensional safety
+and optimized unit conversions for engineering calculations.
+"""
+
+from .dimension import BaseDimension, DimensionSignature
+from .equation import Equation
+from .expression import Expression
+from .unit import registry
+from .units import register_all_units
+from .variable import FastQuantity, TypeSafeSetter, TypeSafeVariable
+from .variables import (
+    AbsorbedDose,
+    Acceleration,
+    ActivationEnergy,
+    AmountOfSubstance,
+    AnglePlane,
+    AngleSolid,
+    AngularAcceleration,
+    AngularMomentum,
+    Area,
+    AreaPerUnitVolume,
+    AtomicWeight,
+    Concentration,
+    DynamicFluidity,
+    ElectricCapacitance,
+    ElectricCharge,
+    ElectricCurrentIntensity,
+    ElectricDipoleMoment,
+    ElectricFieldStrength,
+    ElectricInductance,
+    ElectricPotential,
+    ElectricResistance,
+    ElectricalConductance,
+    ElectricalPermittivity,
+    ElectricalResistivity,
+    EnergyFlux,
+    EnergyHeatWork,
+    EnergyPerUnitArea,
+    Force,
+    ForceBody,
+    ForcePerUnitMass,
+    FrequencyVoltageRatio,
+    FuelConsumption,
+    HeatOfCombustion,
+    HeatOfFusion,
+    HeatOfVaporization,
+    HeatTransferCoefficient,
+    Illuminance,
+    KineticEnergyOfTurbulence,
+    Length,
+    LinearMassDensity,
+    LinearMomentum,
+    LuminanceSelf,
+    LuminousFlux,
+    LuminousIntensity,
+    MagneticField,
+    MagneticFlux,
+    MagneticInductionFieldStrength,
+    MagneticMoment,
+    MagneticPermeability,
+    MagnetomotiveForce,
+    Mass,
+    MassDensity,
+    MassFlowRate,
+    MassFlux,
+    MassFractionOfI,
+    MassTransferCoefficient,
+    MolalityOfSoluteI,
+    MolarConcentrationByMass,
+    MolarFlowRate,
+    MolarFlux,
+    MolarHeatCapacity,
+    MolarityOfI,
+    MoleFractionOfI,
+    MomentOfInertia,
+    MomentumFlowRate,
+    MomentumFlux,
+    NormalityOfSolution,
+    ParticleDensity,
+    Permeability,
+    PhotonEmissionRate,
+    PowerPerUnitMass,
+    PowerPerUnitVolume,
+    PowerThermalDuty,
+    Pressure,
+    RadiationDoseEquivalent,
+    RadiationExposure,
+    Radioactivity,
+    SecondMomentOfArea,
+    SecondRadiationConstantPlanck,
+    SpecificEnthalpy,
+    SpecificGravity,
+    SpecificHeatCapacityConstantPressure,
+    SpecificLength,
+    SpecificSurface,
+    SpecificVolume,
+    Stress,
+    SurfaceMassDensity,
+    SurfaceTension,
+    Temperature,
+    ThermalConductivity,
+    Time,
+    Torque,
+    TurbulenceEnergyDissipationRate,
+    VelocityAngular,
+    VelocityLinear,
+    ViscosityDynamic,
+    ViscosityKinematic,
+    Volume,
+    VolumeFractionOfI,
+    VolumetricCalorificHeatingValue,
+    VolumetricCoefficientOfExpansion,
+    VolumetricFlowRate,
+    VolumetricFlux,
+    VolumetricMassFlowRate,
+    Wavenumber
+)
+
+# Register all units to the global registry
+register_all_units(registry)
+
+# Finalize registry after all registrations
+registry.finalize_registration()
+
+# Define public API
+__all__ = [
+    # Core variable types (most commonly used)
+    "Length", "Pressure", "Temperature", "Time", "Mass", "Volume", "Area",
+    "Force", "EnergyHeatWork", "PowerThermalDuty",
+
+    # Core classes for advanced usage
+    "FastQuantity", "TypeSafeVariable", "TypeSafeSetter",
+    "DimensionSignature", "BaseDimension",
+    "Expression", "Equation",
+
+    # All other variable types (95 additional types)
+    "AbsorbedDose", "Acceleration", "ActivationEnergy", "AmountOfSubstance",
+    "AnglePlane", "AngleSolid", "AngularAcceleration", "AngularMomentum",
+    "AreaPerUnitVolume", "AtomicWeight", "Concentration", "DynamicFluidity",
+    "ElectricCapacitance", "ElectricCharge", "ElectricCurrentIntensity",
+    "ElectricDipoleMoment", "ElectricFieldStrength", "ElectricInductance",
+    "ElectricPotential", "ElectricResistance", "ElectricalConductance",
+    "ElectricalPermittivity", "ElectricalResistivity", "EnergyFlux",
+    "EnergyPerUnitArea", "ForceBody", "ForcePerUnitMass",
+    "FrequencyVoltageRatio", "FuelConsumption", "HeatOfCombustion",
+    "HeatOfFusion", "HeatOfVaporization", "HeatTransferCoefficient",
+    "Illuminance", "KineticEnergyOfTurbulence", "LinearMassDensity",
+    "LinearMomentum", "LuminanceSelf", "LuminousFlux", "LuminousIntensity",
+    "MagneticField", "MagneticFlux", "MagneticInductionFieldStrength",
+    "MagneticMoment", "MagneticPermeability", "MagnetomotiveForce",
+    "MassDensity", "MassFlowRate", "MassFlux", "MassFractionOfI",
+    "MassTransferCoefficient", "MolalityOfSoluteI", "MolarConcentrationByMass",
+    "MolarFlowRate", "MolarFlux", "MolarHeatCapacity", "MolarityOfI",
+    "MoleFractionOfI", "MomentOfInertia", "MomentumFlowRate", "MomentumFlux",
+    "NormalityOfSolution", "ParticleDensity", "Permeability",
+    "PhotonEmissionRate", "PowerPerUnitMass", "PowerPerUnitVolume",
+    "RadiationDoseEquivalent", "RadiationExposure", "Radioactivity",
+    "SecondMomentOfArea", "SecondRadiationConstantPlanck", "SpecificEnthalpy",
+    "SpecificGravity", "SpecificHeatCapacityConstantPressure",
+    "SpecificLength", "SpecificSurface", "SpecificVolume", "Stress",
+    "SurfaceMassDensity", "SurfaceTension", "ThermalConductivity", "Torque",
+    "TurbulenceEnergyDissipationRate", "VelocityAngular", "VelocityLinear",
+    "ViscosityDynamic", "ViscosityKinematic", "VolumeFractionOfI",
+    "VolumetricCalorificHeatingValue", "VolumetricCoefficientOfExpansion",
+    "VolumetricFlowRate", "VolumetricFlux", "VolumetricMassFlowRate",
+    "Wavenumber",
+]
 
-__all__ = ["Length", "Pressure", "Dimensionless"]

qnty/dimension.py

@@ -72,15 +72,113 @@ class DimensionSignature:
         return hash(self._signature)
 
 
-# Pre-defined dimension constants
-DIMENSIONLESS = DimensionSignature.create()
-LENGTH = DimensionSignature.create(length=1)
-MASS = DimensionSignature.create(mass=1)
-TIME = DimensionSignature.create(time=1)
-AREA = DimensionSignature.create(length=2)
-VOLUME = DimensionSignature.create(length=3)
-VELOCITY = DimensionSignature.create(length=1, time=-1)
-ACCELERATION = DimensionSignature.create(length=1, time=-2)
-FORCE = DimensionSignature.create(mass=1, length=1, time=-2)
-PRESSURE = DimensionSignature.create(mass=1, length=-1, time=-2)
-ENERGY = DimensionSignature.create(mass=1, length=2, time=-2)
+# Pre-defined dimension constants (alphabetically ordered)
+ABSORBED_DOSE = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+ACCELERATION = DimensionSignature.create(length=1, time=-2)  # L T^-2
+ACTIVATION_ENERGY = DimensionSignature.create(amount=-1, length=2, time=-2)  # N^-1 L^2 T^-2
+AMOUNT = DimensionSignature.create(amount=1)  # N
+AMOUNT_OF_SUBSTANCE = DimensionSignature.create(amount=1)  # N
+ANGLE_PLANE = DimensionSignature.create()  # Dimensionless
+ANGLE_SOLID = DimensionSignature.create()  # Dimensionless
+ANGULAR_ACCELERATION = DimensionSignature.create(time=-2)  # T^-2
+ANGULAR_MOMENTUM = DimensionSignature.create(length=2, mass=1, time=-1)  # L^2 M T^-1
+AREA = DimensionSignature.create(length=2)  # L^2
+AREA_PER_UNIT_VOLUME = DimensionSignature.create(length=-1)  # L^-1
+ATOMIC_WEIGHT = DimensionSignature.create(amount=-1, mass=1)  # N^-1 M
+CONCENTRATION = DimensionSignature.create(length=-3, mass=1)  # L^-3 M
+CURRENT = DimensionSignature.create(current=1)  # A
+DIMENSIONLESS = DimensionSignature.create()  # Dimensionless
+DYNAMIC_FLUIDITY = DimensionSignature.create(length=1, mass=-1, time=1)  # L M^-1 T
+ELECTRICAL_CONDUCTANCE = DimensionSignature.create(current=2, length=-2, mass=-1, time=3)  # A^2 L^-2 M^-1 T^3
+ELECTRICAL_PERMITTIVITY = DimensionSignature.create(current=2, length=-3, mass=-1, time=4)  # A^2 L^-3 M^-1 T^4
+ELECTRICAL_RESISTIVITY = DimensionSignature.create(current=-2, length=3, mass=1, time=-3)  # A^-2 L^3 M T^-3
+ELECTRIC_CAPACITANCE = DimensionSignature.create(current=2, length=-2, mass=-1, time=4)  # A^2 L^-2 M^-1 T^4
+ELECTRIC_CHARGE = DimensionSignature.create(amount=-1, current=1, time=1)  # N^-1 A T
+ELECTRIC_CURRENT_INTENSITY = DimensionSignature.create(current=1)  # A
+ELECTRIC_DIPOLE_MOMENT = DimensionSignature.create(current=1, length=1, time=1)  # A L T
+ELECTRIC_FIELD_STRENGTH = DimensionSignature.create(current=-1, length=1, mass=1, time=-3)  # A^-1 L M T^-3
+ELECTRIC_INDUCTANCE = DimensionSignature.create(current=-2, length=2, mass=1, time=-2)  # A^-2 L^2 M T^-2
+ELECTRIC_POTENTIAL = DimensionSignature.create(current=-1, length=2, mass=1, time=-3)  # A^-1 L^2 M T^-3
+ELECTRIC_RESISTANCE = DimensionSignature.create(current=-2, length=2, mass=1, time=-3)  # A^-2 L^2 M T^-3
+ENERGY_FLUX = DimensionSignature.create(mass=1, time=-3)  # M T^-3
+ENERGY_HEAT_WORK = DimensionSignature.create(length=2, mass=1, time=-2)  # L^2 M T^-2
+ENERGY_PER_UNIT_AREA = DimensionSignature.create(mass=1, time=-2)  # M T^-2
+FORCE = DimensionSignature.create(length=1, mass=1, time=-2)  # L M T^-2
+FORCE_BODY = DimensionSignature.create(length=-2, mass=1, time=-2)  # L^-2 M T^-2
+FORCE_PER_UNIT_MASS = DimensionSignature.create(length=1, time=-2)  # L T^-2
+FREQUENCY_VOLTAGE_RATIO = DimensionSignature.create(current=1, length=-2, mass=-1, time=3)  # A L^-2 M^-1 T^3
+FUEL_CONSUMPTION = DimensionSignature.create(length=-2)  # L^-2
+HEAT_OF_COMBUSTION = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+HEAT_OF_FUSION = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+HEAT_OF_VAPORIZATION = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+HEAT_TRANSFER_COEFFICIENT = DimensionSignature.create(mass=1, temp=-1, time=-3)  # M Θ^-1 T^-3
+ILLUMINANCE = DimensionSignature.create(length=-2, luminosity=1)  # L^-2 J
+KINETIC_ENERGY_OF_TURBULENCE = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+LENGTH = DimensionSignature.create(length=1)  # L
+LINEAR_MASS_DENSITY = DimensionSignature.create(length=-1, mass=1)  # L^-1 M
+LINEAR_MOMENTUM = DimensionSignature.create(length=1, mass=1, time=-1)  # L M T^-1
+LUMINANCE_SELF = DimensionSignature.create(length=-2, luminosity=1)  # L^-2 J
+LUMINOSITY = DimensionSignature.create(luminosity=1)  # J
+LUMINOUS_FLUX = DimensionSignature.create(luminosity=1)  # J
+LUMINOUS_INTENSITY = DimensionSignature.create(luminosity=1)  # J
+MAGNETIC_FIELD = DimensionSignature.create(current=1, length=-1)  # A L^-1
+MAGNETIC_FLUX = DimensionSignature.create(current=-1, length=2, mass=1, time=-2)  # A^-1 L^2 M T^-2
+MAGNETIC_INDUCTION_FIELD_STRENGTH = DimensionSignature.create(current=-1, mass=1, time=-2)  # A^-1 M T^-2
+MAGNETIC_MOMENT = DimensionSignature.create(current=1, length=2)  # A L^2
+MAGNETIC_PERMEABILITY = DimensionSignature.create(current=-2, length=2, mass=1, time=-2)  # A^-2 L^2 M T^-2
+MAGNETOMOTIVE_FORCE = DimensionSignature.create(current=1)  # A
+MASS = DimensionSignature.create(mass=1)  # M
+MASS_DENSITY = DimensionSignature.create(length=-3, mass=1)  # L^-3 M
+MASS_FLOW_RATE = DimensionSignature.create(mass=1, time=-1)  # M T^-1
+MASS_FLUX = DimensionSignature.create(length=-2, mass=1, time=-1)  # L^-2 M T^-1
+MASS_FRACTION_OF_I = DimensionSignature.create()  # Dimensionless
+MASS_TRANSFER_COEFFICIENT = DimensionSignature.create(length=-2, mass=1, time=-1)  # L^-2 M T^-1
+MOLALITY_OF_SOLUTE_I = DimensionSignature.create(amount=1, mass=-1)  # N M^-1
+MOLARITY_OF_I = DimensionSignature.create(amount=1, length=-3)  # N L^-3
+MOLAR_CONCENTRATION_BY_MASS = DimensionSignature.create(amount=1)  # N
+MOLAR_FLOW_RATE = DimensionSignature.create(amount=1, time=-1)  # N T^-1
+MOLAR_FLUX = DimensionSignature.create(amount=1, length=-2, time=-1)  # N L^-2 T^-1
+MOLAR_HEAT_CAPACITY = DimensionSignature.create(amount=-1, length=2, temp=-1, time=-2)  # N^-1 L^2 Θ^-1 T^-2
+MOLE_FRACTION_OF_I = DimensionSignature.create()  # Dimensionless
+MOMENTUM_FLOW_RATE = DimensionSignature.create(length=1, mass=1, time=-2)  # L M T^-2
+MOMENTUM_FLUX = DimensionSignature.create(length=-1, mass=1, time=-2)  # L^-1 M T^-2
+MOMENT_OF_INERTIA = DimensionSignature.create(length=2, mass=1)  # L^2 M
+NORMALITY_OF_SOLUTION = DimensionSignature.create(amount=1, length=-3)  # N L^-3
+PARTICLE_DENSITY = DimensionSignature.create(length=-3)  # L^-3
+PERMEABILITY = DimensionSignature.create(length=2)  # L^2
+PHOTON_EMISSION_RATE = DimensionSignature.create(length=-2, time=-1)  # L^-2 T^-1
+POWER_PER_UNIT_MASS = DimensionSignature.create(length=2, time=-3)  # L^2 T^-3
+POWER_PER_UNIT_VOLUME = DimensionSignature.create(length=-1, mass=1, time=-3)  # L^-1 M T^-3
+POWER_THERMAL_DUTY = DimensionSignature.create(length=2, mass=1, time=-3)  # L^2 M T^-3
+PRESSURE = DimensionSignature.create(length=-1, mass=1, time=-2)  # L^-1 M T^-2
+RADIATION_DOSE_EQUIVALENT = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+RADIATION_EXPOSURE = DimensionSignature.create(current=1, mass=-1, time=1)  # A M^-1 T
+RADIOACTIVITY = DimensionSignature.create(time=-1)  # T^-1
+SECOND_MOMENT_OF_AREA = DimensionSignature.create(length=4)  # L^4
+SECOND_RADIATION_CONSTANT_PLANCK = DimensionSignature.create(length=1, temp=1)  # L Θ
+SPECIFIC_ENTHALPY = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+SPECIFIC_GRAVITY = DimensionSignature.create()  # Dimensionless
+SPECIFIC_HEAT_CAPACITY_CONSTANT_PRESSURE = DimensionSignature.create(length=2, mass=1, temp=-1, time=-2)  # L^2 M Θ^-1 T^-2
+SPECIFIC_LENGTH = DimensionSignature.create(length=1, mass=-1)  # L M^-1
+SPECIFIC_SURFACE = DimensionSignature.create(length=2, mass=-1)  # L^2 M^-1
+SPECIFIC_VOLUME = DimensionSignature.create(length=3, mass=-1)  # L^3 M^-1
+STRESS = DimensionSignature.create(length=-1, mass=1, time=-2)  # L^-1 M T^-2
+SURFACE_MASS_DENSITY = DimensionSignature.create(length=-2, mass=1)  # L^-2 M
+SURFACE_TENSION = DimensionSignature.create(mass=1, time=-2)  # M T^-2
+TEMPERATURE = DimensionSignature.create(temp=1)  # Θ
+THERMAL_CONDUCTIVITY = DimensionSignature.create(length=1, mass=1, temp=1, time=-3)  # L M Θ T^-3
+TIME = DimensionSignature.create(time=1)  # T
+TORQUE = DimensionSignature.create(length=2, mass=1, time=-2)  # L^2 M T^-2
+TURBULENCE_ENERGY_DISSIPATION_RATE = DimensionSignature.create(length=2, time=-3)  # L^2 T^-3
+VELOCITY_ANGULAR = DimensionSignature.create(time=-1)  # T^-1
+VELOCITY_LINEAR = DimensionSignature.create(length=1, time=-1)  # L T^-1
+VISCOSITY_DYNAMIC = DimensionSignature.create(length=-1, mass=1, time=-1)  # L^-1 M T^-1
+VISCOSITY_KINEMATIC = DimensionSignature.create(length=2, time=-1)  # L^2 T^-1
+VOLUME = DimensionSignature.create(length=3)  # L^3
+VOLUMETRIC_CALORIFIC_HEATING_VALUE = DimensionSignature.create(length=-1, mass=1, time=-2)  # L^-1 M T^-2
+VOLUMETRIC_COEFFICIENT_OF_EXPANSION = DimensionSignature.create(length=-3, mass=1, temp=-1)  # L^-3 M Θ^-1
+VOLUMETRIC_FLOW_RATE = DimensionSignature.create(length=3, time=-1)  # L^3 T^-1
+VOLUMETRIC_FLUX = DimensionSignature.create(length=1, time=-1)  # L T^-1
+VOLUMETRIC_MASS_FLOW_RATE = DimensionSignature.create(length=-3, mass=1, time=-1)  # L^-3 M T^-1
+VOLUME_FRACTION_OF_I = DimensionSignature.create()  # Dimensionless
+WAVENUMBER = DimensionSignature.create(length=-1)  # L^-1

qnty/prefixes.py

@@ -0,0 +1,229 @@
+"""
+SI Prefix System
+================
+
+Standard SI prefixes for unit multiplication/division.
+Provides systematic handling of metric prefixes like kilo-, milli-, micro-, etc.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+@dataclass(frozen=True)
+class SIPrefix:
+    """
+    Standard SI prefix definition.
+    
+    Attributes:
+        name: Full prefix name (e.g., "kilo", "milli")
+        symbol: Standard symbol (e.g., "k", "m")
+        factor: Multiplication factor relative to base unit (e.g., 1000, 0.001)
+    """
+    name: str
+    symbol: str
+    factor: float
+    
+    def apply_to_name(self, base_name: str) -> str:
+        """Apply prefix to a base unit name."""
+        if not self.name:
+            return base_name
+        return f"{self.name}{base_name}"
+    
+    def apply_to_symbol(self, base_symbol: str) -> str:
+        """Apply prefix to a base unit symbol."""
+        if not self.symbol:
+            return base_symbol
+        return f"{self.symbol}{base_symbol}"
+
+
+class StandardPrefixes(Enum):
+    """
+    Standard SI prefixes with their multiplication factors.
+    
+    From yotta (10^24) to yocto (10^-24).
+    """
+    # Larger prefixes (10^3 to 10^24)
+    YOTTA = SIPrefix("yotta", "Y", 1e24)
+    ZETTA = SIPrefix("zetta", "Z", 1e21)
+    EXA = SIPrefix("exa", "E", 1e18)
+    PETA = SIPrefix("peta", "P", 1e15)
+    TERA = SIPrefix("tera", "T", 1e12)
+    GIGA = SIPrefix("giga", "G", 1e9)
+    MEGA = SIPrefix("mega", "M", 1e6)
+    KILO = SIPrefix("kilo", "k", 1e3)
+    HECTO = SIPrefix("hecto", "h", 1e2)
+    DECA = SIPrefix("deca", "da", 1e1)
+    
+    # Base (no prefix)
+    NONE = SIPrefix("", "", 1.0)
+    
+    # Smaller prefixes (10^-1 to 10^-24)
+    DECI = SIPrefix("deci", "d", 1e-1)
+    CENTI = SIPrefix("centi", "c", 1e-2)
+    MILLI = SIPrefix("milli", "m", 1e-3)
+    MICRO = SIPrefix("micro", "μ", 1e-6)
+    NANO = SIPrefix("nano", "n", 1e-9)
+    PICO = SIPrefix("pico", "p", 1e-12)
+    FEMTO = SIPrefix("femto", "f", 1e-15)
+    ATTO = SIPrefix("atto", "a", 1e-18)
+    ZEPTO = SIPrefix("zepto", "z", 1e-21)
+    YOCTO = SIPrefix("yocto", "y", 1e-24)
+
+
+# Common prefix groups for different unit types
+COMMON_LENGTH_PREFIXES = [
+    StandardPrefixes.KILO,
+    StandardPrefixes.CENTI,
+    StandardPrefixes.MILLI,
+    StandardPrefixes.MICRO,
+    StandardPrefixes.NANO,
+]
+
+COMMON_MASS_PREFIXES = [
+    StandardPrefixes.KILO,  # Note: kilogram is the SI base unit
+    StandardPrefixes.MILLI,
+    StandardPrefixes.MICRO,
+]
+
+COMMON_TIME_PREFIXES = [
+    StandardPrefixes.MILLI,
+    StandardPrefixes.MICRO,
+    StandardPrefixes.NANO,
+    StandardPrefixes.PICO,
+]
+
+COMMON_ELECTRIC_PREFIXES = [
+    StandardPrefixes.KILO,
+    StandardPrefixes.MILLI,
+    StandardPrefixes.MICRO,
+    StandardPrefixes.NANO,
+    StandardPrefixes.PICO,
+]
+
+COMMON_ENERGY_PREFIXES = [
+    StandardPrefixes.KILO,
+    StandardPrefixes.MEGA,
+    StandardPrefixes.GIGA,
+]
+
+COMMON_POWER_PREFIXES = [
+    StandardPrefixes.KILO,
+    StandardPrefixes.MEGA,
+    StandardPrefixes.GIGA,
+    StandardPrefixes.MILLI,
+    StandardPrefixes.MICRO,
+]
+
+COMMON_PRESSURE_PREFIXES = [
+    StandardPrefixes.KILO,
+    StandardPrefixes.MEGA,
+    StandardPrefixes.GIGA,
+]
+
+
+def get_prefix_by_name(name: str) -> SIPrefix | None:
+    """Get a prefix by its name (e.g., 'kilo', 'milli')."""
+    for prefix_enum in StandardPrefixes:
+        if prefix_enum.value.name == name:
+            return prefix_enum.value
+    return None
+
+
+def get_prefix_by_symbol(symbol: str) -> SIPrefix | None:
+    """Get a prefix by its symbol (e.g., 'k', 'm')."""
+    for prefix_enum in StandardPrefixes:
+        if prefix_enum.value.symbol == symbol:
+            return prefix_enum.value
+    return None
+
+
+def get_prefix_by_factor(factor: float, tolerance: float = 1e-10) -> SIPrefix | None:
+    """Get a prefix by its multiplication factor."""
+    for prefix_enum in StandardPrefixes:
+        if abs(prefix_enum.value.factor - factor) < tolerance:
+            return prefix_enum.value
+    return None
+
+
+# Define which units should get automatic prefixes
+PREFIXABLE_UNITS = {
+    # Base SI units
+    'meter': COMMON_LENGTH_PREFIXES,
+    'gram': COMMON_MASS_PREFIXES,
+    'second': COMMON_TIME_PREFIXES,
+    'ampere': COMMON_ELECTRIC_PREFIXES,
+    'kelvin': [],  # Temperature usually doesn't use prefixes
+    'mole': [
+        StandardPrefixes.MILLI,
+        StandardPrefixes.MICRO
+    ],
+    'candela': [],  # Luminous intensity rarely uses prefixes
+    
+    # Derived SI units
+    'pascal': COMMON_PRESSURE_PREFIXES,
+    'joule': COMMON_ENERGY_PREFIXES,
+    'watt': COMMON_POWER_PREFIXES,
+    'coulomb': COMMON_ELECTRIC_PREFIXES,
+    'volt': COMMON_ELECTRIC_PREFIXES,
+    'farad': [
+        StandardPrefixes.MILLI,
+        StandardPrefixes.MICRO,
+        StandardPrefixes.NANO,
+        StandardPrefixes.PICO
+    ],
+    'ohm': [
+        StandardPrefixes.KILO,
+        StandardPrefixes.MEGA,
+        StandardPrefixes.MILLI
+    ],
+    'siemens': [
+        StandardPrefixes.MILLI,
+        StandardPrefixes.MICRO
+    ],
+    'weber': [
+        StandardPrefixes.MILLI,
+        StandardPrefixes.MICRO
+    ],
+    'tesla': [
+        StandardPrefixes.MILLI,
+        StandardPrefixes.MICRO,
+        StandardPrefixes.NANO
+    ],
+    'henry': [
+        StandardPrefixes.MILLI,
+        StandardPrefixes.MICRO,
+        StandardPrefixes.NANO
+    ],
+    'lumen': [],
+    'lux': [],
+    'becquerel': [
+        StandardPrefixes.KILO,
+        StandardPrefixes.MEGA,
+        StandardPrefixes.GIGA
+    ],
+    'gray': [
+        StandardPrefixes.MILLI,
+        StandardPrefixes.MICRO
+    ],
+    'sievert': [
+        StandardPrefixes.MILLI,
+        StandardPrefixes.MICRO
+    ],
+    'hertz': [
+        StandardPrefixes.KILO,
+        StandardPrefixes.MEGA,
+        StandardPrefixes.GIGA
+    ],
+    'newton': [
+        StandardPrefixes.KILO,
+        StandardPrefixes.MILLI
+    ],
+    'bar': [
+        StandardPrefixes.MILLI
+    ],  # Common non-SI unit
+    'liter': [
+        StandardPrefixes.MILLI,
+        StandardPrefixes.MICRO
+    ],  # Common non-SI unit
+}

qnty/unit.py

@@ -8,6 +8,7 @@ Unit definitions, constants and registry for the high-performance unit system.
 from dataclasses import dataclass
 
 from .dimension import DIMENSIONLESS, LENGTH, PRESSURE, DimensionSignature
+from .prefixes import SIPrefix, StandardPrefixes
 
 
 @dataclass(frozen=True)
@@ -18,6 +19,21 @@ class UnitDefinition:
     dimension: DimensionSignature
     si_factor: float
     si_offset: float = 0.0
+    base_unit_name: str | None = None  # Base unit without prefix
+    prefix: SIPrefix | None = None      # SI prefix if applicable
+    
+    @classmethod
+    def with_prefix(cls, base_def: 'UnitDefinition', prefix: SIPrefix) -> 'UnitDefinition':
+        """Create a new unit definition with an SI prefix."""
+        return cls(
+            name=prefix.apply_to_name(base_def.name),
+            symbol=prefix.apply_to_symbol(base_def.symbol),
+            dimension=base_def.dimension,
+            si_factor=base_def.si_factor * prefix.factor,
+            si_offset=base_def.si_offset,
+            base_unit_name=base_def.name,
+            prefix=prefix
+        )
 
 
 class UnitConstant:
@@ -50,7 +66,11 @@ class HighPerformanceRegistry:
         self.conversion_table: dict[tuple[str, str], float] = {}  # (from_unit, to_unit) -> factor
         self.dimensional_groups: dict[int, list[UnitDefinition]] = {}
         self._dimension_cache: dict[int, UnitConstant] = {}  # Cache for common dimension mappings
+        self._finalized = False
+        self.base_units: dict[str, UnitDefinition] = {}  # Track base units for prefix generation
+        self.prefixable_units: set[str] = set()  # Track which units can have prefixes
 
+        # Keep legacy initialization for backward compatibility
         self._initialize_units()
         self._precompute_conversions()
     
@@ -85,8 +105,56 @@ class HighPerformanceRegistry:
                 self.dimensional_groups[dim_sig] = []
             self.dimensional_groups[dim_sig].append(unit_def)
     
+    def register_unit(self, unit_def: UnitDefinition):
+        """Register a single unit definition."""
+        if self._finalized:
+            raise RuntimeError("Cannot register units after registry is finalized")
+            
+        self.units[unit_def.name] = unit_def
+        
+        # Group by dimension
+        dim_sig = unit_def.dimension._signature
+        if dim_sig not in self.dimensional_groups:
+            self.dimensional_groups[dim_sig] = []
+        self.dimensional_groups[dim_sig].append(unit_def)
+    
+    def register_with_prefixes(
+            self,
+            unit_def: UnitDefinition,
+            prefixes: list[StandardPrefixes] | None = None
+        ):
+        """
+        Register a unit and automatically generate prefixed variants.
+        
+        Args:
+            unit_def: The base unit definition
+            prefixes: List of StandardPrefixes enum values to apply. If None, uses common prefixes.
+        """
+        if self._finalized:
+            raise RuntimeError("Cannot register units after registry is finalized")
+        
+        # Register base unit
+        self.register_unit(unit_def)
+        self.base_units[unit_def.name] = unit_def
+        self.prefixable_units.add(unit_def.name)
+        
+        # Generate and register prefixed variants
+        if prefixes:
+            for prefix_enum in prefixes:
+                prefix = prefix_enum.value
+                if prefix.name:  # Skip NONE prefix (empty name)
+                    prefixed_unit = UnitDefinition.with_prefix(unit_def, prefix)
+                    self.register_unit(prefixed_unit)
+    
+    def finalize_registration(self):
+        """Called after all units registered to precompute conversions."""
+        if not self._finalized:
+            self._precompute_conversions()
+            self._finalized = True
+
     def _precompute_conversions(self):
         """Pre-compute all unit conversions for maximum speed."""
+        self.conversion_table.clear()  # Clear existing conversions
         for group in self.dimensional_groups.values():
             for from_unit in group:
                 for to_unit in group:

qnty/unit_types/base.py

@@ -0,0 +1,47 @@
+"""
+Base Unit Module Definition
+===========================
+
+Provides abstract base class for unit modules and registration functionality.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from ..unit import UnitDefinition
+
+
+class UnitModule(ABC):
+    """Abstract base class for unit modules."""
+    
+    @abstractmethod
+    def get_unit_definitions(self) -> list[UnitDefinition]:
+        """Return list of unit definitions for this module."""
+        pass
+    
+    @abstractmethod
+    def get_units_class(self) -> type[Any]:
+        """Return the units class for this module."""
+        pass
+    
+    def register_to_registry(self, unit_registry):
+        """Register all unit definitions to the given registry."""
+        from ..unit import UnitConstant
+        
+        for unit_def in self.get_unit_definitions():
+            if unit_def.name not in unit_registry.units:
+                unit_registry.register_unit(unit_def)
+        
+        # Populate the units class with constants from registry
+        units_class = self.get_units_class()
+        for unit_def in self.get_unit_definitions():
+            unit_constant = UnitConstant(unit_registry.units[unit_def.name])
+            setattr(units_class, unit_def.name, unit_constant)
+            
+            # Add any aliases
+            if unit_def.symbol and unit_def.symbol != unit_def.name:
+                setattr(units_class, unit_def.symbol, unit_constant)
+            
+            # Special case for inch - add in_ alias since 'in' is a Python keyword
+            if unit_def.name == "inch":
+                units_class.in_ = unit_constant