# Actualizar de la 3.3 a la 4.0

> Una página de la documentación de phonometry, en Markdown. Índice: https://docs.jmrp.io/phonometry/llms.txt

Canonical: https://docs.jmrp.io/phonometry/es/start/upgrading/
Language: es
Alternate: https://docs.jmrp.io/phonometry/start/upgrading/index.md
Version: phonometry 4.0.0
Install: pip install "phonometry[full]"
Author: José Manuel Requena Plens (https://orcid.org/0000-0003-1250-6212)
Published: 2026-09-10
Updated: 2026-11-16T21:36:13Z
License: MIT (https://github.com/jmrplens/phonometry/blob/main/LICENSE)
Summary: Actualización a la 4.0: lo movido, renombrado o retirado y cómo hallar su grafía nueva, el recorte de la raíz, módulos partidos y unidades en los nombres.

---

La 4.0 rompe duro y no lleva capa de compatibilidad. Casi nada se ha borrado:
de los 885 nombres que la raíz exportaba en la 3.3.0, setenta y ocho no existen ya
en ningún sitio y el resto simplemente vive en una dirección con nombre en vez
de en una plana. Así que el trabajo es sobre todo un barrido de imports, y esta
página es sobre todo un mapa.

Con las dos primeras secciones arreglas los imports. La tercera léela aunque
tengas prisa, porque en cuatro sitios, uno de ellos solo para el código escrito
contra la 4.0.0rc1, el arreglo evidente es el equivocado, y tres de esos cuatro
cambian un número sin levantar nada.

## La regla única: los imports bajan un nivel

En la 3.3.0 la raíz reexportaba la biblioteca entera, así que `from phonometry
import laeq` funcionaba para casi cualquier nombre. Hoy la raíz exporta
veinticinco cosas: los veintiún subpaquetes, las tres clases que no pertenecen a
ningún dominio concreto (`Signal`, `ReportMetadata`, `PhonometryWarning`) y
`__version__`.

```python
import phonometry

print(len(phonometry.__all__))          # 25
print("laeq" in phonometry.__all__)     # False

from phonometry.signals import laeq     # esta es la grafía nueva
```

Medido sobre la superficie entera, 804 de aquellos 885 nombres de la raíz los
publica hoy exactamente un subpaquete, ninguno dos, y ninguno necesita una ruta
más profunda que `phonometry.<subpaquete>`. Otros tres siguen en la raíz, donde
siempre estuvieron. Así que el cambio no tiene ambigüedad: busca el subpaquete e
importa de él.

La forma de atributo no se retiró nunca, que es el cambio más pequeño posible
para el código que tiraba de la raíz:

```python
from phonometry import filters

print(filters.nominal_frequencies(1).labels)
```

### Encontrar la casa nueva de un nombre

En vez de buscar cada uno en la referencia, pregúntaselo al paquete instalado:

```python
import importlib
import pkgutil

import phonometry


def whereis(name):
    """Cada módulo público que publica `name`, del menos profundo al que más."""
    found = ["phonometry"] if name in phonometry.__all__ else []
    for attribute in phonometry.__all__:
        package = getattr(phonometry, attribute)
        if not hasattr(package, "__path__"):
            continue
        modules = [package.__name__]
        modules += [m.name for m in pkgutil.walk_packages(package.__path__, package.__name__ + ".")]
        for module_name in modules:
            if any(part.startswith("_") for part in module_name.split(".")):
                continue
            try:
                module = importlib.import_module(module_name)
            except ImportError:
                continue
            if name in getattr(module, "__all__", ()):
                found.append(module_name)
    return sorted(found, key=lambda path: path.count("."))


print(whereis("laeq")[0])                  # phonometry.signals
print(whereis("reverberation_time")[0])    # phonometry.room
print(whereis("sensitivity")[0])           # phonometry.metrology
print(whereis("Signal")[0])                # phonometry
```

Recorre el árbol en unos dos segundos. Cuando devuelve varias rutas, la menos
profunda es el import canónico: un subpaquete reexporta lo que publican sus
propios módulos, y esa ruta corta es la que usan las guías y los tests. Los
cuatro nombres que la raíz sigue publicando por su cuenta, `Signal`,
`PhonometryWarning`, `ReportMetadata` y `__version__`, vuelven como
`phonometry` a secas. Una lista vacía significa que el nombre está en la
última sección de esta página.

## Módulos que se partieron en vez de mudarse

Cinco de los treinta módulos que cambiaron de ruta no se mudaron a una
dirección nueva. Se dividieron, y quien siga sólo la primera mitad de la
partición se lleva un `ImportError` por el resto. Merece la pena revisarlos uno
a uno, y el paquete privado de renderizado va con ellos porque le pasó lo
mismo:

| Módulo en 3.3.0 | Dónde está hoy su contenido |
| --- | --- |
| `phonometry.impedance_tube` | `materials.absorbers.impedance_tube` (función de transferencia de dos micrófonos), `materials.absorbers.four_microphone` (`TransferMatrix`, `transfer_matrix_one_load`, `wave_decomposition`, `face_quantities`, `air_layer_transfer_matrix`), `materials.absorbers.standing_wave` y `fluids` |
| `phonometry.scattering_diffusion` | `materials.diffusers.reverberation_room_scattering` para la parte de cámara reverberante (`ScatteringResult`, `ScatteringUncertainty`, `BASE_PLATE_BANDS_HZ` y el resto), `materials.diffusers.scattering_diffusion` para los nueve nombres de campo libre |
| `phonometry.materials.porous_absorber` | `materials.absorbers.porous` para los modelos de material en masa, `materials.absorbers.layered` para toda la API multicapa (`layered_absorber`, `AirLayer`, `MembraneLayer`, `PerforatedPlateLayer`, `MicroperforatedPlateLayer`, `LayeredAbsorberResult`) |
| `phonometry.metrology.spectra` | `signals.spectra`, más `signals.multitaper` (`multitaper_psd`) y `signals.windows` (`window_metrics`) |
| `phonometry.compliance` | `filters.compliance` (`FilterComplianceResult`, `class_limits`, `verify_filter_class`), `filters.weighting_compliance` (`verify_weighting_class`, `weighting_class_limits`), `aircraft.measurement_system` (`verify_aircraft_noise_system`) |
| `phonometry._plotting` | `phonometry._plot.<dominio>`: los 82 renderizadores se repartieron por dominio, así que `plot_airborne_insulation` está en `_plot.building` y `plot_age_threshold` en `_plot.hearing`. Privado en ambos casos, y la vía soportada es el `.plot()` del resultado |

Los otros veinticinco se mudaron enteros, y el resolutor de arriba los
encuentra sin leer esta tabla. Cada uno de los tres primeros era alcanzable por
dos rutas en la 3.3.0, la plana y la de dentro de su paquete, y las dos han
desaparecido.

## Cuatro sitios donde el arreglo evidente es el equivocado

Todo lo demás de esta página se anuncia en cuanto lo ejecutas, y el arreglo es
el que parece. Estos cuatro no son así.

### Los auxiliares del tubo de impedancia tomaban kelvin

`air_density_iso` y `speed_of_sound_iso` documentaban y consumían su
temperatura en **kelvin**. Sus sucesores toman grados Celsius, como el resto de
la biblioteca. El nombre cambió, así que el import falla y te enteras, pero el
problema es el argumento que arrastras: 293,15 es un número de aspecto
legítimo en cualquiera de las dos unidades.

```python
from phonometry.materials import speed_of_sound_iso10534

print(round(float(speed_of_sound_iso10534(temperature_c=20.0)), 5))      # 343.28784
print(round(float(speed_of_sound_iso10534(temperature_c=293.15)), 5))    # 477.13003
```

343,29 m/s frente a 477,13 m/s: un 39 % de error, sin excepción ninguna, y
cada coeficiente de absorción calculado a partir de ahí sale mal en una
cantidad de aspecto plausible. Convierte el valor, no te limites a renombrar la
palabra clave.

| 3.3.0 | 4.0 |
| --- | --- |
| `impedance_tube.air_density_iso(T_kelvin, p_kPa)` | `materials.air_density_iso10534(temperature_c=T_kelvin - 273.15, static_pressure_kpa=p_kPa)` |
| `impedance_tube.speed_of_sound_iso(T_kelvin)` | `materials.speed_of_sound_iso10534(temperature_c=T_kelvin - 273.15)` |

Con la conversión aplicada, los dos devuelven exactamente lo que devolvían en
la 3.3.0, bit a bit.

### `GasStream` tomaba kelvin

`noise_control.GasStream` guardaba la temperatura de entrada de IEC 60534-8-3
como `inlet_temperature_k` en la 4.0.0rc1, en **kelvin**, que es como la lee
el apartado 5. En la 4.0 el campo es `inlet_temperature_c`, en grados Celsius
como cualquier otra temperatura que toma la biblioteca, y la conversión a la
temperatura absoluta que necesita el apartado 5 se hace dentro. La palabra
clave falla, así que lo notarás, pero 450,0 es un número tan legítimo en una
unidad como en la otra: renombra la palabra clave, conserva el número y el gas
está 273,15 K más caliente. El ejemplo 1 del Anexo A a 450 K da 91,7 dB(A) a
1 m de la tubería; el mismo 450 leído en grados Celsius da 93,0 dB(A), y no
salta nada.

| 4.0.0rc1 | 4.0 |
| --- | --- |
| `GasStream(inlet_temperature_k=T_kelvin, ...)` | `GasStream(inlet_temperature_c=T_kelvin - 273.15, ...)` |

### `speed_of_sound` es `speed_of_sound_iso17497`, no `fluids.air()`

El `speed_of_sound(temperature)` de la 3.3.0, en el primer nivel y en
`materials.scattering_diffusion`, es la fórmula de una línea de la
ISO 17497-1, y en la 4.0 es `materials.speed_of_sound_iso17497`: la misma
fórmula y el mismo número, con la temperatura, todavía en grados Celsius,
escrita por su nombre. La trampa es el otro candidato. `fluids.air()` es de
donde el resto de la 4.0 lee la velocidad del sonido del aire, así que parece
la casa nueva de una función que la devolvía, pero calcula aire húmedo por el
Anexo F de IEC 61094-2: a 20 °C responde 343,99 m/s donde la fórmula de la
ISO 17497-1 responde 343,20 m/s, y no salta nada. Es poco, y no es nada
despreciable si estás reproduciendo una medición hecha con el número antiguo.

```python
from phonometry import fluids, materials

print(round(float(materials.speed_of_sound_iso17497(temperature_c=20.0)), 2))    # 343.2
air = fluids.air(temperature_c=20.0, relative_humidity_percent=50.0, static_pressure_pa=101_325.0)
print(round(air.speed_of_sound, 2))                                              # 343.99
```

| 3.3.0 | 4.0 |
| --- | --- |
| `speed_of_sound(T_celsius)` | `materials.speed_of_sound_iso17497(temperature_c=T_celsius)` |

### El campo `tl` de un resultado submarino es `pl`

`transmission_loss` pasó a `propagation_loss`, cosa que el import detecta, y
con él se renombró el campo de dentro del resultado. Ese no levanta nada: un
`PropagationLossResult` no tiene `.tl`, así que el `AttributeError` aparece
allí donde lo leas, que puede quedar lejos de la llamada.

```python
from phonometry.underwater.propagation.closed_form import propagation_loss

result = propagation_loss([1000.0], 1000.0)
print(round(float(result.pl[0]), 5))    # 60.06013, el número que guardaba .tl
```

El mismo renombrado llega a `underwater.sonar_equation`, cuyo parámetro
`transmission_loss` es ahora `propagation_loss`.

## El entorno se metió en una dataclase

Cinco puntos de entrada ya no toman las condiciones ambientales como números
sueltos. Ahí no basta con renombrar la palabra clave, porque el parámetro ha
desaparecido del todo:

| 3.3.0 | 4.0 |
| --- | --- |
| `airport_noise.event_level(..., temperature=15.0, pressure=101.325)` | `event_level(..., atmosphere=AerodromeAtmosphere(temperature_c=15.0, static_pressure_kpa=101.325))` |
| `airport_noise.noise_contour(...)` | lo mismo, con `AerodromeAtmosphere` |
| `rotorcraft_noise.rotorcraft_event_level(..., temperature=15.0, relative_humidity=70.0)` | `rotorcraft_event_level(..., atmosphere=RotorcraftAtmosphere(temperature_c=15.0, relative_humidity_percent=70.0))` |
| `rotorcraft_noise.rotorcraft_noise_contour(...)` | lo mismo, con `RotorcraftAtmosphere` |
| `outdoor_propagation.predicted_receiver_level(..., humidity=70.0)` | `predicted_receiver_level(..., atmosphere=AtmosphericConditions(relative_humidity_percent=70.0))` |

Las demás opciones de estas funciones también pasaron a registros, entre ellas
las sustituciones punto a punto del rotorcraft, y la sección siguiente las
recorre.

```python
from phonometry.aircraft.airport_noise import AerodromeAtmosphere

atmosphere = AerodromeAtmosphere(temperature_c=15.0, static_pressure_kpa=101.325)
print(atmosphere.temperature_c, atmosphere.static_pressure_kpa)
```

## Las firmas más largas toman sus opciones en registros

Diez firmas tomaban más de trece parámetros cada una, y en la 4.0 las opciones
que van juntas son un registro. Una palabra clave de la 3.3.0 entre ellas no se
renombró, sino que desapareció, así que una llamada que la pasa lanza
`TypeError`: construye el registro al que fue la palabra clave y pasa ese. Cada
campo de un registro se escribe por su nombre, y un campo con valor por defecto
tiene el que tenía su palabra clave, así que un registro lleva solo lo que
cambias. Las atmósferas de
la sección anterior son registros de la misma clase; estos son los demás:

| 3.3.0 | 4.0 |
| --- | --- |
| `filter_type=`, `ripple=` y `attenuation=` en `octave_filter` y `OctaveFilterBank`, y `resample=` en `OctaveFilterBank` | `design=filters.FilterDesign(filter_type=..., ripple=..., attenuation=..., resample=...)` |
| `calibration_factor=` y `dbfs=` en `octave_filter` y `OctaveFilterBank` | `calibration=filters.LevelCalibration(factor=..., dbfs=...)` |
| `show=` y `plot_file=` en `octave_filter` y `OctaveFilterBank` | `response_plot=filters.ResponsePlot(show=..., file=...)` |
| `stateful=` y `steady_ic=` en `OctaveFilterBank` | `block_processing=filters.BlockProcessing(stateful=..., steady_ic=...)` |
| `polar=`, `polar_frequency=` y `directivity_index_db=` en `microphone_characteristics` | `directivity=electroacoustics.MicrophoneDirectivity(polar=..., frequency=..., index=...)` |
| `noise_voltage=`, `equivalent_noise_level_db=`, `noise_weighting=` y `noise_spectrum=` en `microphone_characteristics` | `noise=electroacoustics.MicrophoneNoise(voltage_v=..., equivalent_level=..., weighting=..., spectrum=...)`, cuya ponderación es `"A"` o `"468"`, como dice la tabla de una grafía por concepto |
| `max_spl_db=`, `max_spl_thd_percent=` y `distortion=` en `microphone_characteristics` | `overload=electroacoustics.MicrophoneOverload(spl=..., thd_percent=..., distortion=...)` |
| `rated_impedance=`, `minimum_load_impedance=`, `powering=` y `supply_current_ma=` en `microphone_characteristics` | `electrical=electroacoustics.MicrophoneElectrical(rated_impedance_ohm=..., min_load_impedance_ohm=..., powering=..., supply_current_ma=...)` |
| `directivity=` (un `RadiatingPistonResult`), `polar=`, `polar_frequency=` y `directivity_index_db=` en `loudspeaker_characteristics` | `directivity=electroacoustics.LoudspeakerDirectivity(piston=..., polar=..., frequency=..., index=...)` |
| `rated_frequency_range=`, `rated_noise_power=`, `rated_sinusoidal_power=` y `resonance_frequency=` en `loudspeaker_characteristics` | `ratings=electroacoustics.LoudspeakerRatings(frequency_range=..., noise_power=..., sinusoidal_power=..., resonance_frequency=...)` |
| `absorption_area=`, `reverberation_time=`, `volume=`, `mean_absorption_coefficient=` y `room_surface=` en `sound_power_pressure` | `room=emission.RoomEnvironment(...)`, con los mismos cinco nombres |
| `distance`, `source_height` y `receiver_height` por posición, y `projected_distance=`, en `predicted_receiver_level` | `environment.PropagationGeometry(distance=..., source_height_m=..., receiver_height_m=..., projected_distance=...)` como segundo argumento, tras el nivel de potencia acústica |
| `ground_source=`, `ground_middle=` y `ground_receiver=` en `predicted_receiver_level` | `ground=environment.GroundFactors(source=..., middle=..., receiver=...)` |
| `directivity_index=` y `d_omega=` en `predicted_receiver_level` | `directivity=environment.DirectivityCorrection(index=..., d_omega=...)` |
| `ground_roll=`, `landing_roll=` y `bank=` en `aircraft.event_level` y `noise_contour` | `segments=aircraft.FlightSegmentState(ground_roll=..., landing_roll=..., bank=...)` |
| `atmospheric_method=` en `rotorcraft_event_level` y `rotorcraft_noise_contour` | el `atmospheric_method` de su `RotorcraftAtmosphere` |
| `receiver_height=`, `ground_elevation=`, `flow_resistivity=`, `terrain=` y `terrain_resolution=` en esas mismas dos | `ground=aircraft.RotorcraftGround(receiver_height_m=..., ground_elevation=..., flow_resistivity=..., terrain=..., terrain_resolution=...)` |
| `airspeed=`, `path_angle=`, `heading=` y `bank_angle=` en esas mismas dos | `track_state=aircraft.RotorcraftTrackState(airspeed=..., path_angle_deg=..., heading=..., bank_angle_deg=...)` |
| `scaling_factor=` y `triangles=` en esas mismas dos | `interpolation=aircraft.FlightConditionInterpolation(scaling_factor=..., triangles=...)` |

`OctaveFilterBank(48000, 3)` se lee como antes, porque los cuatro argumentos
que se escriben por posición conservaron su sitio; en `octave_filter`, toda
opción que va detrás de `limits` se escribe por su nombre.

```python
import numpy as np

from phonometry import filters

x = np.random.default_rng(0).standard_normal(48_000)
try:
    filters.octave_filter(x, 48_000, calibration_factor=2.0)
except TypeError as error:
    print(type(error).__name__)
# TypeError
result = filters.octave_filter(x, 48_000, calibration=filters.LevelCalibration(factor=2.0))
print(len(result.frequencies))
# 11
```

## El aire de un modelo es un único `fluid=`

Veintidós funciones de la 3.3.0 tomaban como números sueltos el aire en el que
calculan: una velocidad del sonido y una densidad, en los modelos viscotérmicos
una viscosidad, un número de Prandtl, una relación de calores específicos y una
presión estática, y en la corrección térmica de la ISO 9053-2 un calor
específico y una conductividad térmica, cada uno con su propio valor por
defecto.
En la 4.0 estas veintidós toman un único `fluid=`, un `fluids.Fluid` que lleva
todas las propiedades que lee su modelo, y sus palabras clave sueltas han
desaparecido, así que una llamada que pasaba una lanza `TypeError`. Otras funciones
que toman una velocidad del sonido o una densidad, entre ellas
`expansion_chamber`, conservan sus propias palabras clave. Si se
omite, `fluid=` es `materials.ABSORBER_AIR`, que guarda los valores por defecto
de la 3.3.0: 343 m/s, 1,205 kg/m³, 1,84·10⁻⁵ Pa s, un número de Prandtl de
0,71, una relación de calores específicos de 1,4 y 101,325 kPa. Una llamada que
nunca pasó el aire da el número que daba.

| 3.3.0 | 4.0 |
| --- | --- |
| `speed_of_sound=` y `air_density=` en `delany_bazley`, `miki`, `membrane_resonance_frequency`, `mass_law_transmission_loss`, `single_panel_transmission_loss`, `double_wall_transmission_loss`, `mass_spring_mass_resonance`, `ground_effect` y `barrier_insertion_loss` | `fluid=` |
| `speed_of_sound=`, `air_density=` y `viscosity=` en `layered_absorber` y `diffuse_field_absorption`; `air_density=` y `viscosity=` en `perforated_plate_impedance` y `microperforated_plate_impedance` | `fluid=` |
| `speed_of_sound=`, `air_density=`, `viscosity=`, `prandtl_number=`, `heat_capacity_ratio=` y `atmospheric_pressure=` en `johnson_champoux_allard`, `slit_helmholtz_absorber` y `critical_coupling_design`, y los mismos salvo `speed_of_sound=` en `helmholtz_resonator_impedance`, `slit_effective_properties` y `rectangular_duct_properties` | `fluid=`, cuyo `static_pressure_pa` es la presión, en pascales como antes |
| `air_density=` en `atmospheric_parabolic_equation` | `fluid=` |
| `speed_of_sound=`, `air_density=`, `specific_heat_ratio=`, `specific_heat_cp=` y `thermal_conductivity=` en `effective_kappa`, y los mismos salvo `specific_heat_ratio=` en `thermal_boundary_layer_thickness` | `fluid=`, con otro valor por defecto, más abajo |

Pasa como un `Fluid` el aire al que te refieres. `fluids.air()` calcula uno a
una temperatura, una humedad y una presión, y un `Fluid` construido a mano
lleva los números que imprime un libro. Un modelo que lee una propiedad que el
fluido no lleva lanza `fluids.FluidPropertyUnavailableError`, nombrándola.

```python
import numpy as np

from phonometry import fluids, materials

f = np.array([250.0, 1000.0])
print(materials.delany_bazley(f, 20_000.0).characteristic_impedance.round(1))
# [971.5-775.5j 609.6-281.1j]
book_air = fluids.Fluid(
    temperature_c=20.0,
    static_pressure_pa=101_325.0,
    composition={},
    model="el aire del libro que se reproduce",
    validity="",
    properties={"speed_of_sound": 340.0, "density": 1.21},
)
# delany_bazley(f, 20000.0, speed_of_sound=340.0, air_density=1.21) en la 3.3.0
print(materials.delany_bazley(f, 20_000.0, fluid=book_air).characteristic_impedance.round(1))
# [965.3-769.6j 606.1-279.j ]
```

Dos de las veintidós toman otro aire por defecto. `effective_kappa` y
`thermal_boundary_layer_thickness`, la corrección térmica de la ISO 9053-2,
tomaban por defecto en la 3.3.0 los cinco valores que imprime el Anexo A.3 de
la ISO 9053-2, dos de los cuales no son del aire que el anexo dice usar
([registro de erratas](https://docs.jmrp.io/phonometry/es/reference/errata/)). En la 4.0 toman ese
aire, el del Anexo F de IEC 61094-2 en el estado del Anexo A.3: 23 °C,
101,325 kPa y un 50 % de humedad relativa. La corrección se mueve en su quinta
cifra, `effective_kappa(0.01, 0.001, 250.0)` es 1,400297 donde era 1,400339, y
los resultados impresos del Anexo A.3 siguen saliendo.

## Un parámetro que nombra una magnitud lleva su unidad

En todo lo demás, las condiciones ambientales conservaron su sitio y ganaron un
sufijo. La regla es que un parámetro público que nombra una magnitud dimensional
termina en la unidad que teclea quien llama, porque el número es donde se pierde
la unidad y ninguna guardia puede cazarlo por magnitud: 101,325 y 101325 son
las dos presiones legítimas en esta biblioteca.

| 3.3.0 | 4.0 |
| --- | --- |
| `temperature=` | `temperature_c=` |
| `pressure=` en `air_attenuation`, `air_attenuation_m` (ahora `air_power_attenuation_per_m`), `atmospheric_attenuation`, `atmospheric_absorption`, `outdoor_propagation_attenuation`, `sae_band_attenuation` (ahora `band_attenuation_arp5534`), `impedance_adjustment` y `atmospheric_adjustment`, y en los métodos `event_level` y `noise_contour` de `AnpAircraft` y `AnpDatabase`; `static_pressure=` en `meteorological_corrections`, `sound_power_anechoic`, `sound_power_reverberation` y `sound_power_comparison`; los campos `AtmosphericAttenuation.pressure`, `AircraftBandAttenuation.pressure` y `ReportMetadata.pressure`, todos en kPa | `static_pressure_kpa=` y `.static_pressure_kpa` |
| `static_pressure=` en `alternating_airflow_resistance`, `barometric_pressure=` en `sound_power_intensity_precision`, `atmospheric_pressure=` en `enclosed_gas_stiffness` y `floating_floor_resonance` | `static_pressure_pa=` |
| `atmospheric_pressure=` en `air_density_iso` (ahora `air_density_iso10534`) y `air_density_astm` (ahora `air_density_astm_e2611`) | `static_pressure_kpa=` en `air_density_iso10534` y `air_density_astm_e2611` |
| `atmospheric_pressure=` en `johnson_champoux_allard` y en las funciones de sonido lento | el `fluid=` que reciben ahora, que lleva su propia presión estática |
| `humidity=`, `relative_humidity=` | `relative_humidity_percent=` |
| `diameter=` y sus trece compuestos | `diameter_m=` |
| `angle=`, `angles=`, `bank_angle=`, `path_angle=`, `grazing_angle=`, `launch_angles=` | `_deg=` o `_rad=`, según lo que lea la función |
| `runway_gradient=` | `runway_gradient_ratio=` |
| `sound_speed_gradient=` | `sound_speed_gradient_per_s=` |

La presión del medio tiene un solo nombre. `static_pressure_kpa` o
`static_pressure_pa` es la presión absoluta del medio en el que se calcula la
magnitud (el aire, un gas o el agua de mar), en la unidad en la que la escribe su apartado; la presión
de una corriente medida en un conducto es manométrica y lo dice
(`static_gauge_pressure_pa`), o es la `static_pressure_pa` de
`velocity_pressure_pa` y `total_pressure`, cuyas fórmulas la leen así.
`atmospheric_pressure_pa` se reserva para la atmósfera exterior allí donde el
mismo método mide a su lado la presión de una corriente: `pipe_transmission_loss`,
`DownstreamPipe`, `normal_air_density` y `gas_density_kg_m3`.

Un caso merece mención propia porque era una trampa y no una incomodidad.
`critical_angle` era un campo en radianes en un resultado y un parámetro en
grados en las dos funciones que estaban una pantalla más abajo, o sea la misma
palabra para dos cosas separadas por un factor 57. Ahora es
`critical_angle_rad` en el resultado y `critical_angle_deg` en los parámetros.

`transmission_loss=` pasó a `propagation_loss=` sólo en los resultados de sónar
y de propagación numérica submarina. `ReactiveSilencerResult` y
`SoundReductionResult` siguen llamando al suyo `transmission_loss=`, y con
razón: es como lo llaman las normas que hay detrás.

Las funciones de la EN 29052-1 de `materials` siguen la misma regla, con la
unidad de cada magnitud al final de su nombre:

| 3.3.0 | 4.0 |
| --- | --- |
| `apparent_dynamic_stiffness(resonant_frequency=, total_mass_per_area=)` | `resonant_frequency_hz=`, `total_mass_per_area_kg_m2=` |
| `enclosed_gas_stiffness(thickness=)` | `thickness_m=` |
| `installed_dynamic_stiffness(apparent_stiffness, airflow_resistivity, gas_stiffness=)` | `apparent_stiffness_n_m3`, `airflow_resistivity_kpa_s_m2=` sólo por nombre, `gas_stiffness_n_m3=` |
| `natural_frequency(dynamic_stiffness=, mass_per_area=)` | `dynamic_stiffness_n_m3=`, `mass_per_area_kg_m2=` |
| `floating_floor_resonance(resonant_frequency=, total_mass_per_area=, floor_mass_per_area=, airflow_resistivity=, thickness=)` | `resonant_frequency_hz=`, `total_mass_per_area_kg_m2=`, `floor_mass_per_area_kg_m2=`, `airflow_resistivity_kpa_s_m2=`, `thickness_m=` |

La resistividad al flujo es la que se gana la palabra clave. La EN 29052-1 pone
sus umbrales en kPa·s/m², y todas las demás resistividades al flujo de la
biblioteca van en Pa·s/m², una unidad mil veces menor, así que una cifra en
Pa·s/m² pasada por posición caía sin aviso en la rama equivocada del
apartado 8.2; ahora se escribe por su nombre. Y por debajo de 100 kPa·s/m²,
`installed_dynamic_stiffness` ya no toma como cero un término de gas ausente:
la 3.3.0 devolvía $s'_\mathrm{t}$ con `installed_dynamic_stiffness(20e6, 50.0)`,
la Fórmula 6 sin su segundo término, y la 4.0 lanza un error y pide
$s'_\mathrm{a}$.

Las funciones de la ISO 13472-1 de `materials` escriben el micrófono entero y
dan las dos alturas en metros, y dos temperaturas dicen en qué escala están:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `mic_height=` y `source_height=` en todas las funciones de la ISO 13472-1 de `materials` que los toman, y en `plot_insitu_geometry` | `microphone_height_m=`, `source_height_m=` |
| `InsituAbsorptionResult.mic_height` y `.source_height` | `.microphone_height_m` y `.source_height_m` |
| `GasStream.inlet_temperature_k`, en kelvin | `inlet_temperature_c`, en grados Celsius: convierte el número, como enseña la sección de arriba |
| `RoadEmissionCoefficients.temperature_k`, la $K_m$ de CNOSSOS-EU en dB por grado, que se leía como una temperatura en kelvin | `temperature_coefficient_db_per_k`: un coeficiente por grado es por kelvin, el mismo número que por grado Celsius |

Las longitudes llevan su unidad allí donde una segunda unidad se disputa la
palabra. Un espesor va en metros en una capa y en milímetros en la fila del
catálogo de la que se lee, una separación son metros entre dos micrófonos o
hercios entre dos líneas espectrales, una altura son metros sobre el suelo y
decibelios en una meseta de coincidencia, y el paquete de aeronaves lee sus
tablas nivel-potencia-distancia (NPD) en pies y calcula en metros:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `thickness=` en `PorousLayer`, `AirLayer`, `PerforatedPlateLayer`, `MicroperforatedPlateLayer`, `PoroelasticLayer`, `TransferMatrix`, `BarrierInsertionLoss` y en toda función que lo recibía: las de Biot, de cuatro micrófonos, de placa perforada, de resistencia al flujo, de capas elásticas, de revestimientos de suelo, de paneles, de flancos, de transmisión estructural, de SEA y de movilidad puntual, y las funciones que dibujan la geometría; `thickness1=` y `thickness2=` en `junction_transmission`, `junction_wave_parameters`, `right_angle_transmission_coefficient`, `point_connection_coupling_loss_factor`, `JunctionTransmissionResult` y `plot_junction_geometry`; `wall_thickness=`, `lining_thickness=`, `plate_thickness=`, `splitter_thickness=`; `specimen_thickness=` en `plot_dynamic_stiffness_rig` y `sample_thickness=` en `plot_impedance_tube_geometry` | `thickness_m=`, `thickness1_m=`, `thickness2_m=`, `wall_thickness_m=`, `lining_thickness_m=`, `plate_thickness_m=`, `splitter_thickness_m=`, `specimen_thickness_m=`, `sample_thickness_m=` |
| `spacing=` en `sound_intensity` e `IntensityResult`, en las funciones de la IEC 61043 e `IntensityInstrumentComplianceResult`, y en las funciones del tubo de impedancia e `ImpedanceTubeResult` | `spacing_m=` |
| `line_spacing=` en las funciones de tonos de la ISO/PAS 20065 y `ToneAudibilityResult`; `ZoomFFTResult.bin_spacing` | `line_spacing_hz=`; `.bin_spacing_hz` |
| `height=`, `heights=`, `source_height=`, `receiver_height=`, `barrier_height=`, `max_height=`, `height_step=`, `slit_height=`, `plenum_height=`, `drop_height=` y las demás alturas en metros, entre ellas `height_fundamental_frequency(height=)` | el mismo nombre terminado en `_m` |
| `plateau_height=` en `plateau_transmission_loss` y `SoundReductionResult` | `plateau_height_db=` |
| `distance=`, `distances=` y sus compuestos en `aircraft`: `npd_level`, `npd_curve`, `event_level`, `noise_contour`, `noise_fraction`, `AnpNpdCurves`, `AnpDatabase`, `RotorcraftHemisphere`, `hover_ring_hemisphere`, las funciones de propagación de helicópteros y sus resultados | `distance_m=`, `distances_m=`, `reference_distance_m=`, `horizontal_distance_m=`, `scaled_distance_m=`, `query_distances_m=`, `table_distances_m` |
| `ReportMetadata(mic_spacing=, thickness=)` | `microphone_spacing_m=`, `thickness_m=` |
| `center=`, `width=` y `wavelength=` en `FDTD2D.add_plane_wave` | `center_m=`, `half_width_m=` (la semianchura en `1/e`, como `GaussianPulse.half_width_s` lo es en el tiempo) y `wavelength_m=`, junto a las anchuras que el motor cuenta en celdas |

Trece longitudes se escriben además por su nombre, porque llevan valor por
defecto y el nombre es el único sitio donde se ve la unidad:
`npd_curve(query_distances_m=)`, `static_airflow_resistance(thickness_m=)`, los
campos `distance_m`, `spacing_m` y `source_height_m` de `RotorcraftHemisphere`,
`IntensityResult` y `RoadEmissionResult`, los `thickness1_m` y `thickness2_m`
que `JunctionTransmissionResult` guarda para su dibujo, y los `source_height_m`
y `microphone_height_m` de la ISO 13472-1 en `geometric_spreading_factor`,
`geometric_spreading_factor_angle` e `InSituAbsorptionResult`. La sección de
conducto que lee `duct_path` es `{"width_m": a, "height_m": b}`, y
`TABLE_D1_QUANTITIES` nombra `thickness_m` entre las magnitudes que describen
una fila de la Tabla D.1. Las filas de los catálogos conservan `thickness_mm`,
la unidad en la que el catálogo guarda todas sus filas, sea cual sea la que
imprime su fuente, y `vertical_directivity(height=1)` conserva su nombre,
porque 1 o 2 elige una línea de fuente y no es una longitud.

Una tasa, una velocidad y una fase también llevan su unidad. Un coeficiente de
absorción en dB/km junto al coeficiente de absorción adimensional de una pared,
la velocidad de un vehículo en km/h junto a una velocidad del viento en m/s y
una de vuelo en nudos, y una fase en radianes en una función de transferencia
junto a otra en grados en un registro de calibración eran, cada una, la misma
palabra para dos cosas:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `absorption_coefficient` en `PropagationLossResult`, `GaussianBeamResult` y `DetectionRangeResult`, en dB/km | `absorption_db_per_km` |
| `air_absorption_coefficient=` en `sound_power_anechoic` y `meteorological_corrections`, en dB/m | `air_absorption_db_per_m=`, la grafía que usa `CalibrationConditions` |
| `AtmosphericAttenuation.attenuation_coefficient`, en dB/m | `.attenuation_db_per_m` |
| `air_attenuation=` en `sabine_reverberation_time`, `eyring_reverberation_time`, `millington_sette_reverberation_time`, `fitzroy_reverberation_time`, `arau_puchades_reverberation_time`, `reverberation_time_models` e `image_source_rir`, y `SoundAbsorptionMeasurement.air_attenuation` | `air_attenuation_per_m` |
| `attenuation=` en `tube_wavenumber` y `two_microphone_impedance`, en Np/m | `attenuation_np_per_m=` |
| `attenuation_source=` y `attenuation_receiving=` en `plenum_flanking_reduction_index` | `attenuation_source_per_m=` y `attenuation_receiving_per_m=` |
| `speed=` en `road_rolling_noise`, `road_propulsion_noise`, `road_vehicle_sound_power`, `aerodynamic_sound_power` y `roughness_to_frequency`; `RoadTraffic.speed`, `RailwayVehicle.speed` y `RoadSurfaceCoefficients.speed_range`; `railway_source_power(minimum_speed=)`, todos en km/h | `speed_kmh`, `speed_range_kmh` y `min_speed_kmh=`; `RailwayVehicle` toma `speed_kmh=` por su nombre |
| `reference_speed=` en `event_level`, `noise_contour` y `duration_correction`, y `segment_speed=` en `duration_correction` | `reference_speed_m_s=` y `segment_speed_m_s=` |
| `FlightPathKinematics.airspeed` y `.ground_speed`, en m/s | `.airspeed_m_s` y `.ground_speed_m_s` |
| `ground_speed=` en `linear_sound_speed_profile`, `log_linear_sound_speed_profile`, `ray_curvature_radius` y `shadow_zone_distance`, la velocidad del sonido junto al suelo | `ground_speed_of_sound=` |
| `RayTraceResult.profile_speeds` | `.profile_speeds_of_sound` |
| `blade_passing_frequency(rotational_speed=)` | `rotational_speed_rpm=` |
| `.phase` en `FrequencyResponseResult`, `CrossSpectralDensityResult`, `PhaseDecompositionResult`, `EnvelopeResult` y `MobilityResult`; `.minimum_phase` y `.excess_phase` en `PhaseDecompositionResult`; `CrossSpectralDensityResult.phase_std`, todos en radianes | `.phase_rad`, `.min_phase_rad`, `.excess_phase_rad` y `.phase_standard_deviation_rad` |
| `residual_index_from_phase_mismatch(phase_mismatch=)` e `IntensityInstrumentComplianceResult.phase_mismatch()`, en grados | `phase_mismatch_deg=` y `.phase_mismatch_deg()` |

Un nombre tiene además una sola grafía dentro de un paquete. Donde una palabra
era pública a la vez sin unidad y con ella en un mismo paquete, ahora conserva la
unidad si otra unidad compite por ella, como en la primera tabla de abajo, y la
pierde si la palabra solo tuvo nunca una, como en la tabla de «Una grafía por
concepto»:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `RotorcraftHemisphere.azimuth` y `.polar`, `RotorcraftEventResult.azimuth` y `.polar`, en grados | `.azimuth_deg` y `.polar_deg`, como los recibe `hemisphere_source_level` |
| `sae_band_attenuation(path_length=)` (ahora `band_attenuation_arp5534`) y `AircraftBandAttenuation.path_length` | `path_length_m` |
| `gap=` en `double_wall_transmission_loss`, `mass_spring_mass_resonance` y `plot_double_wall_geometry`, y `SoundReductionResult.gap`, en metros | `gap_m`, junto al `gap_mm` de una serie de juntas |
| `HeavyImpactSourceSpec.tolerance` y `HeavyImpactSourceCheck.tolerance`, en dB | `.tolerance_db` |
| `LoudspeakerCharacteristics.input_voltage` y `loudspeaker_characteristics(input_voltage=)`, `MicrophoneNoise.voltage` | `input_voltage_v` y `voltage_v`, como los escriben los registros de bucle de inducción |
| `LoudspeakerCharacteristics.rated_frequency_range`, `MicrophoneCharacteristics.reference_frequency` y `microphone_characteristics(reference_frequency=)` | `rated_frequency_range_hz` y `reference_frequency_hz`, como los escriben los registros de auriculares |
| `SweptSineDistortionResult.thd`, una razón | `.thd_ratio`, junto al `thd_percent` de los registros de altavoz y de micrófono |
| `roughness_to_frequency(wavelengths=)`, en milímetros | `wavelengths_mm=`, junto al `wavelengths_m` de un espectro de la EN 15610 |
| `sea_water_sound_speed(salinity=, depth=, latitude=)` | `salinity_psu=`, `depth_m=` y `latitude_deg=`, como los reciben `sea_water` y `sea_water_density` |
| `depth=` en `metadiffuser_reflection`, `metadiffuser_polar_response`, `metadiffuser_diffusion_spectrum` y `plot_metadiffuser_panel_geometry`, y `MetadiffuserResult.depth`, en metros | `depth_m`, junto al `depth_mm` de una muestra de techo |
| `DynamicStiffnessResult.resonant_frequency`, `.apparent_stiffness`, `.dynamic_stiffness`, `.gas_stiffness` y `.floor_mass_per_area` | `.resonant_frequency_hz`, `.apparent_stiffness_n_m3`, `.dynamic_stiffness_n_m3`, `.gas_stiffness_n_m3` y `.floor_mass_per_area_kg_m2`, como los reciben las funciones de la EN 29052-1 junto a los MN/m³ que imprime la norma |
| `johnson_champoux_allard(viscous_length=, thermal_length=)`, en metros | `viscous_length_m=` y `thermal_length_m=`, junto a los micrómetros de una fila de catálogo |
| `CorrelationResult.duration` y `correlation_random_error(duration=)`, en segundos | `duration_s`, junto al `duration_hours` de `lex_8h` |
| `LevelCrossingResult.duration` y `PeakStatisticsResult.duration`, en segundos | `.duration_s`, junto al `duration_ms` de una ráfaga tonal de la IEC 61672-1 |
| `RigidMassCalibrationResult.tolerance` y `.deviation`, y `tolerance=` en `seat_transmission` y `mean_of_test_runs`, cifras relativas | `relative_tolerance` y `relative_deviation` |
| `LabAirborneInsulationResult.absorption` y `LabImpactInsulationResult.absorption`, el área A en m² | `.absorption_area` |
| `HelmholtzResonator(neck_length=, neck_side=, cavity_length=, cavity_side=)`; `lattice_step=` en `slit_helmholtz_absorber`, `helmholtz_resonator_impedance`, `critical_coupling_design`, `plot_slit_absorber_geometry` y `SlitResonatorAbsorberResult`; `critical_coupling_design(cavity_length_bounds=)` y `rectangular_duct_properties(side=)` | los mismos nombres terminados en `_m` |
| `width=` en `plane_wave_limit`, `rectangular_duct_cut_on`, `elbow_insertion_loss`, `lined_rectangular_duct_attenuation`, `unlined_rectangular_duct_attenuation` y `hydraulic_diameter` | `width_m=`, junto a su `height_m=` |
| `width=` en `outdoor_attenuation`, `typical_element_mobility`, `slit_transmission_coefficient`, `slit_resonance_frequencies` y `plot_aperture_geometry`, y `ApertureTransmissionResult.width`, en metros | `width_m`, junto al `height_m` de una fachada y al `joint_width_mm` de una junta |
| `AircraftBandAttenuation.coefficient`, en dB/m | `.coefficient_db_per_m`, junto al `coefficient_db_per_100m` de un resultado de la ARP 866A |
| `LoudspeakerCharacteristics.rated_impedance`, `.minimum_impedance` y `.impedance_modulus`, y `loudspeaker_characteristics(rated_impedance=)`; `rated_impedance` y `minimum_load_impedance` en `MicrophoneCharacteristics` y `MicrophoneElectrical`, y `microphone_characteristics(rated_impedance=, minimum_load_impedance=)` de la 3.3.0, todos en ohmios | los mismos nombres terminados en `_ohm`, como los escriben los registros de auriculares y de bucle de inducción junto a las impedancias mecánicas de un pistón, con el mínimo escrito `min_` (`rated_impedance_ohm`, `min_impedance_ohm`, `impedance_modulus_ohm`, `min_load_impedance_ohm`); el par del micrófono se da como `microphone_characteristics(..., electrical=MicrophoneElectrical(rated_impedance_ohm=..., min_load_impedance_ohm=...))` |
| `flow_resistivity=` en `ground_effect`, `atmospheric_parabolic_equation`, `delany_bazley`, `miki`, `johnson_champoux_allard` y `decoupling_frequency`, `PorousMediumResult.flow_resistivity` y `barrier_insertion_loss(ground_flow_resistivity=)`, en Pa s/m² | `flow_resistivity_pa_s_m2` y `ground_flow_resistivity_pa_s_m2`, junto a los kPa s/m² de las clases de suelo de la IEC TS 61400-11-2 y de la EN 29052-1 |

Una constante publicada sigue la misma regla, y la necesita más, porque un
número suelto no tiene más que su nombre para decir en qué está: `10.0` son
hercios, decibelios o una cuenta. La constante que guarda un solo número
termina en su unidad, o en `_DB` cuando está en decibelios, salvo que sea una
cuenta, un factor o una razón; la tabla cuyo nombre dice lo que guarda
(bandas, velocidades, alturas) termina en la unidad de eso. Las constantes que
exportaba la raíz de la 3.3.0 están en la tabla de nombres que ya no están, al
final de esta página; estas son las demás.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `noise_control.ISO7235_GAS_CONSTANT`, 287 J/(kg K) | `ISO7235_AIR_GAS_CONSTANT_J_KG_K` |
| `noise_control.UNIVERSAL_GAS_CONSTANT`, 8314 J/(kmol K) | `IEC60534_MOLAR_GAS_CONSTANT_J_KMOL_K` |
| `noise_control.AIR_SOUND_SPEED_M_S`, `PIPE_SOUND_SPEED_M_S` | `AIR_SPEED_OF_SOUND_M_S`, `PIPE_SPEED_OF_SOUND_M_S` |
| `environment.ROAD_REFERENCE_SPEED`, `RAILWAY_MINIMUM_SPEED`, `TRAM_MINIMUM_SPEED`, `AERODYNAMIC_THRESHOLD_SPEED`, `AERODYNAMIC_REFERENCE_SPEED`, todas en km/h | `ROAD_REFERENCE_SPEED_KMH`, `RAILWAY_MIN_SPEED_KMH`, `TRAM_MIN_SPEED_KMH`, `AERODYNAMIC_THRESHOLD_SPEED_KMH`, `AERODYNAMIC_REFERENCE_SPEED_KMH` |
| `environment.ROAD_REFERENCE_TEMPERATURE` | `ROAD_REFERENCE_TEMPERATURE_C` |
| `environment.ROAD_SOURCE_HEIGHT`, `RAILWAY_SOURCE_HEIGHTS` | `ROAD_SOURCE_HEIGHT_M`, `RAILWAY_SOURCE_HEIGHTS_M` |
| `environment.ROAD_OCTAVE_BANDS`, `RAILWAY_OCTAVE_BANDS`, `RAILWAY_THIRD_OCTAVE_BANDS` | los mismos nombres terminados en `_HZ` |
| `building.LOW_FREQUENCY_BANDS` | `LOW_FREQUENCY_PROCEDURE_BANDS_HZ`, junto a la `environment.LOW_FREQUENCY_BANDS_HZ` de otra norma |
| `building.HEAVY_IMPACT_OCTAVE_BANDS`, `TABLE_F1_OCTAVE_BANDS`, `DB_HR_FREQUENCIES` | los mismos nombres terminados en `_HZ` |
| `building.TAPPING_DROP_HEIGHT`, `TAPPING_HAMMER_RADIUS`, `TAPPING_HAMMER_MASS`, `TAPPING_IMPACT_RATE` | `TAPPING_DROP_HEIGHT_M`, `TAPPING_HAMMER_RADIUS_M`, `TAPPING_HAMMER_MASS_KG`, `TAPPING_IMPACT_RATE_HZ` |
| `building.LOW_FREQUENCY_VOLUME_LIMIT` | `LOW_FREQUENCY_VOLUME_LIMIT_M3` |
| `hearing.AUDIOMETRIC_FREQUENCIES`, `PROTECTOR_OCTAVE_BANDS` | `AUDIOMETRIC_FREQUENCIES_HZ`, `PROTECTOR_OCTAVE_BANDS_HZ` |
| `building.MINIMUM_MULTI_JUNCTION_KIJ`, −5 dB | `MIN_MULTI_JUNCTION_KIJ` |
| `broadcast.DBQPS_REFERENCE`, 0,775 V | `DBQPS_REFERENCE_V` |
| `electroacoustics.CARDIOID_RELATIVE_DIRECTIVITY`, `DEFAULT_STABILITY_MARGIN`, las dos en dB | los mismos nombres terminados en `_DB` |
| `environment.REFERENCE_JOINT_DENSITY`, juntas por metro | `REFERENCE_JOINT_DENSITY_PER_M` |
| `noise_control.ISO7235_ABSOLUTE_ZERO_OFFSET`, 273 K | `ISO7235_ABSOLUTE_ZERO_OFFSET_K` |
| `psychoacoustics.ERB_C1`, en Hz, y `ERB_C2`, por hercio | `ERB_C1_HZ`, `ERB_C2_PER_HZ` |
| `room.COMMUNICATION_SNR`, `PRIVACY_SNR`, las dos en dB | los mismos nombres terminados en `_DB` |
| `vibration.UNCONSTRAINED_BELOW`, el −100 % de la ISO 8041-1 | `UNCONSTRAINED_BELOW_PERCENT`, junto a `CENTRAL_TOLERANCE_PERCENT` y las demás |

Las constantes de los gases enseñan por qué una constante necesita su unidad
tanto como un parámetro. Dos constantes de un mismo paquete compartían las
palabras «constante de los gases» para 287 J/(kg K) y 8314 J/(kmol K), y
`fluids` publica 8,314 J/(mol K) como tercera: tres cifras separadas por
factores de 29 y de 1000 bajo un mismo nombre. Ahora cada una lleva su unidad
entera.

Una señal temporal que es una sola magnitud física se nombra por ella, con su
unidad, como ya hacía `velocity_mm_s` en las funciones de la DIN 4150 y la
DIN 45669; una señal en cualquier unidad es `x`. Solo cambia una llamada que
escribía la señal por su nombre:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `pressure=` en `underwater.sound_pressure_level`, `peak_sound_pressure_level`, `sound_exposure_level`, `pile_strike_metrics`, `single_strike_sel` y `strike_sel_spectrum`, y `PileStrikeResult.pressure` | `pressure_pa` |
| `acceleration=` en `vibration.acceleration_dose`, `spinal_response` y `multiple_shock_assessment` | `acceleration_m_s2=` |
| `force=` en `building.impact_force_exposure_level` y `vibration.injected_power` | `force_n=` |

## Las condiciones y las banderas se escriben por su nombre

Una condición del ambiente o del medio o un factor de calibración que lleva
valor por defecto, y toda bandera booleana pública, son keyword-only. Las
condiciones son la temperatura, la humedad y la presión estática, la velocidad
del sonido y la densidad del medio, y los tres factores de suelo de ISO 9613-2. La regla existe porque el sitio
donde se pierde el significado es la llamada:
`air_attenuation(freqs, 20.0, 50.0, 101.325)` son una temperatura, una humedad
y una presión en un orden que no recuerda nadie, y `bank.filter(x, True)` no
dice cuál de cinco banderas se ha activado. La elección de un método o de un
conjunto de bandas y un recuento (`mode`, `method`, `fraction`, `n`, `seed`)
son opciones, no condiciones, y la regla las deja donde estaban.

El fallo es ruidoso, que es de lo que se trata:

```python
import numpy as np

from phonometry.signals import leq

x = np.random.default_rng(1).standard_normal(4800) * 0.01

try:
    leq(x, 48000)
except TypeError as error:
    print(error)      # leq() takes 1 positional argument but 2 were given
```

Esa llamada merece una segunda mirada. `leq` nunca tuvo `fs`, porque una media
energética no lo necesita, así que en la 3.3.0 el 48000 se ligaba en silencio a
`calibration_factor` y la respuesta salía 93,6 dB alta sin una queja. Ahora es
un `TypeError`, que es lo que siempre debió ser.

```python
print(round(float(leq(x, dbfs=True)), 3))
```

Estas tomaban hasta ahora una condición o un factor de calibración por
posición:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `signals.sound_exposure(x, fs, 8.0, cal)` y `lex_8h(x, fs, 8.0, cal)` | `sound_exposure(x, fs, duration_hours=8.0, calibration_factor=cal)` |
| `psychoacoustics.sharpness_din(x, fs, "free", "din", cal)` | `sharpness_din(x, fs, "free", "din", calibration_factor=cal)` |
| `environment.ground_attenuation(d, hs, hr, bands, gs, gm, gr)` | `ground_attenuation(d, hs, hr, frequencies=bands, ground_source=gs, ground_middle=gm, ground_receiver=gr)`, y `projected_distance=` por su nombre |
| la velocidad del sonido por posición en `IntensityInstrumentComplianceResult.phase_mismatch_deg`, `emission.phase_mismatch_from_residual_index`, `residual_index_from_phase_mismatch`, `environment.fresnel_number`, `spherical_reflection_coefficient`, `room.reflection_density`, `materials.reflected_path_delay`, `spot_tube_upper_frequency` y `spot_microphone_spacing_bounds` | `speed_of_sound=` |
| `noise_control.LiquidPipe(d, t, rho, c, rho_air, c_air)` | `LiquidPipe(internal_diameter_m=d, wall_thickness_m=t, density=rho, speed_of_sound=c, air_density=rho_air, air_sound_speed=c_air)` |
| `underwater.FluidSeabed(rho, c, rho_water)` | `FluidSeabed(density=rho, speed_of_sound=c, water_density=rho_water)` |
| `io.Signal(data, fs, cal)` | `io.Signal(data, fs, calibration_factor=cal)`, y `channel_labels`, `provenance` y `source` por su nombre |
| `simulation.FDTD2D(c, dx, ...)` (3.3.0) y `simulation.ElasticFDTD2D(c_p, c_s, dx, rho=..., ...)` (4.0.0rc1) | `FDTD2D(c=c, dx=dx, ...)` y `ElasticFDTD2D(c_p=c_p, c_s=c_s, dx=dx, rho=..., ...)`: todos los argumentos por su nombre, como toman los suyos `FDTDRun` y `ElasticRun`. `FDTD2D(0.01, 343.0, shape=...)`, con la velocidad y el paso de malla intercambiados, construía un motor de celdas de 343 m y un paso de tiempo de unas cuatro horas |

Un parámetro cuyo nombre lleva su unidad y que tiene valor por defecto se
escribe también por su nombre. `noise_signal(fs, 2.0)` se lee como dos
segundos solo si uno recuerda el orden, y el `_s` que lo dice está en el
parámetro, no en la llamada:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `signals.noise_signal(fs, 2.0)`, `speech.stipa_signal(fs, 18.0)` | `noise_signal(fs, duration_s=2.0)`, `stipa_signal(fs, duration_s=18.0)` |
| `underwater.ship_source_spectrum(12.0, 100.0)` | `ship_source_spectrum(12.0, length_m=100.0)` |
| la duración de cada muestra por posición en `hearing.job_based_exposure` | `sample_duration_hours=` |

Un eje de frecuencias se escribe también por su nombre, allí donde va junto a
los valores que etiqueta. Dos arrays de la misma longitud se ligan en
cualquier orden sin una queja, así que una llamada que los intercambia responde
sobre el eje equivocado en vez de fallar; la propia referencia de la API traía
`weighted_rating_extended(freqs, r)` y `weighted_impact_rating_extended(freqs, ln)`
con las frecuencias donde van los niveles. Los valores siguen siendo
posicionales, en el orden que tenían, y el eje pasa detrás del `*`:

```python
import numpy as np

from phonometry import room, signals

frequencies = np.array([63.0, 125.0, 250.0, 500.0, 1000.0, 2000.0, 4000.0, 8000.0])
levels = np.array([62.0, 56.0, 50.0, 45.0, 41.0, 38.0, 36.0, 35.0])

print(room.noise_criterion(levels, frequencies=frequencies).rating)
smoothed = signals.fractional_octave_smoothing(levels, frequencies=frequencies, domain="db")
print(smoothed.shape)

try:
    room.noise_criterion(levels, frequencies)
except TypeError as error:
    print(error)      # noise_criterion() takes 1 positional argument but 2 were given
```

El eje es `frequencies`, `frequencies_hz` en las dos funciones subacuáticas
cuyas fórmulas se imprimen en kHz, y `frequency` donde una función evalúa una
frecuencia o muchas. Un array cuyo nombre acaba en uno de ellos sigue la misma
regla: las `tone_frequencies` junto a los niveles de tono de ISO/PAS 20065, o
las `critical_frequencies` junto a los índices de reducción vibratoria de
ISO 12354-1. Estas funciones lo tomaban hasta ahora por posición:

- `aircraft`: `hover_ring_hemisphere`, `terrain_screening_adjustment`.
- `building`: `a_weighted_max_impact_level`, `apply_low_frequency_procedure`, `ceiling_attenuation_class`, `equivalent_absorption_length`, `impact_improvement`, `improvement_octave_bands`, `perimeter_absorption_coefficient`, `plate_loss_factor`, `reception_plate_power`, `reciprocity_impact_level`, `resonant_sound_reduction_index`, `structural_reverberation_time`, `structure_borne_power_level`, `tapping_machine_characteristic_power_level`, `tapping_machine_coupling_term`, `total_loss_factor`, `weighted_impact_rating_extended`, `weighted_rating_extended`.
- `electroacoustics`: `loudspeaker_characteristics`, `microphone_characteristics`.
- `emission`: `field_indicators`, `octave_band_levels`, `phase_mismatch_from_residual_index`, `precision_background_correction`, `residual_index_from_phase_mismatch`, `sound_energy_in_situ`, `sound_energy_reverberation`, `sound_power_in_duct`, `sound_power_in_situ`, `sound_power_reverberation`, `velocity_level_from_acceleration`, `verify_intensity_class`.
- `environment`: `assess_tonal_survey`, `spherical_reflection_coefficient`, `tonal_correction`, `wind_turbine_tonality`.
- `hearing`: `hearing_level_to_coupler_spl`.
- `materials`: `diffusion_spectrum`, `equivalent_area_uncertainty`, `measure_sound_absorption`, `one_third_octave_absorption`, `practical_coefficient_uncertainty`, `scattering_coefficient_spectrum`, `sound_absorption_coefficient_uncertainty`.
- `noise_control`: `duct_path`, `room_to_room_transmission`, `splitter_silencer_insertion_loss`.
- `psychoacoustics`: `analyze_spectrum`, `assess_tones`, `combined_tone_level`, `equal_loudness_contours`, `mean_narrowband_level`, `tone_level`.
- `room`: `noise_criterion`, `octave_pair_averages`, `room_criterion`, `room_modal_density`, `room_mode_count`, `single_number_average`.
- `signals`: `fractional_octave_smoothing`, cuyo `fraction` también se escribe ahora por su nombre.
- `underwater`: `monopole_source_level`, `weighted_exposure`.
- `vibration`: `characteristic_phase_deviation`, `convert_frf`, `coupling_loss_factor`, `indirect_transfer_stiffness_result`, `power_injection_clf`, `power_injection_matrix`, `transfer_stiffness_indirect`, `verify_phase_response`, `verify_rigid_mass_calibration`, `verify_weighting`, `weighted_acceleration`.

Un valor posicional que venía detrás del eje sigue siendo posicional y sube un
puesto: `convert_frf(value, f, "mobility", "impedance")` es
`convert_frf(value, "mobility", "impedance", frequency=f)`.

Un eje de longitudes de onda se escribe por su nombre del mismo modo.
`environment.roughness_to_frequency(levels, wavelengths, speed)` es
`roughness_to_frequency(levels, wavelengths_mm=wavelengths, speed_kmh=speed)`:
los niveles de la tabla de rugosidad siguen siendo posicionales, y sus
longitudes de onda se escriben por su nombre con la velocidad que va detrás,
de modo que los km/h de la velocidad quedan también en la línea.
`materials.standing_wave_reflection(swr, x_min1, lam)` y
`standing_wave_normalized_impedance(swr, x_min1, lam)` toman por su nombre la
longitud de onda de cada tono, `wavelength=lam`: es una longitud de la misma
forma que la distancia al primer mínimo que va a su lado, y las dos se ligan en
cualquier orden.

Una función de señal toma por posición las muestras y su frecuencia de
muestreo, y por su nombre la magnitud que dice lo que hace con ellas. Estas
tomaban esa magnitud por posición en la 3.3.0, incluso cuando es una elección,
como el `name` de la ponderación de `apply_weighting`, o un recuento, como un
`order`. La frecuencia de muestreo puede omitirse ahora cuando las muestras son
un `Signal`, que lleva la suya:

| 3.3.0 | 4.0 |
| --- | --- |
| `linkwitz_riley(x, fs, 1000.0, 4)` | `filters.linkwitz_riley(x, fs, frequency=1000.0, order=4)`, con el `frequency` que era `freq` |
| `parametric_eq(x, fs, sections)` | `filters.parametric_eq(x, fs, sections=sections)` |
| `zoom_fft(x, fs, 900.0, 1100.0)` | `signals.zoom_fft(x, fs, f_min=900.0, f_max=1100.0)` |
| `lifter(x, fs, 0.002)` | `signals.lifter(x, fs, cutoff=0.002)` |
| `time_synchronous_average(x, fs, 0.05)` | `signals.time_synchronous_average(x, fs, period_s=0.05)`, el periodo en segundos, como dice ahora su nombre |
| `resample_signal(x, fs, 32000)` | `signals.resample_signal(x, fs, fs_new=32000)` |
| `harmonic_distortion(x, fs, 1000.0, 2)` | `electroacoustics.harmonic_distortion(x, fs, fundamental=1000.0, order=2)` |
| `difference_frequency_distortion(x, fs, 1000.0, 1200.0)` | `electroacoustics.difference_frequency_distortion(x, fs, f1=1000.0, f2=1200.0)` |
| `modulation_distortion(x, fs, 60.0, 7000.0)` | `electroacoustics.modulation_distortion(x, fs, f_low=60.0, f_high=7000.0)` |
| `swept_sine_distortion(recorded, fs, 20.0, 20000.0, 2.0)` | `electroacoustics.swept_sine_distortion(recorded, fs, f1=20.0, f2=20000.0, duration_s=2.0)` |
| `apply_weighting(x, fs, "Wk")` | `vibration.apply_weighting(x, fs, name="Wk")` |
| `sound_intensity(p1, p2, fs, 0.012)` | `emission.sound_intensity(p1, p2, fs, spacing_m=0.012)` |

```python
import numpy as np

from phonometry import io, signals

fs = 8000
x = io.Signal(np.sin(2 * np.pi * 1000.0 * np.arange(fs) / fs), fs)
try:
    signals.zoom_fft(x, fs, 900.0, 1100.0)
except TypeError as error:
    print(error)      # zoom_fft() takes from 1 to 2 positional arguments but 4 were given
zoom = signals.zoom_fft(x, f_min=900.0, f_max=1100.0)
print(zoom.frequencies[np.argmax(zoom.amplitude)])      # 1000.0
```

Un registro que construyes y entregas a una función se escribe por nombre del
mismo modo: `aircraft.RotorcraftHemisphere(freqs, az, po, levels)` es
`RotorcraftHemisphere(frequencies=freqs, azimuth_deg=az, polar_deg=po,
levels=levels)`, y una llamada posicional lanza `TypeError`. Un resultado que
construye la biblioteca y que otra función recibe entero conserva sus campos
donde estaban, porque nadie lo escribe campo a campo.

Todo registro que construyes y entregas a una función toma sus campos por
nombre, no solo los que tienen un eje. Estos los tomaban por posición en la
3.3.0 o en la 4.0.0rc1:

- `aircraft`: `Aerodrome`, `AerodynamicCoefficients`, `ApproachStep`, `DepartureStep`, `FlightConditionInterpolation`, `JetEngineCoefficients`, `PerformanceAircraft`, `PropellerEngineCoefficients`, `RotorcraftGround`.
- `broadcast`: `QuasiPeakBallistics`.
- `building`: `ApertureTransmissionResult`, `BandPath`, `FacadeElement`, `FlankingPath`, `HomogeneousElement`, `LowFrequencyProcedure`, `SoundReductionResult`.
- `electroacoustics`: `LoudspeakerDirectivity`, `LoudspeakerRatings`, `MicrophoneDirectivity`, `MicrophoneElectrical`, `MicrophoneNoise`, `MicrophoneOverload`.
- `emission`: `GradeConditions`, `PrecisionFieldIndicators`, `RoomEnvironment`.
- `environment`: `Barrier`, `DirectivityCorrection`, `EffectiveSoundSpeedProfile`, `GroundFactors`, `NoisePhase`, `PropagationGeometry`, `RailwayTrack`, `RailwayVehicle`, `RegulationLimits`, `RoadDeviceRating`, `RoadEmissionCoefficients`, `RoadSurfaceCoefficients`, `RoadTraffic`, `RollingStock`, `SourceEmission`.
- `filters`: `EQSection`, `FilterDesign`, `LevelCalibration`.
- `fluids`: `Fluid`.
- `hearing`: `ExposureResult`, `HMLRatingResult`, `SNRRatingResult`, `Task`.
- `io`: `BroadcastMetadata`, `SignalOrigin`.
- `materials`: `AbsorptionRatingResult`, `AirLayer`, `BiotWavesResult`, `HelmholtzResonator`, `MembraneLayer`, `MetadiffuserWell`, `MicroperforatedPlateLayer`, `PerforatedPlateLayer`, `PoroelasticLayer`, `PorousLayer`, `PorousMediumResult`.
- `metrology`: `Quantity`.
- `noise_control`: `DesignCriterion`, `DownstreamPipe`, `DuctElement`, `Expander`, `GasStream`, `LiquidPipe`, `LiquidStream`, `LiquidTrim`, `RegimeBoundaries`, `RoomToRoomResult`, `SourceRoom`, `ValveTrim`.
- `simulation`: `ContourPhasors`, `CWSource`, `ElasticBoundaries`, `ElasticRecording`, `ExplosionSource`, `ForceSource`, `GaussianPulse`, `Material`, `PlaneWaveSource`, `SignalSource`.
- `underwater`: `BeamFan`, `FluidSeabed`, `RayTraceResult`, `VolumeAbsorption`, `WestonSeabed`.
- `vibration`: `FaultFrequencyResult`, `FaultLine`, `WeightingVerification`, `ZoneBoundaries`.

`noise_control.DuctElement("Elbow", [0, 1, 2], [41, 39, 36])` es
`DuctElement(label="Elbow", attenuation=[0, 1, 2], self_noise=[41, 39, 36])`.
`io.Signal(x, fs)` es el único registro que conserva por posición sus dos
primeros campos: las muestras y su frecuencia de muestreo son el par que toda
función de la biblioteca recibe así.

## Una grafía por concepto

Los nombres públicos se habían ido repartiendo entre varias grafías de la
misma magnitud, y la 4.0 se queda con la que ya usaba la mayoría. La regla de
las magnitudes que se cuentan en plural es la que seguía casi toda la API: un
campo o un parámetro que guarda un array es `frequencies`, `times`,
`distances` o `levels`, y uno que guarda un solo valor va en singular. Un
argumento vectorizado que admite un número o un array conserva su nombre. Un
eje no lleva la unidad en el nombre, porque su unidad nunca cambia:
`frequencies` va en hercios, `levels` en decibelios y la frecuencia de
muestreo es `fs` en todas las funciones.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `sound_speed` (válvulas de control, medición de silenciadores, regímenes de Weston, ruido ambiente, `FluidSeabed`, `ShipSourceLevelResult`) | `speed_of_sound` |
| `c=` y `rho=` en `sound_intensity`, `c=` en las dos conversiones de desajuste de fase, `phase_mismatch()` (ahora `phase_mismatch_deg()`), `absorption_coefficient_uncertainty` y `monopole_source_level` | `speed_of_sound=`, `density=` |
| `speed_of_sound_m_s=` en `thickness_critical_frequency_product` | `speed_of_sound=` |
| `sample_rate` en el `SignalSource` de FDTD, `STOIResult` e `impact_force_exposure_level` | `fs` |
| `sponge_width=`, `sponge_sides=`, `sponge_reflection=` y `.sponge_width`/`.sponge_sides` en `FDTD2D` y `ElasticFDTD2D` | `absorbing_layer_cells=`, `absorbing_sides=`, `absorbing_layer_reflection=` y `.absorbing_layer_cells`/`.absorbing_sides`, las palabras que usan los registros de una ejecución para la misma capa, como `FDTDBoundaries.absorbing_layer_cells` y `ElasticBoundaries.absorbing_layer_cells`; el valor por defecto sigue siendo 0, sin capa |
| `FDTD2D.plot_geometry(probes=)` en metros (4.0.0rc1) | celdas `(ix, iy)`, como `FDTDRecording.probes`; cada una se dibuja en el centro de celda que anota `FDTDResult.probe_positions`, y una celda fuera de la malla o dentro de un obstáculo se rechaza como la rechaza una ejecución |
| `freq=` en `linkwitz_riley` y `adaptation_term_kc` | `frequency=` y `frequencies=` |
| `band["freq"]` en las filas `bands` de `FilterComplianceResult`, `WeightingComplianceResult` e `IntensityInstrumentComplianceResult`, y `between_nominals["worst_freq"]` en `WeightingComplianceResult` | `band["frequency"]` y `between_nominals["worst_frequency"]` |
| `.frequency` en los resultados que llevan un eje de frecuencias: `IntensityResult`, `FieldIndicators`, `IntensityInstrumentComplianceResult`, `RoomAcousticsResult`, los cinco resultados de auditorio, `ImpedanceTubeResult`, `PorousMediumResult`, `LayeredAbsorberResult`, `DiffuseFieldAbsorptionResult`, `BiotWavesResult`, `SlitResonatorAbsorberResult`, `MetadiffuserResult`, `TransferMatrix`, los dos resultados de ruido de válvulas, `AircraftBandAttenuation`, `AmbientNoiseResult`, `ShipTrafficSpectrum` | `.frequencies` |
| `.band_centers` en las clasificaciones de ISO 717 e ISO 11654 (`WeightedRatingResult`, `ImpactRatingResult`, `ExtendedWeightedRatingResult`, `ExtendedImpactRatingResult`, `AbsorptionRatingResult`), `.centre_frequencies` en `EcmaLoudness`, `EcmaTonality`, `EcmaRoughness`, `EcmaFluctuationStrength` y `MooreGlasbergLoudness`, `.band_frequencies` en `FilterComplianceResult` y `STOIResult`, `.bands_hz` en `RoadDeviceRating` | `.frequencies`, el eje de bandas de todos los resultados |
| `frequency=` con un array: las funciones de transmisión por flancos, `internal_spectrum`, `pipe_transmission_loss`, `expander_noise`, `transfer_matrix_one_load`, `transfer_matrix_two_load`, `TransferMatrix.plot` | `frequencies=` |
| `level=` y `frequency=` con un eje de bandas: `apply_low_frequency_procedure`, `heavy_impact_octave_levels`, `a_weighted_maximum_impact_level`, `standardized_maximum_impact_level`, `ceiling_attenuation_class`, `plenum_flanking_reduction_index`, `single_number_average`, `octave_pair_averages`, `one_third_octave_absorption`, `power_injection_matrix`, `power_injection_clf`, `valve_hydrodynamic_noise`, `indirect_transfer_stiffness_result`, y `frequency_hz=` en `ship_source_spectrum` | `levels=` y `frequencies=` |
| `frequency_hz=` con un array en `weighted_exposure` y `ocean_ambient_noise` | `frequencies_hz=`; la unidad se queda porque las fórmulas que evalúan están impresas en kHz |
| `.time` en `ZwickerLoudness`, `EcmaLoudness`, `MooreGlasbergTimeVaryingLoudness`, los resultados de tonalidad, aspereza y fuerza de fluctuación de ECMA-418-2, `DecayCurve`, `QuasiPeakResult` | `.times` |
| `.level` en `DecayCurve`, `NpdLevelResult`, `NoiseContourResult`, `RotorcraftNoiseContourResult`, `LowFrequencyResult`, `DuctPathStage`, `LateLateralResult`, `TransferStiffnessResult` | `.levels` |
| `.distance` en `NpdLevelResult` y `RotorcraftEventResult` | `.distances_m` |
| `frequencies_hz` en las comprobaciones del instrumento de vibración humana (`WeightingVerification`, `PhaseVerification`, `characteristic_phase_deviation`, `verify_phase_response`), `levels_db=` en `operating_standard_deviation` y `subinterval_level` | `frequencies`, `levels` |
| `sound_speeds` en `EffectiveSoundSpeedProfile` y `sound_speeds=` en `normal_modes`, `ray_trace`, `gaussian_beams` y `parabolic_equation` | `speeds_of_sound` |
| `SoundSpeedProfile.sound_speed` y `.depth` | `.speeds_of_sound` y `.depths` |
| `omc_uncertainty=` en `sound_power_pressure` y `sound_energy_pressure`, `sigma_omc=` en `sound_power_anechoic`, `precision_uncertainty`, `sound_power_in_situ` y `sound_energy_in_situ`, `.sigma_omc` en `InSituSoundPowerResult` | `sigma_omc_db` |
| `level=`, `measured_level=`, `operational_level=` en `sti_from_impulse_response`, `stipa`, `sti_adjusted_for_levels` y `STIResult.adjusted_for_levels` | `levels=`, `measured_levels=`, `operational_levels=` |
| `.passed` en `AircraftSystemComplianceResult`, `QuasiPeakDynamicsResult`, `HeavyImpactSourceCheck`, `RigidMassCalibrationResult` | `.passes`, como en todos los demás verificadores |
| `microphone_characteristics(noise_weighting="CCIR")` (3.3.0, donde la ponderación era una etiqueta libre) y `MicrophoneNoise(weighting="CCIR")` (4.0.0rc1) | `noise=MicrophoneNoise(weighting="468")`, la grafía que usan `weighting_filter` y `weighted_thd` para la curva UIT-R BS.468-4. La ponderación es `"A"` o `"468"`, y `microphone_characteristics` rechaza cualquier otra con `ValueError` |
| `atmospheric_pressure_kpa=` en las funciones de la ISO 9613-1, `atmospheric_absorption`, `outdoor_propagation_attenuation`, `AtmosphericAttenuation`, `AtmosphericConditions`, `sae_band_attenuation` (ahora `band_attenuation_arp5534`), `AircraftBandAttenuation`, `AerodromeAtmosphere`, `RotorcraftAtmosphere`, `impedance_adjustment`, `atmospheric_adjustment`, los métodos de `AnpAircraft` y `AnpDatabase`, `air_density_iso10534` y `air_density_astm` (ahora `air_density_astm_e2611`); `atmospheric_pressure_pa=` en `enclosed_gas_stiffness` y `floating_floor_resonance`; `barometric_pressure_pa=` en `sound_power_intensity_precision`; `absolute_pressure_pa=` en `sea_water_density` | `static_pressure_kpa=` o `static_pressure_pa=`, en la misma unidad |
| `ambient_pressure_pa=` en `normal_air_density` | `atmospheric_pressure_pa=`, la atmósfera exterior junto a la presión estática manométrica del conducto |
| `environmental_ratio_from_absorption(absorption_area_m2=)`, `running_rms_decay_time(integration_time_s=)` y `verify_running_rms_decay(integration_time_s=)` | `absorption_area=` e `integration_time=`, la grafía del resto de sus paquetes |
| `bending_stress(density_kg_m3=)` | `density=`, la grafía del resto de `vibration` |
| `confidence=` en `building.insulation_coverage_factor`, `materials.absorption_coverage_factor`, `sound_absorption_coefficient_uncertainty`, `equivalent_area_uncertainty`, `practical_coefficient_uncertainty`, `weighted_coefficient_uncertainty`, `single_number_rating_uncertainty` y `environment.environmental_expanded_uncertainty`, y `UncertainValue.confidence` | `coverage=` y `.coverage`, la probabilidad de cobertura de la GUM; `confidence` queda para la confianza estadística de un intervalo, como en `signals.power_spectral_density` |

Un `DecayCurve` se lee por nombre, `curve.times` y `curve.levels`, y ya no se
desempaqueta como el par al que sustituyó. Los solvers FDTD conservan `c` y `rho`, que nombran
los mapas en los que están escritas sus ecuaciones.

Una unidad también tiene una sola grafía. Una duración termina en `_s` o en
`_hours`, un ángulo en `_deg`, una velocidad en kilómetros por hora en `_kmh` y
una en nudos en `_kt`, una tasa de decaimiento en `_db_per_s`; `_seconds`,
`_degrees`, `_km_h`, `_knots`, `_db_s` y un `_h` que significa horas ya no
aparecen en ningún sitio de la API pública.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `vibration.phase_tolerance_degrees` | `vibration.phase_tolerance_deg` |
| `ToneBurstResult.burst_seconds` | `.burst_s` |
| `wind_speed_knots=` en `ocean_ambient_noise` y `wind_noise_spectrum`, y `AmbientNoiseResult.wind_speed_knots` | `wind_speed_kt`, la grafía que usan las velocidades de aeronaves |
| `speed_knots=` en `ship_source_spectrum`, y `ShipTrafficSpectrum.speed_knots` | `speed_kt` |
| `GasStream.molecular_mass`, en kg/kmol | `GasStream.molar_mass_kg_kmol`, el nombre que el catálogo de fluidos da a su `molar_mass_kg_mol` por mol |

Una palabra se escribe entera: `ref` es `reference` en todo nombre público que
la abreviaba. SPL, SEL, SNR y RMS se quedan como están, términos del oficio
como `L_max`.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `levels_ref=`, `background_levels_ref=` y `lw_ref=` en `sound_power_comparison` y `sound_energy_comparison` (3.3.0), y en `sound_power_in_situ` y `sound_energy_in_situ` (4.0.0rc1) | `reference_levels=`, `reference_background_levels=` y `reference_sound_power_levels=`, este último como lo escribe `high_frequency_sound_power_comparison` |
| `InSituSoundPowerResult.background_correction_ref`, `.sound_power_level_ref` y `.sound_energy_level_ref` | `.reference_background_correction`, y `.sound_power_level_at_reference_conditions` y `.sound_energy_level_at_reference_conditions`: los niveles con la corrección del anexo C (C2, a las condiciones meteorológicas de referencia), no los de la fuente de referencia |
| `metrology.sensitivity(ref_signal=)` | `reference_signal=` |

La designación de una norma solo aparece en un nombre donde distingue dos
cosas, y entonces se escribe de una sola forma: el organismo unido a su
número, al principio en una constante o una clase y al final en una función.
Donde el módulo ya nombra la norma, la designación desaparece.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `sae_band_attenuation` | `aircraft.band_attenuation_arp5534`, el documento que sigue |
| `itu_r_468_weighting` | `electroacoustics.weighting_bs468` |
| `air_density_astm` y `speed_of_sound_astm`, y `plane_wave_frequency_range_astm` (4.0.0rc1) | `materials.air_density_astm_e2611`, `speed_of_sound_astm_e2611` y `plane_wave_frequency_range_astm_e2611`, junto a `air_density_iso10534` |
| `noise_control.VDI2081_SPECTRAL_CORRECTION` | `noise_control.SPECTRAL_CORRECTION`: el paquete no tiene otra corrección espectral de la que distinguirla, y su propio texto cita la VDI 2081 parte 2 |
| `building.EN_12354_AIR` | `building.EN12354_AIR` |

Un identificador se escribe en inglés estadounidense, e in situ se escribe
`in_situ`. Quien llama escribe cada nombre, así que `center_frequency` en una
función y `centre_frequency` en la siguiente era un `TypeError` que había que
ir a buscar. Los valores que se escriben en la llamada siguen la misma regla:
una opción de un `Literal`, un valor por defecto, la clave de una tabla
publicada y una cadena de una tupla publicada de opciones. `catalogue`
conserva su grafía: también es una variante
estadounidense, todos los nombres la escriben igual y es el formato de archivo
de tus propios catálogos. Una cadena que imprime una fuente conserva lo
impreso, y por eso la superficie de CNOSSOS de abajo sigue siendo
`"optimised brushed down concrete"`. Las opciones cerradas de los motores
FDTD y de sus registros también son un `Literal`: un lado, un campo anotado,
el sentido de avance de una onda plana y el eje de una fuerza, así que un
comprobador de tipos rechaza `free_sides="Top"` antes de la ejecución; en
tiempo de ejecución no cambia nada.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `materials.insitu_reflection_factor`, `insitu_absorption_from_reflection`, `insitu_absorption_coefficient`, `insitu_absorption_spectrum`, `plot_insitu_geometry` e `InsituAbsorptionResult` | `in_situ_reflection_factor`, `in_situ_absorption_from_reflection`, `in_situ_absorption_coefficient`, `in_situ_absorption_spectrum`, `plot_in_situ_geometry` e `InSituAbsorptionResult`, como ya se escribían los demás nombres in situ de la biblioteca |
| `centre_frequency` en `critical_bandwidth`, `tonal_audibility`, `assess_tonal_audibility` y `TonalAssessmentResult` | `center_frequency` |
| `centre=` en `room.filter_bandwidth` y `room.source_directivity_limit` | `center=` |
| `location="centre"` en las movilidades e impedancias puntuales de placas y vigas infinitas de `vibration` | `location="center"` |
| `.unfavourable_sum` en `WeightedRatingResult`, `ImpactRatingResult` y `AbsorptionRatingResult` | `.unfavorable_sum` |
| `vibration.storey_fundamental_frequency(storeys)`, `STOREY_FREQUENCY_MIN_STOREYS`, `STOREY_FREQUENCY_NUMERATOR_HZ`, `STOREY_PERIOD_COEFFICIENT_S` | `vibration.story_fundamental_frequency(n_stories)`, `STORY_FREQUENCY_MIN_STORIES`, `STORY_FREQUENCY_NUMERATOR_HZ`, `STORY_PERIOD_COEFFICIENT_S` |
| `storeys=` y el modelo `"storeys"` en `fundamental_period`, `fundamental_frequency` y `estimate_fundamental_frequency` | `n_stories=` y el modelo `"stories"` |
| `draught=` en `underwater.monopole_source_level` | `draft_m=`, que además dice su unidad |
| `procedure="aeroplane"` en `aircraft.effective_perceived_noise_level` | `procedure="airplane"`, que sigue siendo el valor por defecto |
| `urbanisation=` en `environment.outdoor_quality_objectives` | `urbanization=` |
| `vapour_pressure_pa` en las funciones de la IEC 60534-8-4 de `noise_control` (`differential_pressure_ratio`, `cavitation_differential`, `jet_strouhal_number`, `stage_conditions`, `last_stage_differential`) y en `LiquidStream` | `vapor_pressure_pa` |
| `"water_vapour_mole_fraction"` en la `composition` de `fluids.air()` | `"water_vapor_mole_fraction"` |
| `building.DB_HR_NORMALISED_SPECTRA`, `environment.NORMALISED_RAILWAY_NOISE_SPECTRUM_DB` y `environment.NORMALISED_TRAFFIC_NOISE_SPECTRUM_DB` | `DB_HR_NORMALIZED_SPECTRA`, `NORMALIZED_RAILWAY_NOISE_SPECTRUM_DB` y `NORMALIZED_TRAFFIC_NOISE_SPECTRUM_DB` |
| `simulation.ALUMINIUM` | `simulation.ALUMINUM` |
| `RoadSurface.OPTIMISED_BRUSHED_DOWN_CONCRETE` | `RoadSurface.OPTIMIZED_BRUSHED_DOWN_CONCRETE`, cuyo valor sigue siendo el `"optimised brushed down concrete"` que imprime la tabla F-4 de CNOSSOS-EU |

Una palabra también tiene una sola grafía. Un acrónimo se escribe en mayúsculas
dentro del nombre de una clase, como siempre lo estuvieron `EPNLResult` y
`STIResult`; Ecma, que es el nombre que la organización se da a sí misma y no
un acrónimo, es la excepción (`EcmaLoudness`). `mic`, `lab` y `std` se
escriben enteros. Un recuento es `n_<plural>`, y un límite sobre
uno, `min_n_` o `max_n_` (`min_n_records`, `max_n_arrivals`); una duración
nombra su magnitud antes que su unidad, nunca la unidad sola
(`exposure_duration_years`, `duration_s`, `period_hours`), con el minuto
escrito entero (`assessment_period_minutes`) porque un `_min` final es un
mínimo, y un número de clase, un eje, un número de decimales y una longitud contada en muestras no son
recuentos. `minimum` y `maximum` se
escriben `min` y `max` en todo nombre público, `MIN` y `MAX` en una constante
y `Min` y `Max` en una clase, como los escriben numpy, SciPy, scikit-learn y
Matplotlib, términos consagrados incluidos: los niveles máximo y mínimo Lmax y
Lmin son `max_level` y `min_level` (nunca un `max_db` a secas), el máximo por
intervalo (*Takt*) de DIN 45669-1 y DIN 4150-2 es `TAKT_MAX_FACTOR` y la
reconstrucción de fase mínima es `min_phase`. Una cota de confianza es
`confidence_lower` o `confidence_upper`. Una función que lee una señal temporal la toma primero, como `x`, el nombre que ya
usaban `octave_filter(x, fs)` y el resto de funciones de señal; llamada por
posición, no cambia nada. Los nombres de la raíz de la 3.3.0 que están entre
estos aparecen en la tabla de los nombres que ya no están.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `building.DbHrAssessment`, `DbHrCheck`, `DbHrGlobalIndexResult` y `DbHrRequirement`, `noise_control.HvacWarning`, `underwater.StrikeSelSpectrum` | `DBHRAssessment`, `DBHRCheck`, `DBHRGlobalIndexResult`, `DBHRRequirement`, `HVACWarning`, `StrikeSELSpectrum` |
| el módulo `building.measurement.lab_insulation` | `building.measurement.laboratory_insulation`; importar de `building` no cambia |
| `HMLRatingResult.subject_h`, `.subject_m` y `.subject_l` | `.subject_high`, `.subject_medium` y `.subject_low`, los valores por sujeto junto a `high`, `medium` y `low` |
| `.std` en `TrendTestResult` y `StationarityTestResult`, `TimeDelayResult.delay_std` | `.standard_deviation`, `.delay_standard_deviation` |
| `StationarityTestResult.count` | `.trend_statistic`, el `statistic` de la prueba de tendencia que ejecutó |
| `num_points=` en `verify_filter_class`, y `FilterComplianceResult.num_points` | `n_points` |
| `AnpAircraft.num_engines` y `PerformanceAircraft.engines` | `ANPAircraft.n_engines` y `PerformanceAircraft.n_engines` |
| `blade_count=` en `fan_sound_power`, y el `blades` de `blade_passing_frequency` | `n_blades` |
| `count=` en `precision_positions` | `n_positions=` |
| `count=` en `circular_duct_cut_on` y `rectangular_duct_cut_on`, y `WestonRegimeBoundaries.mode_count` | `n_modes` |
| `count=` en `diffuser_sound_power` | `n_devices=` |
| `harmonics=` en `gear_mesh_frequencies` y `blade_pass_frequencies`, y el `count` de `FaultFrequencyResult.harmonics` | `n_harmonics` |
| `SawtoothBurstTest.burst_count` | `.n_bursts` |
| `room.MAXIMUM_DIRECTIVITY_STEP_DEG`, `MINIMUM_BANDWIDTH_TIME_PRODUCT`, `MINIMUM_DETECTOR_MULTIPLE` y `MINIMUM_REFERENCE_DISTANCE_M`, `noise_control.MAXIMUM_PASSAGE_ASPECT`, `MINIMUM_FLOW_RATES` y `MINIMUM_PRESSURE_DIFFERENCE_PA`, `emission.MINIMUM_BACKGROUND_MARGIN_DB` | `MAX_DIRECTIVITY_STEP_DEG`, `MIN_BANDWIDTH_TIME_PRODUCT`, `MIN_DETECTOR_MULTIPLE`, `MIN_REFERENCE_DISTANCE_M`, `MAX_PASSAGE_ASPECT`, `MIN_FLOW_RATES`, `MIN_PRESSURE_DIFFERENCE_PA`, `MIN_BACKGROUND_MARGIN_DB` |
| `OperatingLine.maximum_deviation`, `maximum_open_loop_gain` y `maximum_level_at_microphone` en `FeedbackStabilityResult`, `maximum_reduction_db=` en `end_reflection_loss`, `LoudspeakerCharacteristics.minimum_impedance`, `minimum_load_impedance` en `MicrophoneCharacteristics` y `MicrophoneElectrical`, `DiscretePointIntensityResult.minimum_positions`, `minimum_speed=` en `railway_source_power` | `max_deviation`, `max_open_loop_gain`, `max_level_at_microphone`, `max_reduction=`, `min_impedance_ohm`, `min_load_impedance_ohm`, `min_positions`, `min_speed_kmh=` |
| `building.a_weighted_maximum_impact_level`, `standardized_maximum_impact_level`, `AWeightedMaximumImpactResult` y `StandardizedMaximumImpactResult` | `a_weighted_max_impact_level`, `standardized_max_impact_level`, `AWeightedMaxImpactResult` y `StandardizedMaxImpactResult`: `max` y `min` en todo nombre público, términos consagrados incluidos |
| `room.minimum_reliable_reverberation_time` y `minimum_receiver_positions` | `min_reliable_reverberation_time` y `min_receiver_positions` |
| `PhaseDecompositionResult.minimum_phase_response` | `.min_phase_response` |
| `maximum_levels=` en `aircraft.event_level` y `noise_contour` | `max_levels=` |
| `ci_lower` y `ci_upper` en `SpectralDensityResult` y `MultitaperSpectralDensityResult` | `confidence_lower` y `confidence_upper`, como en `MethodBSummary` |
| `elements=` en `low_frequency_element_normalized_difference`, y `LowFrequencyElementResult.elements` | `n_elements` |
| `orders=` en `slit_resonance_frequencies`, y el `junctions` de `multi_junction_adjustment` | `n_orders=` y `n_junctions` |
| `open_microphones=` en `feedback_stability` y `open_microphone_correction`, y `FeedbackStabilityResult.open_microphones` | `n_open_microphones` |
| `events=` en `sound_energy_pressure`, `mean_single_event_level`, `sound_energy_in_situ`, `sound_energy_reverberation` y `sound_energy_comparison`, y `.events` en `SoundEnergyResult` y `ReverberationSoundEnergyResult` | `n_events` |
| `reflecting_planes=` en `measurement_positions`, `sound_power_pressure` y `sound_energy_pressure` | `n_reflecting_planes=` |
| `.positions` en `DiscretePointIntensityResult`, y `.positions`, `.subset_positions` y `.additional_positions` en `PartialPowerConcentration` | `.n_positions`, `.n_subset_positions` y `.n_additional_positions` |
| `RollingStock.axles`, `VehicleDescriptor.axles` y el `axles` de `rolling_sound_power` | `n_axles` |
| `sweep_points=` en `verify_weighting_class`, y `WeightingComplianceResult.sweep_points` | `n_sweep_points` |
| `AssumedProtectionResult.subjects` | `.n_subjects` |
| `io.AudioFileInfo.channels` y `.frames` | `.n_channels` y `.n_samples`, las muestras por canal, como en `Signal` |
| `quadrature_points=` en `diffuse_field_absorption`, y `sum_terms=` en `helmholtz_resonator_impedance` y `rectangular_duct_properties` | `n_quadrature_points=` y `n_sum_terms=` |
| `repetitions=` en `predict_diffuser_polar_response`, `predicted_diffusion_spectrum`, `metadiffuser_diffusion_spectrum`, `metadiffuser_polar_response` y `plot_qrd_geometry`, y `DiffuserPolarResponse.repetitions` | `n_repetitions` |
| `cycles=` y `repetitions=` en `signals.tone_burst`, `ToneBurstResult.cycles` y `.repetitions`, y `cycles=` en `vibration.sawtooth_burst` y `signal_burst_indications` | `n_cycles` y `n_repetitions` |
| `trials=` en `metrology.monte_carlo`, y `MonteCarloResult.trials` | `n_trials` |
| el `passages` de `silencer_self_noise`, `valve_style_modifier`, `multihole_incipient_cavitation_ratio` y `uniform_passage_style_modifier`, y el `stages` de `stage_level_correction` | `n_passages` y `n_stages` |
| el `steps` de `FDTD2D.run` y `ElasticFDTD2D.run`, y `max_arrivals=` en `underwater.eigenrays` | `n_steps` y `max_n_arrivals=` |
| `simulation.ContourProbe.samples` y `ContourProbe(sim=...)` | `.n_samples`, de solo lectura, y `engine=` |
| `record_every=` y `decimate=` en `FDTD2D.run` y `ElasticFDTD2D.run`, por posición o por nombre | `snapshot_every=` y `snapshot_decimation=`, los nombres que dan `FDTDRecording` y `ElasticRecording` a las mismas dos cuentas, y como en ellos solo por nombre: `run(400, 10, 2)` es `run(400, snapshot_every=10, snapshot_decimation=2)` |
| `fdtd_simulation(probes=..., snapshot_every=..., snapshot_decimation=...)` | `fdtd_simulation(FDTDRun(..., recording=FDTDRecording(probes=..., snapshot_every=..., snapshot_decimation=...)))`: lo que anota una ejecución acústica es un solo registro, el `recording` de la ejecución, como lo de una elástica es un `ElasticRecording`; una ejecución sin él solo anota su eje temporal, como antes |
| `fdtd_simulation(c, dx, duration, sources=..., ...)` y `elastic_fdtd_simulation(c_p, c_s, dx, duration, sources=..., rho=..., ...)` | `fdtd_simulation(FDTDRun(c=c, dx=dx, duration_s=duration, sources=..., boundaries=simulation.FDTDBoundaries(sides=..., absorbing_layer_cells=...), ...))` y `elastic_fdtd_simulation(ElasticRun(c_p=c_p, c_s=c_s, dx=dx, duration_s=duration, sources=..., rho=..., ...))`: una simulación es un solo registro, con los mismos argumentos, que toma cada campo por su nombre y los comprueba todos al construirse. `duration` es `duration_s`, y los `boundaries=` y `absorbing_layer_cells=` de la ejecución acústica son ahora un solo `FDTDBoundaries`, como los de la elástica son un solo `ElasticBoundaries`; `compute=` se queda en la función. Un argumento mal dado se rechaza donde se escribe la ejecución, con la misma clase y las mismas palabras, salvo que una duración rechazada nombra ahora `duration_s` |
| un `boundaries=` de `elastic_fdtd_simulation` que no es un `ElasticBoundaries`, que fallaba dentro de la ejecución | se rechaza con `TypeError` al construir el `ElasticRun` |
| un `ElasticRecording` con una sonda mal formada, un campo desconocido o repetido o una cuenta de instantáneas mal dada, que solo se rechazaba cuando `elastic_fdtd_simulation` lo ejecutaba; un `recording=` de otro tipo, que fallaba dentro de la ejecución | se rechaza al construir el registro, con la misma clase y las mismas palabras, y una sonda fuera de la malla la sigue rechazando la ejecución; un `recording=` que no es el registro propio de la ejecución (`FDTDRecording` para un `FDTDRun`, `ElasticRecording` para un `ElasticRun`) lanza `TypeError` nombrándolo al construir la ejecución |
| `sidebands=` en `gear_mesh_frequencies` y `induction_motor_frequencies`, el `poles`, el `rotor_bars` y el `slot_harmonics` de `induction_motor_frequencies`, y `lobe_orders=` en `blade_pass_frequencies` | `n_sidebands`, `n_poles`, `n_rotor_bars`, `n_slot_harmonics` y `n_lobe_orders` |
| `years=` en `hearing.nipts` y `htlan` y en `vibration.injury_risk` y `multiple_shock_assessment`, y `.years` en los resultados de la ISO 1999 (`NiptsResult` y `HtlanResult` en la 3.3.0) y en `MultipleShockResult` | `exposure_duration_years`: una duración nombra su magnitud antes que su unidad |
| `environment.NoisePhase.hours` y `hours=` en `evaluation_period_level`; `hearing.Task.duration_range` y `.duration_samples`, en horas | `duration_hours`; `.duration_range_hours` y `.duration_observations_hours`, porque un final en `_samples` se lee como un número de muestras |
| `seconds=` en `room.sweep_signal`, `inverse_filter` y `shaped_sweep_signal`, en `electroacoustics.synchronized_sweep_signal` y `swept_sine_distortion`, en `signals.noise_signal` y en `speech.stipa_signal`; `duration=` en `room.image_source_rir`, `SweptSineDistortionResult.duration`, y `io.Signal.duration` e `io.AudioFileInfo.duration` (4.0.0rc1); `flat_duration=`, `leading_duration=` y `trailing_duration=` en `materials.adrienne_window`, `StationarityTestResult.segment_duration` y `PileStrikeResult.pulse_duration` | `duration_s`, la grafía que ya tenían las demás duraciones en segundos, y `flat_duration_s=`, `leading_duration_s=`, `trailing_duration_s=`, `.segment_duration_s` y `.pulse_duration_s`: una duración termina en su unidad |
| `hours=` en `environment.lden` y `ldn` | `period_hours=`, que pasa a ser keyword-only |
| `assessment_period_min=` en `environment.impulse_prominence`, y `ImpulseProminenceResult.assessment_period_min` | `assessment_period_minutes`: un `_min` final se lee como un mínimo (`f_min`), así que el minuto se escribe entero, como la hora |
| `ReportMetadata.source_positions` y `.receiver_positions` | `.n_source_positions` y `.n_receiver_positions` |
| `signal_in=` en `loudness_ecma`, `tonality_ecma`, `roughness_ecma`, `fluctuation_strength_ecma` y `fluctuation_strength`; `signal=` en `loudness_moore_glasberg_time`, en las medidas de distorsión y de ruido de `electroacoustics` (`thd`, `thd_plus_noise`, `sinad`, `weighted_thd`, `harmonic_analysis`, `harmonic_distortion`, `dynamic_range`, `idle_channel_noise`, `modulation_distortion`, `difference_frequency_distortion`, `total_difference_frequency_distortion`, `dynamic_intermodulation_distortion`), en `impulsive_sound_adjustment` y `sound_pressure_level_history`, en las funciones de vibración humana (`running_rms`, `mtvv`, `vibration_dose_value`, `motion_sickness_dose_value`, `crest_factor`, `apply_weighting`, `apply_band_limiting`) y en `room.plot_excitation` | `x` |
| `tone_freq=` en `tone_to_noise_ratio` y `prominence_ratio` | `tone_frequency=`, que, como `resolution_hz=`, pasa a ser keyword-only |

Una elección se escribe igual allí donde se ofrece. Un conjunto de bandas es el
entero `fraction` que ya recibían `OctaveFilterBank`, `decay_curve` y
`sound_intensity`, `3` para tercios de octava y `1` para octavas; las palabras
`"third"`, `"third-octave"`, `"one-third-octave"` y `"octave"` se rechazan, y
una tabla que se lee por conjunto de bandas se indexa por el mismo entero. Un
campo libre, uno difuso y uno de presión se escriben `"free"`, `"diffuse"` y
`"pressure"`. Una ponderación frecuencial se elige con `weighting`, y la señal
sin ponderar se escribe `"Z"` allí donde se ofrece: en las ponderaciones del
nivel sonoro es la ponderación Z de IEC 61672-1, y en los demás casos es la
respuesta que la norma deja sin ponderar, como la sola limitación de banda del
medidor de vibraciones de DIN 45669-1.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `band=` en `field_incidence_correction`, `mass_law_transmission_loss`, `single_panel_transmission_loss`, `double_wall_transmission_loss`, `orthotropic_transmission_loss`, `short_pulse_mean_square_force`, `tapping_force_spectrum`, `covering_improvement`, `a_weighted_maximum_impact_level` y `cylindrical_shell_modal_density`, y `.band` en `TappingForceResult` y `AWeightedMaximumImpactResult` | `fraction=` y `.fraction`, `3` o `1` |
| `bands=` en `weighted_rating`, `weighted_impact_rating`, `SoundReductionResult.rating`, `facade_sound_reduction`, `normalized_flanking_level_difference`, `normalized_flanking_impact_level`, `calculated_sound_reduction_index`, `reciprocity_impact_level`, `in_situ_element`, `detailed_airborne_prediction` y `detailed_impact_prediction` | `fraction=`; `None` sigue leyendo el conjunto de bandas de los valores donde lo hacía |
| `band_type=` en `sound_power_intensity`, `sound_power_intensity_points`, `position_count_factor` y `determination_standard_deviation` | `fraction=` |
| `bandwidth=` en `tapping_machine_force_level_estimate` | `fraction=` |
| `building.HEAVY_IMPACT_A_WEIGHTING["third"]` y `["octave"]` | `[3]` y `[1]` |
| `"free-field"` y `"diffuse-field"` en `hearing.reference_threshold`, y en `hearing.FIELDS` | `"free"` y `"diffuse"` |
| `curve=` en `filters.weighting_filter` y `WeightingFilter`, `WeightingFilter.curve` y `WeightingComplianceResult.curve` | `weighting=` y `.weighting` |
| `weighted=` en `broadcast.quasi_peak_meter`, y `QuasiPeakResult.weighted` | `weighting="468"` (por defecto) o `weighting="Z"`, y `.weighting` |
| `weighting=None` en `signals.ln_levels` y `sel` | `weighting="Z"`, ahora por defecto |
| `building.PathContribution.fraction`, la parte de la energía transmitida que lleva un camino | `.energy_fraction`, para que `fraction` nombre solo un conjunto de bandas |
| `building.DetailedAirborneResult.fractions` y `DetailedImpactResult.fractions`, la parte de la energía que lleva cada camino en cada banda | `.energy_fractions` |

## Cada nombre público tiene una sola dirección

Unos pocos nombres se podían importar desde un segundo módulo en la 3.3.0 o en
la 4.0.0rc1, o desde un módulo que listaba algo que su paquete no publicaba, y
la base de datos ANP ponía un nombre privado en dos constructores. Cada nombre
tiene ahora una sola dirección, la que devuelve el resolvedor de más arriba, y
ninguno es privado:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `vibration.partial_exposure` | `vibration.daily_exposure`, la función de la que era un segundo nombre. Llamada con el valor y la duración de una sola operación, devuelve la exposición parcial Ai(8) de esa operación, y el número no se mueve |
| las valoraciones ISO 717 que listaba `building.measurement.insulation`: `weighted_rating`, `weighted_impact_rating`, sus formas `_extended`, `weighted_impact_improvement`, `impact_improvement_adaptation_term` y los cuatro resultados de valoración | `building.weighted_rating` y los demás, definidos en `building.measurement.ratings` |
| `LowFrequencyProcedure`, que listaba `building.measurement.insulation` | `building.LowFrequencyProcedure`, definido en `building.measurement.low_frequency` |
| los trasdosados del anexo D de la ISO 12354-1 que listaba `building.prediction.resilient_layers`: `lining_improvement`, `lining_improvement_in_situ`, `lining_resonance_frequency`, `weighted_lining_improvement`, `LiningImprovementResult` | `building.lining_improvement` y los demás, definidos en `building.prediction.linings` |
| `emission.DeclarationForm`; `Grade` y `Surface`, que listaba `emission.sound_power`; `EQFilterType`, que listaba `filters.equalizer` (`metrology.equalizer` en la 3.3.0) | nada que importar: ningún alias de tipo es público. Pasa la cadena que toma el parámetro, por ejemplo `form="single-number"`, y la referencia de la API muestra el `Literal[...]` de cada parámetro donde antes estaba el alias |
| `BASIC_METHOD_MAX_CREST_FACTOR`, que listaba `vibration.human.exposure` | no se publica. `vibration.crest_factor` avisa por encima de 9, el factor de cresta hasta el que la ISO 2631-1 6.2.2 da por suficiente el método básico |
| `REFERENCE_IMPEDANCE`, `REFERENCE_AREA` y `REFERENCE_SOUND_POWER` de `emission.vibration_sound_power`, un módulo sin `__all__` cuyo paquete nunca los publicó | no se publican. Los 400 N·s/m³ y el 1 m² son los valores por defecto de `reference_impedance=` y `reference_area=` en `emission.radiated_sound_power_level`, y el 1 pW es `metrology.REFERENCE_VALUES["gas"]["sound_power"].value` |
| `AnpAircraft(..., _database=db)` y `aircraft._database` | `ANPAircraft(..., database=db)` y `aircraft.database`, que sigue fuera del repr y de las comparaciones |
| `AnpDatabase(..., performance=...)` (4.0.0rc1) | sin `performance=`, cuyo tipo no publicaba nadie: `aircraft.load_anp_database` lee las tablas de actuaciones de una exportación, y una base de datos construida a mano vuela perfiles de punto fijo |

```python
from phonometry import building, vibration

# ISO 5349-2 E.3: la exposición parcial de la desbrozadora, 4,6 m/s² durante 2 h
print(round(vibration.daily_exposure(4.6, 2 * 3600.0), 1))
print(callable(building.weighted_rating), callable(building.lining_improvement))
print(hasattr(vibration, "partial_exposure"))
# 2.3
# True True
# False
```

## Una función se nombra por lo que devuelve, una sola vez

Un cálculo se nombra por la magnitud que devuelve, y un cálculo tiene un solo
nombre. Una unidad se queda en el nombre de una función solo donde esa
magnitud se escribe en más de una unidad (`peak_velocity_from_kb_mm_s`,
`air_power_attenuation_per_m`); un nivel, una corrección, un índice o una
frecuencia no la lleva, porque solo se da en decibelios o en hercios. La raíz
de la suma de cuadrados de incertidumbres independientes es una sola función,
`metrology.combined_standard_uncertainty`, la imprima la norma que la imprima,
y la probabilidad de cobertura de una incertidumbre expandida se escribe
`coverage` allí donde se pide.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `environment.combined_standard_uncertainty(contributions)` | `metrology.combined_standard_uncertainty(contributions)`, con la misma firma y el mismo número; ahora rechaza un par `(u, c)` con `u` negativa |
| `noise_control.combine_stage_levels(80.0, 74.0)`, `noise_control.combine_internal_levels(trim, expander)` | `noise_control.combined_stage_level([80.0, 74.0])`, `noise_control.combined_internal_levels([trim, expander])`: los niveles llegan como una sola secuencia, como los toma cualquier otra suma energética |
| `building.energy_average_level(levels, 0)`, `room.directivity_energy_average(levels, 0)` | `axis=0`, por su nombre |
| `materials.PUBLISHED_AIR` | `materials.ABSORBER_AIR`, el aire seco a 20 °C que los modelos de absorbentes usan por defecto, con los mismos valores. El prefijo `PUBLISHED_` es de los catálogos, y el nombre ya no atribuye ese aire al modelo de Johnson-Champoux-Allard, cuyo libro imprime otro |
| `metrology.combine_uncertainty(model, quantities)` | `metrology.uncertainty_propagation(model, quantities)`, con los mismos argumentos |
| `metrology.expanded_uncertainty(result, 0.95)` | `result.expanded(0.95)`, el método del resultado que recibía |
| `environmental.expanded_uncertainty(u, confidence=0.95)`, la de la ISO 1996-2, que el primer nivel de la 3.3.0 publicaba como `environmental_expanded_uncertainty` | `environment.environmental_expanded_uncertainty(u, coverage=0.95)`, con el mismo número: 2,4 dB para una `u` de 1,2 dB. El `expanded_uncertainty` de primer nivel de la 3.3.0 era otra función, la de la ISO 12999-1, que da 2,352 dB para la misma `u`; la tabla de los nombres que ya no están dice adónde fue |
| `coverage_factor(0.95, one_sided)` en el primer nivel de la 3.3.0 | `building.insulation_coverage_factor(0.95, one_sided=...)`, el factor de la ISO 12999-1 al que remitía. `metrology.coverage_factor(coverage, dof)` es otra función, el factor GUM de la t de Student, que da 1,96 a dos decimales para el 95 % e infinitos grados de libertad y no tiene forma unilateral |

Los nombres de la raíz de la 3.3.0 que esto renombra o retira (`combine_uncertainties`,
`combine_uncertainty`, `expanded_uncertainty`, `combine_linings`,
`combine_subareas`, `combine_partial_exposures`, `combine_age_and_noise`,
`air_attenuation_m`, `attenuation_from_alpha` y
`air_attenuation_coefficient`) están en la tabla de los nombres que ya no
están, al final de esta página.

```python
from phonometry import metrology, noise_control

# ISO 1996-2:2017 Tabla G.2, los cinco productos c_j u_j de una hora junto a una carretera
print(round(metrology.combined_standard_uncertainty([0.59, 0.3, 2.0, 0.40, 0.38]), 2))
print(round(noise_control.combined_stage_level([80.0, 80.0]), 2))
# 2.18
# 83.01
```

## Un nivel o una diferencia de niveles no lleva sufijo de unidad

Un nivel y una diferencia de niveles están en decibelios por definición (un
nivel de sonoridad está en fonios), así que un nombre público cuyo núcleo es
uno de ellos no lleva `_db`, sea un parámetro, un campo, una propiedad, un
método o una constante. El núcleo es el último sustantivo del nombre, pasadas
las palabras que lo califican por detrás (una banda, una ponderación
frecuencial, `before` o `after`, `max` o `min`): un nivel, una pérdida, un
aislamiento, una reducción, un rechazo, una diferencia, una
mejora, una atenuación de un solo valor, una corrección, un ajuste, un
índice, el término de adaptación espectral de la ISO 717, un desplazamiento o
un exceso del nivel que el nombre nombra (`level_shift`), o el símbolo impreso
de uno de ellos. Un nombre cuyo núcleo no dice decibelios conserva el sufijo:
una tolerancia, un margen, una incertidumbre, una desviación, un escalón, una
pendiente o una tasa (`tolerance_db`, `background_margin_db`,
`expanded_uncertainty_db`, `slope_db_per_decade`, `attenuation_db_per_m`). La
tabla de un cuaderno sigue mostrando en decibelios un número con ese nombre,
ahora leídos de su núcleo, y un nivel de sonoridad en fonios; un indicador,
un texto, un factor complejo o un registro con uno de esos nombres no muestra
unidad, y un número que el núcleo leería mal (el índice de reflexión de la
EN 1793-5, el A_eta de la IEC 60534-8-3) muestra la suya. Casi todos los
nombres que esto renombra son posteriores a la 4.0.0rc1; los que se
publicaron son estos.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `MicrophoneCharacteristics.sensitivity_level_db`, `diffuse_field_sensitivity_level_db`, `directivity_index_db`, `equivalent_noise_level_db`, `noise_band_levels_db`, `max_spl_db` y `distortion_spl_db`; `MicrophoneNoise.equivalent_level_db`, `MicrophoneOverload.spl_db`, `MicrophoneDirectivity.index_db` | `sensitivity_level`, `diffuse_field_sensitivity_level`, `directivity_index`, `equivalent_noise_level`, `noise_band_levels`, `max_spl`, `distortion_spl`; `equivalent_level`, `spl`, `index` |
| `LoudspeakerCharacteristics.sensitivity_level_db`, `reference_level_db`, `directivity_index_db` y `spl_db`, `spl_db=` en `loudspeaker_characteristics`, `LoudspeakerDirectivity.index_db` | `sensitivity_level`, `reference_level`, `directivity_index`, `spl`, `spl=`, `index` |
| `QuasiPeakResult.level_db`; `level_db=` en `stipa_signal` y `fluctuation_strength_am_noise` | `level`, `level=` |
| `WindowMetricsResult.scalloping_loss_db` y `worst_case_processing_loss_db`, `SynchronousAverageResult.noise_reduction_db`, `ResampledSignalResult.stopband_attenuation_db` y `stopband_attenuation_db=` en `resample_signal` | `scalloping_loss`, `worst_case_processing_loss`, `noise_reduction`, `stopband_attenuation`, `stopband_attenuation=` |
| `EmissionPressureResult.level_db`, `measured_level_db`, `background_correction_db` y `local_correction_db`, los mismos tres parámetros de `emission_sound_pressure_level`, `measured_level_db` y `background_level_db` en `background_noise_correction_at_workstation`, `local_correction_db` en `grade_from_local_correction`, `environmental_correction_db` y `directivity_index_db=` en `environmental_ratio_from_k2` y `environmental_ratio_from_absorption` | `level`, `measured_level`, `background_correction`, `local_correction`, `background_level`, `environmental_correction`, `directivity_index=` |
| `noise_control.MODAL_FILTER_ATTENUATION_DB` | `MODAL_FILTER_ATTENUATION` |
| `emission.MAX_K3_DB` y `GRADE_2_MAX_K3_DB`, el tope de la corrección ambiental local $K_3$ y su cota del grado 2 | `MAX_K3`, `GRADE_2_MAX_K3` |
| `sound_reduction_index_db` en `environment.airborne_insulation_rating` | `sound_reduction_index` |

```python
from phonometry import signals

metrics = signals.window_metrics("hann")
print(round(metrics.scalloping_loss, 2), round(metrics.worst_case_processing_loss, 2))
# 1.42 3.18
```

## Un nombre dice la magnitud que guarda

Un nombre que ponía `_db` tras palabras que sólo lo califican (`corrected_db`,
`floor_db`, `threshold_db`, `mean_db`) decía la unidad de un número y nunca
qué es ese número. Cada uno lleva ahora el sustantivo de lo que guarda. Un
nivel toma `level` o `levels` y pierde luego su `_db` por la regla de la
sección anterior (`threshold_level`, `corrected_levels`, `emission_levels`),
una diferencia de niveles toma su propio sustantivo
(`floor_level_difference`, `mean_attenuation`, `min_isolation`) y cualquier
otra magnitud conserva `_db` tras su sustantivo (`fixture_uncertainty_db`,
`lower_tolerance_db`, `prominence_limit_db`). Un nombre sin decibelios toma
también el sustantivo de su magnitud: una tolerancia es un límite que un valor
tiene que respetar, y ningún valor tiene que respetar el ± 50 % que
ISO 4866 D.2 considera típico de una predicción empírica de la frecuencia
fundamental de un edificio, así que se llama error. La mayoría de estos
nombres son posteriores a 4.0.0rc1; los que se publicaron son estos.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `psychoacoustics.ToneAssessment.criterion_db` | `prominence_limit_db` |
| `signals.WindowMetricsResult.highest_sidelobe_db` | `highest_sidelobe_level` |
| `broadcast.KWeightingResponse.shelf_db` y `highpass_db` | `shelf_magnitude_db` y `highpass_magnitude_db`, junto a `magnitude_db` |
| `signals.LifterResult.liftered_db` | `liftered_spectrum_db`, junto a `spectrum_db` |
| `operating_db=` en `emission.total_standard_deviation` | `sigma_omc_db=`, el nombre que toda función de potencia sonora da a la desviación típica de las condiciones de funcionamiento y montaje |
| `polar_db` de `electroacoustics.MicrophoneCharacteristics` y `electroacoustics.LoudspeakerCharacteristics` | `polar_response_db` |
| `vibration.EMPIRICAL_FREQUENCY_TOLERANCE` | `EMPIRICAL_FREQUENCY_ERROR`, el mismo 0,5, junto a la `empirical_frequency_bounds` que lo aplica |

```python
from phonometry import emission, signals

print(round(signals.window_metrics("hann").highest_sidelobe_level, 1))
# -31.5
print(emission.total_standard_deviation(1.5, sigma_omc_db=2.0))
# 2.5
```

## Un módulo nunca queda oculto tras una función de su mismo nombre

Veintitrés módulos de la 4.0.0rc1 compartían nombre con la función que su
paquete publicaba: `signals/correlation.py` estaba junto a
`signals.correlation()`. El atributo del paquete es la función, así que
`import phonometry.signals.correlation as m` ligaba la función,
`signals.correlation.time_delay` lanzaba `AttributeError` y sólo `from
phonometry.signals.correlation import time_delay` llegaba al módulo. Todos esos
módulos son ahora privados. La función conserva su nombre, cada nombre que el
paquete publicaba desde el módulo conserva su dirección, y lo único que
desaparece es el import a través de la ruta del fichero:

| 4.0.0rc1 | 4.0 |
| --- | --- |
| `from phonometry.signals.correlation import time_delay` | `from phonometry.signals import time_delay` |
| `from phonometry.fluids.air import air` | `from phonometry.fluids import air`, o `fluids.air(...)` tras `from phonometry import fluids` |
| `broadcast.program_loudness`, `emission.sound_power_anechoic`, `emission.sound_power_in_duct`, `emission.sound_power_in_situ`, `emission.sound_power_intensity`, `emission.sound_power_intensity_points`, `emission.sound_power_reverberation`, `fluids.air`, `materials.absorbers.airflow_resistance`, `noise_control.duct_path`, `psychoacoustics.quality.fluctuation_strength`, `psychoacoustics.quality.fluctuation_strength_ecma`, `psychoacoustics.quality.roughness_ecma`, `psychoacoustics.quality.tonality_ecma`, `psychoacoustics.quality.tone_audibility`, `room.crowd_noise`, `room.impulse_response`, `signals.cepstrum`, `signals.correlation`, `signals.envelope`, `underwater.propagation.seabed_reflection`, `vibration.structural.junction_transmission`, `vibration.structural.radiation_efficiency` como rutas de módulo | el paquete que precede al último punto, que publica la función y sus compañeras: `from phonometry.room import impulse_response, mls_impulse_response` |
| los números que esos módulos guardaban para sí: los umbrales y las duraciones de bloque de `broadcast.program_loudness` (`ABSOLUTE_GATE`, `RELATIVE_GATE`, `BLOCK_DURATION`, `BLOCK_OVERLAP`, `SHORT_TERM_DURATION`, `MAX_METER_STEP`, `LRA_RELATIVE_GATE`, `LRA_PERCENTILES`), `DEFAULT_SELF_NOISE_FLOOR` de `noise_control.duct_path`, y `SIGMA_NARROWBAND_LEVEL` y `COVERAGE_FACTOR_90` de `psychoacoustics.quality.tone_audibility` | no se publican, como antes: sus paquetes nunca los recogieron. Cada uno sale del documento que sigue su módulo, y la función que lo lee lo aplica o lo toma como valor por defecto de `self_noise_floor=`, `sigma_level_db=` o `coverage_factor=`. El paso de 0,1 s es el periodo de la frecuencia de actualización de 10 Hz que exige la EBU Tech 3341, y el suelo de 0 dB es el valor por defecto de la hoja de cálculo de conductos de *Architectural Acoustics* de Long |
| los umbrales de prominencia `PROMINENT_TONALITY_TU_HMS`, `PROMINENT_ROUGHNESS_ASPER` y `PROMINENT_FLUCTUATION_STRENGTH_VACIL` de los módulos de la ECMA-418-2 | `psychoacoustics.PROMINENT_TONALITY_TU_HMS`, `psychoacoustics.PROMINENT_ROUGHNESS_ASPER` y `psychoacoustics.PROMINENT_FLUCTUATION_STRENGTH_VACIL_HMS`, el último con el `_HMS` de su unidad, porque `psychoacoustics` publica también la intensidad de fluctuación de Osses en vacil a secas. Ninguna función los aplica: compara tú el resultado. El apartado 6.3 de la ECMA-418-2 considera prominente una tonalidad cuando, en un sonido estacionario, `specific_tonality` supera 0,4 tu_HMS en un máximo local cuya entrada de `tonal_frequencies` cae entre las frecuencias centrales situadas un Bark_HMS por debajo y por encima, o, en un sonido no estacionario, cuando `tonality` supera 0,4 tu_HMS. El apartado 7.2 considera prominente una aspereza cuando `roughness` supera 0,2 asper, y el apartado 9.2 una intensidad de fluctuación cuando `fluctuation_strength` supera 0,2 vacil_HMS |

En la 3.3.0 varios de ellos vivían en otro sitio (`metrology/correlation.py`,
`psychoacoustics/tone_audibility.py`); también allí la respuesta es importar
del paquete.

`signals.test_signals` (4.0.0rc1) también es privado, por otro motivo: pytest
recoge un módulo cuyo nombre empieza por `test_`, y el prefijo es de los
ficheros de test. Cada función que contenía conserva su dirección en
`signals.`, así que `from phonometry.signals.test_signals import noise_signal`
es `from phonometry.signals import noise_signal`.

Los alias de tipo que definían esos módulos se fueron con ellos, y ya no hay
ruta pública que llegue a ellos: `PrecisionSurface`, `PrecisionArray` y
`PrecisionRoom` de `emission.sound_power_anechoic`, `MicrophoneShield` de
`emission.sound_power_in_duct`, `Grade` y `BandType` de
`emission.sound_power_intensity`, y `DeterminationGrade` y `BandType` de
`emission.sound_power_intensity_points`. Anota con el `Literal` que
representaba cada uno: `Literal["sphere", "hemisphere"]` para
`PrecisionSurface`, y así con los demás. `BandType` nombraba un conjunto de
bandas, que ahora es el entero `fraction`: `Literal[1, 3]`.

```python
from phonometry import room, signals

print(callable(signals.correlation), callable(signals.time_delay))
print(callable(room.impulse_response), callable(room.mls_impulse_response))
# True True
# True True
```

### Y todo módulo público dice lo que publica

Un módulo sin `__all__` no dice cuáles de sus nombres son públicos, así que una
constante que definía para su propio uso parecía tan pública como sus
funciones, y algunas llegaron a las guías y a los scripts por la ruta completa
del módulo. Todo módulo público lista ahora lo que define y su paquete publica,
y lo demás que define lleva un guion bajo delante. Estos nombres se alcanzaban
así en la 3.3.0 o en la 4.0.0rc1 y ya no:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `OCTAVE_BANDS`, `NC_INDICES` y `NC_CURVES` de `room.noise_criteria` (`room.room_noise` en la 3.3.0) | `room.NC_OCTAVE_BANDS_HZ`, `room.NC_RATINGS` y `room.NC_CURVE_LEVELS`, publicados con su unidad: las diez bandas de la tabla 1 de la ANSI/ASA S12.2, sus doce designaciones y sus niveles por banda |
| `BAND_CENTERS`, `BAND_IMPORTANCE`, `REFERENCE_INTERNAL_NOISE` y `VOCAL_EFFORTS` de `speech.sii` (`hearing.sii` en la 3.3.0) | `speech.sii_procedure("one-third-octave")`, cuyos `frequencies`, `band_importance` e `internal_noise` son los mismos arrays, y `speech.standard_speech_spectra().vocal_efforts` |
| `NIPTS_FREQUENCIES` de `hearing.noise_induced_hearing_loss` | las `frequencies` del resultado de `hearing.nipts(...)` |
| `VALIDATED_YEARS`, `VALIDATED_FRACTILES` y `VALIDATED_L_EX_MAX` del mismo módulo | no se publican. `nipts` y `htlan` avisan fuera de los 1 a 40 años, los fractiles de 0,05 a 0,95 y los 100 dB que valida la ISO 1999 |
| `OCTAVE_BANDS` de `noise_control.hvac` y de `room.enclosed_space_absorption` | no se publican: cada uno es el eje de bandas por defecto de sus funciones, y todo resultado lleva sus `frequencies` |
| `SPEED_OF_SOUND`, `AIR_ATTENUATION` y `PUBLISHED_AIR_CONDITION` (`DEFAULT_AIR_CONDITION` en la 3.3.0) de `room.enclosed_space_absorption` | no se publican: los 345,6 m/s por defecto de `speed_of_sound=`, y las seis condiciones que admite `air_condition=`, que su docstring enumera, con `"20C_50-70"` como la que recomienda el apartado 4.3 |
| `REFERENCE_VELOCITY`, `REFERENCE_FORCE`, `REFERENCE_SOUND_POWER` y `FREE_VELOCITY_REFERENCE` de `building.measurement.structure_borne_power` (`building.structure_borne_power` en la 3.3.0), y `REFERENCE_PRESSURE` de `environment.assessment.impulsive_sound` (`environmental.impulsive_sound` en la 3.3.0) | el `.value` de la entrada de `metrology.REFERENCE_VALUES` de la que se leía cada uno, porque la entrada es un registro y no un número: `["solid"]["velocity"].value` (1 nm/s), `["solid"]["force"].value` (1 µN), `["gas"]["sound_power"].value` (1 pW), `["solid"]["velocity_alternative"].value` (los 50 nm/s de la nota b de la tabla 3, la referencia de velocidad libre de la ISO 9611) y `["gas"]["sound_pressure"].value` (20 µPa) |
| `REFERENCE_MOBILITY` y `CHARACTERISTIC_PLATE_MOBILITY` de `building.measurement.structure_borne_power` (`building.structure_borne_power` en la 3.3.0), y `REFERENCE_PLATE_MOBILITY` de `building.prediction.installed_structure_borne` (`building.installed_structure_borne` en la 3.3.0) | no se publican. `REFERENCE_MOBILITY` es la movilidad de referencia de 1 m/(N s) del apartado 5 de la EN 15657, que las funciones aplican en sus fórmulas (15), (17) y (18); la movilidad de la placa es el valor por defecto de `characteristic_mobility=` y de `plate_mobility=` |
| `SPEED_OF_SOUND`, `AIR_DENSITY`, `REFERENCE_FREQUENCY`, `REFERENCE_LENGTH` y `MAX_RADIATION_FACTOR` de `building.prediction.detailed_model` | no se publican. El aire es `building.EN12354_AIR`, que lleva los 340 m/s y los 1,29 kg/m³ |
| los coeficientes, límites y valores por defecto de `environment.assessment.impulsive_sound` (`environmental.impulse_prominence` y `environmental.impulsive_sound` en la 3.3.0): `PROMINENCE_COEFFS`, `ADJUSTMENT_SLOPE`, `ADJUSTMENT_THRESHOLD`, `ONSET_RATE_LIMIT`, `DEFAULT_ASSESSMENT_PERIOD_MIN`, `ONSET_GRADIENT_LIMIT`, `TIME_WEIGHTING_F_TAU`, `MERGE_GAP`, `SAMPLE_INTERVAL_RANGE`, `DEFAULT_SAMPLE_INTERVAL`, `HIGHLY_IMPULSIVE_LIMIT` | no se publican: cada uno lo aplica `impulse_prominence` o `impulsive_sound_adjustment`, y los dos valores por defecto son los de `dt=` (20 ms) y `assessment_period_minutes=` (30 min) |
| las constantes del anexo C de `vibration.human.multiple_shock` (`vibration.multiple_shock_vibration` en la 3.3.0): `MZ_MALE`, `MZ_FEMALE`, `DOSE_AMPLITUDE_FACTOR`, `DOSE_EXPONENT`, `GRAVITY`, `ULTIMATE_STRENGTH_INTERCEPT`, `STRENGTH_AGE_SLOPE_MALE`, `STRENGTH_AGE_SLOPE_FEMALE`, `WEIBULL_MALE`, `WEIBULL_FEMALE`, `RISK_THRESHOLDS_MALE`, `RISK_THRESHOLDS_FEMALE` | no se publican: las funciones toman `sex=` y aplican la pareja que nombra. `compression_dose(..., mz=)` toma por defecto 0,029, el valor masculino de la fórmula C.2; pasa 0,025 para el femenino |
| `DEFAULT_HEADWIND_KT` y `APPROACH_WEIGHT_FRACTION` de `aircraft.flight_performance` | no se publican: los 8 kt por defecto de `Aerodrome(headwind_kt=)`, y el 0,9 del peso máximo de aterrizaje con el que se vuela la aproximación |
| `STANDARD_ATMOSPHERIC_PRESSURE` de `materials.resilient.dynamic_stiffness` (`materials.dynamic_stiffness` en la 3.3.0) | no se publica: los 0,1 MPa por defecto de `static_pressure_pa=` |
| `REFERENCE_SPACING` de `emission.intensity_compliance` | no se publica: la separación nominal de micrófonos de 25 mm de la Tabla 2 de IEC 61043, el valor por defecto de `spacing_m=` de `residual_index_limits` y `verify_intensity_class` |
| `DISTRIBUTIONS` de `metrology.uncertainty` | no se publica: `metrology.Quantity` rechaza un `distribution=` fuera de `"gaussian"`, `"rectangular"`, `"triangular"` y `"u-shaped"` y nombra las cuatro |
| `CIRCULAR_EIGENVALUES`, `PLANE_WAVE_EIGENVALUE` y `warn_above_plane_wave_limit` de `noise_control.duct_modes` | `noise_control.circular_duct_cut_on` y `noise_control.plane_wave_limit`; los resultados del silenciador y del recorrido de conducto lanzan ellos mismos `PlaneWaveWarning` por encima del límite |
| `WALL_ORDER` de `room.image_source` | no se publica: un `absorption=` por pared va en el orden `x0`, `xL`, `y0`, `yL`, `z0`, `zL` |
| `MAX_ENUMERATED_LATTICE` de `room.modes`, `SAMPLE_RATE` de `speech.objective_intelligibility` (`hearing.objective_intelligibility` en la 3.3.0) | no se publican: un límite de la retícula que `room_modes` indica cuando rechaza el cálculo, y los 10 kHz a los que remuestrea `speech.stoi` |
| `AUDIBILITY_THRESHOLD_SONE_HMS` de `psychoacoustics.loudness_ecma` (3.3.0) | `psychoacoustics.AUDIBILITY_THRESHOLD_SONE_HMS`; `psychoacoustics.loudness.ecma.AUDIBILITY_THRESHOLD_SONE_HMS`, su dirección en la 4.0.0rc1, se sigue importando. Ninguna función lo aplica: el apartado 5.1.9 de la ECMA-418-2 considera audible una señal cuando su sonoridad básica total, la sonoridad básica específica sumada en las 53 bandas (fórmula 26), supera 0,01 sone_HMS, y `loudness_ecma` devuelve ese total bloque a bloque como `basis_loudness_vs_time`, el campo con el que se compara hasta su `last_evaluated_block`; su `loudness` es la N de la fórmula 117, no esa suma |
| `J1_FIRST_ZERO` de `electroacoustics.piston` | desaparece: nadie lo leía. Es `scipy.special.jn_zeros(1, 1)[0]` |
| `critical_bandwidth` de `environment.sources.wind_turbine` (`environmental.wind_turbine_noise` en la 3.3.0) | el `critical_bandwidth` del `WindTurbineTonalityResult`. `environment.critical_bandwidth` es otra banda, la de la ISO 1996-2 |
| `reference_sound` de `psychoacoustics.quality.sharpness` (`psychoacoustics.sharpness` en la 3.3.0) | no se publica: la biblioteca construye la señal de ensayo del apartado 6 de la DIN 45692 sólo para fijar su propia normalización. Es un ruido limitado a la banda de 920 a 1080 Hz con 60 dB: pasa `signals.noise_signal(fs, duration_s)` por un filtro paso banda de 920 a 1080 Hz, escálalo a 0,02 Pa de valor eficaz, y `psychoacoustics.sharpness_din` le da 1,00 acum |
| `check_guidance` de `underwater.bioacoustics.weighting` | no se publica. Las funciones que toman `guidance=` rechazan una desconocida, y `underwater.WEIGHTING_GUIDANCE` nombra las conocidas |

Los alias de tipo que definen estos módulos (`NCMethod`, `EventMetric` y los
demás) tampoco se listan, por la regla de más arriba, y se siguen pudiendo
importar como anotaciones.

```python
from phonometry import hearing, room, speech

print(room.NC_CURVE_LEVELS[room.NC_RATINGS == 40][0][:3])
print(round(speech.sii_procedure("one-third-octave").band_importance.sum(), 6))
print(hearing.nipts(95.0, 40.0, 0.9).frequencies[:3])
# [84. 74. 64.]
# 1.0
# [ 500. 1000. 2000.]
```

## Todo `.plot()` toma primero los ejes

El `.plot()` de cada resultado se lee ahora `plot(ax=None, *, ...)`: primero
los ejes, y todo lo demás por su nombre, `language` incluido. Tres no empezaban
por los ejes en la 3.3.0, así que `plot(ax)` les entregaba los ejes al
parámetro equivocado:

| 3.3.0 | 4.0 |
| --- | --- |
| `LoudspeakerCharacteristics.plot("impedance", ax)` | `.plot(ax, quantity="impedance")` |
| `MicrophoneCharacteristics.plot("noise", ax)` | `.plot(ax, quantity="noise")` |
| `TransferMatrix.plot(f, rho_c, ax)` | `.plot(ax, frequencies=f, characteristic_impedance=rho_c)` |

Seis resultados posteriores a la 3.3.0 tomaban `language` por posición en la
4.0.0rc1: las cuatro valoraciones de protectores auditivos y los dos resultados
de intensimetría en baja frecuencia. `plot(ax, "es")` sobre ellos es ahora
`plot(ax, language="es")`, como en todos los demás.

Las funciones auxiliares `plot_*` públicas, que dibujan un dispositivo o una
geometría en vez de un resultado, comparten ahora también una sola forma: lo
que dibujan, por posición, y los ejes, el idioma y los argumentos de estilo,
por su nombre, `plot_x(<datos>, *, ax=None, ..., language="en", **kwargs)`.
Diecisiete tomaban los ejes detrás de sus datos y seis los tomaban primero.
`plot_silencer_geometry` tomaba además cada dimensión como un argumento propio;
ahora toma el `kind` y la `geometry` que guarda un `ReactiveSilencerResult`,
con las dimensiones en un solo mapeo bajo las mismas claves, de modo que el
dibujo se lee como el resultado:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `vibration.plot_plate_geometry(0.8, 0.6, ax)`, `environment.plot_barrier_geometry(ax, source_height=...)` y las otras veintiuna funciones auxiliares `plot_*` públicas | `plot_plate_geometry(0.8, 0.6, ax=ax)`, `plot_barrier_geometry(ax=ax, source_height_m=...)` |
| `noise_control.plot_silencer_geometry("expansion chamber", ax, length=0.3, chamber_area=0.04, pipe_area=0.01)` | `plot_silencer_geometry("expansion chamber", {"length": 0.3, "chamber_area": 0.04, "pipe_area": 0.01}, ax=ax)` |

## Un `.plot()` de varios paneles devuelve una tupla de ejes

Un `.plot()` que dibuja más de un panel devuelve, sin `ax`, una tupla con sus
ejes, el panel de arriba primero, donde la 3.3.0 y la 4.0.0rc1 devolvían un
array de NumPy con ellos. La indexación, el desempaquetado y `len()` funcionan
como antes; los atributos propios del array, no:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `axes = result.plot()`, y luego `axes.shape` o `axes.size` | `len(result.plot())` |
| `result.plot().flat`, `result.plot().ravel()` | la propia tupla: `for ax in result.plot()` |
| `isinstance(drawn, np.ndarray)`, para distinguir varios paneles de unos solos ejes | `isinstance(drawn, tuple)` |

Con `ax`, el gráfico dibuja un panel sobre ellos y devuelve esos ejes, como
antes. Cada caso es ahora una sobrecarga tipada, así que un comprobador de
tipos lee `top, bottom = result.plot()` como dos `Axes` y
`result.plot(ax=ax)` como uno. `ZwickerLoudness.plot()` sin `ax` sigue
devolviendo unos ejes para un resultado estacionario y dos para uno variable
en el tiempo, algo que deciden solo los datos.

Los gráficos que dibujan sobre unos ejes polares lo dicen. `PistonDirectivity`,
`VectorChangeResult` y `DiffuserPolarResponse` devuelven un `PolarAxes`, igual
que `DiffusionResult.plot()` sin `ax`, `DirectivityFactor.plot()` en su vista
`"response"`, y `LoudspeakerCharacteristics.plot()` y
`MicrophoneCharacteristics.plot()` con `quantity="directivity"`. Esos toman un
`PolarAxes` donde lo necesitan; matplotlib tipa como `Axes` simples un subplot
creado con `projection="polar"`, así que quien comprueba tipos lo entrega como
`typing.cast(PolarAxes, ax)`. `DiffuserPolarResponse.plot()` rechaza unos ejes
cartesianos con un `ValueError` que nombra `ax`, como los demás gráficos
polares, donde antes saltaba un `AttributeError` de matplotlib.

## Un array de dimensión cero devuelve un array de dimensión cero

Una función de un número o de un array de ellos devuelve un `float` solo
cuando todos los argumentos que deciden la forma de su resultado son
números, de Python o de NumPy, y un array en cuanto uno de ellos es una
secuencia o un array, donde la 3.3.0 y la 4.0.0rc1 devolvían un `float` para
un array de dimensión cero, y un array de dimensión cero, un escalar de
NumPy o un array de un elemento para números. Trescientas cincuenta y dos
funciones y métodos públicos siguen la regla, entre ellos
`room.room_constant`, `room.critical_distance` y
`fluids.sea_water_sound_speed`, y `vibration.evaluation_zone` la sigue con
la letra de una zona donde las demás dan un `float`, y un resultado complejo
(una movilidad, una impedancia, una función de transferencia) con un
`complex` de Python:

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `room.room_constant(100.0, np.array(0.2))` devolvía el `float` `25.0` | devuelve `array(25.)`; `float(...)` o `.item()` da el número |
| `emission.local_environmental_correction([0.5])` devolvía un `float` para cualquier entrada de un elemento, igual que `emission.environmental_ratio_from_k2`, `emission.environmental_ratio_from_absorption`, y el campo `background_margin_db` y la propiedad `correction` del `WorkstationBackgroundCorrection` que devuelve `emission.background_noise_correction_at_workstation` | cada uno da un array de un elemento; para obtener un número, se pasa `0.5` y no `[0.5]` |
| `electroacoustics.piston_resistance(1.0)` devolvía un `numpy.float64`, igual que `piston_reactance` y `piston_directivity` | devuelve un `float` de Python, sin `.shape` ni `.dtype` |
| `building.mass_law_transmission_loss(500.0, 10.0)` devolvía un array de dimensión cero, igual que otras 61 funciones y métodos que se enumeran abajo | devuelve un `float` de Python; `np.asarray(...)` da un array donde haga falta |
| `materials.absorption_coefficient(4.0, 2.0, 200.0, 11.0)` devolvía un `numpy.float64`, igual que otras 7 que se enumeran abajo | devuelve un `float` de Python, sin `.shape` ni `.dtype` |
| `building.composite_transmission_loss([10.0, 2.0], [40.0, 25.0])` devolvía un array de dimensión cero, igual que `building.total_structure_borne_pressure_level([30.0, 35.0])`, `materials.reverberation_time_uncertainty` y `emission.mean_single_event_level` con `n_events=None` | cada una devuelve un `float` cuando se reduce a un número |
| `building.survey_service_equipment_level([30.0, 31.0, 32.0], 0.5, volume=50.0)` guardaba un array de dimensión cero en `l_xy` y un `numpy.float64` en `l_xy_nt` y `l_xy_n` | los tres niveles son `float` de Python para lecturas sueltas |
| `vibration.sdof_mobility(100.0, 1.0, 1.0e4, 5.0)` devolvía un array `complex128` de dimensión cero, igual que otras 18 funciones que se enumeran abajo | devuelve un `complex` de Python; `np.asarray(...)` da un array donde haga falta |
| `materials.membrane_impedance(500.0, surface_density=1.0)` devolvía un array complejo de un elemento, igual que otras 8 funciones que se enumeran abajo | devuelve un `complex` de Python, y un array de dimensión cero da uno de dimensión cero |
| `building.bending_radiation_factor(500.0, critical_frequency=100.0, length1=4.0, length2=3.0)` devolvía un array de un elemento, igual que otras 69 funciones y métodos que se enumeran abajo, cuya comprobación convertía un número en un array de una dimensión | devuelve un `float` de Python, y un array de dimensión cero da uno de dimensión cero |

Las funciones y los métodos que devolvían un array de dimensión cero para
números son, además de `building.mass_law_transmission_loss`:
`aircraft.MeanGroundPlaneResult.height`; en `building`,
`background_correction`, `low_frequency_level`,
`characteristic_reception_plate_power`, `equivalent_blocked_force_level`,
`equivalent_free_velocity_level`, `source_mobility_from_levels`,
`structure_borne_power_level`, `transmission_loss_from_coefficient`,
`coupling_term`, `coupling_term_force_source`,
`coupling_term_velocity_source`, `installed_power_from_reception_plate`,
`installed_structure_borne_power_level`,
`structure_borne_pressure_level_path`, `structure_to_airborne_adjustment`,
`tapping_machine_characteristic_power_level`,
`tapping_machine_coupling_term`, `tapping_machine_force_level_estimate`,
`force_pulse` y `typical_element_mobility`; en `emission`,
`normal_intensity_from_levels`, `phase_mismatch_from_residual_index`,
`residual_index_from_phase_mismatch`, `background_noise_correction`,
`radiated_sound_power_level`, `radiation_factor`, `velocity_level` y
`velocity_level_from_acceleration`; en `environment`, `air_attenuation`,
`kurze_anderson_attenuation` y `EffectiveSoundSpeedProfile.speed_at`; en
`materials`, `absorption_from_reflection`, `absorption_reference_corrected`,
`air_density_iso10534`, `normalized_diffusion_coefficient`,
`scattering_coefficient`, `speed_of_sound_iso10534`,
`speed_of_sound_iso17497`, `standing_wave_absorption`,
`standing_wave_ratio_from_level`, `standing_wave_reflection_magnitude`,
`statistical_absorption`, `tube_attenuation_constant`,
`absorption_coefficient_uncertainty`, `base_plate_scattering`,
`random_incidence_absorption` y `specular_absorption_coefficient`;
`signals.comb_filter_response`; y en `vibration`,
`corner_transmission_coefficient`, `straight_transmission_coefficient`,
`coupling_loss_factor`, `point_connection_coupling_loss_factor`,
`wave_vibration_reduction_index`, `random_error_percent`,
`transfer_stiffness_level`, `loss_factor`, `beam_bending_wave_speed`,
`plate_bending_wave_speed`, `injected_power` y `phase_tolerance_deg`
(`phase_tolerance_degrees` en la 4.0.0rc1). Los que devolvían un escalar de
NumPy son, además de `materials.absorption_coefficient`:
`building.surface_pressure_intensity_indicator` y
`building.reverberation_index`; `environment.predicted_prominence` y
`environment.impulse_adjustment`; `materials.absorption_area`;
`room.hard_object_absorption`; y `vibration.ultimate_strength`. Un array de
dimensión cero que se dé a cualquiera de ellos devuelve un array de
dimensión cero, y los valores son los mismos.

Los resultados complejos que devolvían un array de dimensión cero para
números son, además de `vibration.sdof_mobility`: en `materials`,
`normalized_surface_impedance`, `normalized_surface_admittance`,
`surface_impedance`, `reflection_factor`, `tube_wavenumber`,
`standing_wave_reflection` y `standing_wave_normalized_impedance`; y en
`vibration`, `sdof_receptance`, `sdof_accelerance`, `convert_frf`,
`infinite_beam_impedance`, `infinite_beam_mobility`,
`infinite_beam_moment_mobility`, `base_transmissibility`,
`blocking_force_ratio`, `transfer_stiffness_direct`,
`transfer_stiffness_indirect` y `seat_to_spine_transfer`. Los que devolvían
un array complejo de un elemento son, además de
`materials.membrane_impedance`:
`environment.spherical_reflection_coefficient`; en `materials`,
`perforated_plate_impedance`, `microperforated_plate_impedance` y
`helmholtz_resonator_impedance`; en `noise_control`, `helmholtz_impedance` y
`quarter_wave_impedance`; `simulation.far_field_from_contour`; y
`underwater.reflection_coefficient`. Los resultados reales que devolvían un
array de un elemento son, además de `building.bending_radiation_factor`: en
`aircraft`, `atmospheric_adjustment`, `diffraction_attenuation`,
`ground_effect_adjustment`, `npd_level` y `ANPNPDCurves.level`
(`AnpNpdCurves.level` en la 3.3.0 y la 4.0.0rc1); en `building`,
`acceleration_level`, `band_mode_count`, `bare_floor_impact_level`,
`calculated_sound_reduction_index`, `direct_impact_level`,
`direct_reduction_index`, `direction_averaged_level_difference`,
`equivalent_absorption_length`, `fast_reverberation_correction`,
`flanking_impact_level`, `flanking_impact_level_from_flanking_level`,
`flanking_impact_level_from_normalized_difference`,
`flanking_reduction_index`, `flanking_reduction_index_from_flanking_level`,
`flanking_reduction_index_from_normalized_difference`,
`floating_floor_improvement`, `forced_radiation_factor`,
`in_situ_equivalent_absorption_length`, `in_situ_impact_level`,
`in_situ_reduction_index`, `in_situ_total_loss_factor`,
`in_situ_velocity_level_difference`, `laboratory_total_loss_factor`,
`modal_overlap_factor`, `normalized_ceiling_attenuation`,
`partition_referenced_reduction_index`, `plate_loss_factor`,
`reciprocity_impact_level`, `resilient_mount_improvement`,
`resonant_sound_reduction_index`, `short_pulse_mean_square_force`,
`structural_reverberation_time`, `total_loss_factor`,
`velocity_level_difference` y `vibration_reduction_index_from_flanking`;
`electroacoustics.weighting_bs468` (`itu_r_468_weighting` en la 3.3.0 y la
4.0.0rc1); en `emission`, `flow_modal_correction` y
`in_duct_reproducibility`; en `environment`, `fresnel_number`
(`environmental.fresnel_number` en la 3.3.0) y `line_source_segment_power`;
en `hearing`, `earphone_reference_level`, `hearing_level_to_coupler_spl` y
`reference_threshold`; `materials.spot_internal_loss_correction`; los
`peak_exceedance` y `peak_density` de `metrology.PeakStatisticsResult`; en
`noise_control`, `band_internal_levels`, `cavitation_distribution`,
`duct_sound_power_level`, `flow_noise_power_level`,
`measured_transmission_loss`, `open_end_reflection_coefficient`,
`open_end_transmission_loss`, `substitution_insertion_loss`,
`transmission_loss_correction` y `turbulent_distribution`; en `underwater`,
`seawater_absorption`, `spreading_loss`, `thermal_noise_spectrum` y
`wind_noise_spectrum`; y en `vibration`, `band_limiting_factors`,
`beam_modal_density`, `cylindrical_shell_modal_density` y
`weighting_factors`. Una secuencia o un array que se dé al argumento que
decide la forma, también de un elemento, devuelve el array que devolvía, y
los valores son los mismos. Un argumento por banda que acompaña a las
frecuencias no decide nada por sí mismo: el tiempo de reverberación
estructural de `building.total_loss_factor` y
`building.equivalent_absorption_length` y el tiempo de reverberación de
`building.plate_loss_factor` (con `frequency=` para las dos primeras en la
4.0.0rc1), dados como una secuencia de un elemento o un array de dimensión
cero junto a una frecuencia numérica, daban un array de un elemento y ahora
dan un `float`. Sin frecuencias, `hearing.reference_threshold` y
`hearing.earphone_reference_level` dan todas las bandas de su tabla, como
antes.

Estas llegaron después de la 4.0.0rc1 y siguen la regla desde el principio,
con un `complex` para números: `electroacoustics.program_signal_filter`; en
`materials`, `microphone_calibration_factor` y
`apply_microphone_calibration`; en `metrology`,
`microphone_acoustic_impedance`, `temperature_transfer_function`,
`air_gap_series_impedance_pa_s_m3`, `free_field_transfer_impedance`, los
`acoustic_impedance_pa_s_m3` y `complex_equivalent_volume_m3` de
`ReciprocityMicrophone` y los `response_at` y `record_response_at` de
`TimeSelectiveResponse`; y en `vibration`, `kb_weighting_response`,
`band_limitation_response` y los `fitted_frf`, `corrected_frf` y
`corrected_mobility` de `SingleModeFitResult`; y con un `float`: en
`electroacoustics`, `band_limit_response`, `field_strength`,
`field_strength_level`, `magnetic_flux_density`, `telecoil_response`,
`AmplifierFrequencyResponse.at` y los `at` y `drive_voltage` de
`LoopImpedance`; en `emission`, `reverberation_parameter`,
`special_room_background_correction`, `air_absorption_np_per_m`,
`free_field_absorption_correction`, `directionality_tolerance`,
`inverse_square_law_tolerance`, `min_analyzer_bandwidth`,
`plant_air_absorption_db_per_m`, `reverberation_background_correction`,
`room_absorption_coefficient`, `room_constant_from_air_absorption`,
`room_constant_from_reverberation_time`, `radiation_impedance_correction`,
`reference_source_reproducibility` y el `sound_power_level_at` de
`ReferenceSourceCalibration`; en `environment`,
`air_power_attenuation_per_m`, `barrier_background_correction` y
`redistributed_band_energies`; en `hearing`, `age_and_noise_threshold`,
`incidence_correction` y `reat_expanded_uncertainty`; en `io`, el
`values_at` de `BandedRow` y de las filas de catálogo de `materials`,
`building` y `noise_control`; en `materials`,
`power_attenuation_from_alpha`, `air_density_astm_e2611`,
`speed_of_sound_astm_e2611`, `in_situ_absorption_from_reflection`,
`air_absorption_correction` y `reproducibility_uncertainty`; en `metrology`,
`max_expanded_uncertainty`, los `level_at` y `spectrum_at` de
`RectangularPulse` y los `level_at` y `phase_deg_at` de
`TimeSelectiveResponse`; en `noise_control`, `flow_velocity_m_s`,
`insertion_level_difference`, `reverberant_surface_area_m2`,
`screen_background_corrected_level`, `silencer_background_correction`,
`silencer_sound_power_level`, `transmission_level_difference` y
`velocity_pressure_pa`; en `room`, `corrected_distribution_value`,
`floor_reference_value`, `level_excess`, `reference_distribution_value` y
`sound_distribution_value`; y en `vibration`,
`assessment_weighting_response`, `blast_peak_velocity_mm_s`,
`elastic_insertion_loss`, `far_field_velocity_mm_s`,
`foundation_to_floor_level_difference`,
`ground_attenuation_coefficient_per_m`, `ground_transmission`,
`impact_peak_velocity_mm_s`, `kb_weighted_levels`,
`machine_count_correction`, `machine_hall_velocity_mm_s`,
`material_damping_factor`, `passage_energy_spectral_density`,
`predict_floor_spectrum`, `rescale_emission_for_speed`,
`spectral_density_level`, `train_kb_fmax`, `train_velocity_ratio`,
`velocity_psd_from_voltage` y `velocity_spectrum_um_s`. Un argumento por
banda junto a las frecuencias de estas, como los niveles de potencia sonora
de `room.sound_distribution_value`, las diferencias de nivel de
`vibration.predict_floor_spectrum` y el exponente de
`vibration.ground_transmission`, no decide nada por sí mismo, y da un
`float` junto a una frecuencia numérica también como una secuencia de un
elemento.

Trescientos dieciséis de ellos tienen sobrecargas tipadas, así que un
comprobador de tipos lee `room.room_constant(100.0, 0.2)` como un `float` y
`room.room_constant(100.0, alphas)` como un array, sea cual sea la forma de
`alphas`; un `ArrayLike` o una lista anidada se lee como la unión, que quien
comprueba tipos estrecha. Las reducciones (`signals.leq` y los demás niveles
de una señal, `building.energy_average_level`,
`room.directivity_energy_average` y sus afines), cuyo resultado es un número
para una entrada de una dimensión, conservan la unión y su comportamiento.
Los cuatro caminos de flanco del modelo detallado de edificación
(`building.flanking_reduction_index`, `building.flanking_impact_level` y sus
dos formas a partir de una diferencia normalizada), cinco o seis de cuyos
argumentos se difunden, y
`building.vibration_reduction_index_from_flanking`, que difunde cinco,
conservan la unión en su firma y siguen la regla al ejecutarse.

Las matrices de cuatro polos de `noise_control` siguen la regla con una
matriz en lugar de un número. `noise_control.duct_matrix(500.0, 0.3, 0.05)`
devolvía una pila de una matriz, de forma `(1, 2, 2)`, igual que
`noise_control.shunt_matrix` para una impedancia; ahora las dos devuelven la
matriz `(2, 2)` sola para un número o un array de dimensión cero, y la pila
`(n_freq, 2, 2)` para una secuencia o un array, también de un elemento, como
antes. `noise_control.cascade` multiplica matrices sueltas en una matriz, lo
que la 4.0.0rc1 rechazaba, y pilas en una pila, y rechaza una matriz suelta
junto a una pila con un `ValueError`; `noise_control.transmission_loss` y
`noise_control.insertion_loss` devuelven un `float` para una matriz suelta,
donde lanzaban un `IndexError`, y un valor por frecuencia para una pila.
`matrix[np.newaxis]` forma una pila de una, que da el array de un elemento
que daba; los valores son los mismos.

## Una frecuencia de muestreo es un `float`, y un recuento admite un entero de NumPy

La frecuencia de muestreo de un `Signal` es el `float` que se le dio, así
que un comprobador de tipos lee `sig.fs` como un `float`, donde leía un
`int`, y toda función que funciona a cualquier frecuencia positiva admite un
`float`: la frecuencia que devuelve una función es la que admite la
siguiente. Las funciones que necesitan un número entero de muestras por
segundo siguen rechazando una fraccionaria: `io.write`, que escribe la
frecuencia en la cabecera del archivo, las señales de prueba de
`electroacoustics`, `electroacoustics.field_strength_meter`,
`room.image_source_rir`, `psychoacoustics.loudness_zwicker`,
`psychoacoustics.sharpness_din`,
`psychoacoustics.psychoacoustic_annoyance_from_signal` y `speech.stoi`.
`vibration.evaluate_train_passage`, `signals.resample_signal` con un `Signal`
y el banco del método B de `environment` también rechazaban una frecuencia
fraccionaria, con el argumento de que el banco de filtros necesitaba una
entera, y no la necesita: funcionan a cualquier frecuencia.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `psychoacoustics.loudness_zwicker(x, sig.fs)` pasaba la comprobación de tipos, con `sig.fs` leído como un `int` | se entrega el `Signal`, `loudness_zwicker(sig)`, o `int(sig.fs)` |
| `io.write(path, io.Signal(x, 44100.5))` fallaba dentro de la cabecera con `struct.error` | lanza `ValueError` nombrando `fs`, como lo hace `fs=44100.5` |
| `filters.OctaveFilterBank(fs, order=2.5)`, `room.mls_signal(10.5)` y los demás recuentos que solo se comprobaban como un número funcionaban con una fracción o un booleano | una fracción lanza `ValueError: 'order' must be a whole number`, un booleano un `TypeError`; se pasa el número entero |
| `emission.sound_intensity(p1, p2, fs, spacing_m=d, fraction=1.0)` funcionaba | lanza `TypeError`, como toda fracción de banda; se pasa `1` o `3` |

Un recuento, una fracción de banda o un indicador admiten el entero o el
valor de verdad de NumPy que admite su validador (`int | np.integer[Any]`,
`BandFraction | np.integer[Any]`, `bool | np.bool_`), y los valores por
banda admiten un mapeo con claves enteras (`{125: 40.0}`) igual que uno con
claves de coma flotante. Un recuento que solo se comprobaba como un número
pasa por la misma comprobación de número entero, así que se rechaza la
fracción o el booleano que antes admitía, como en las filas de arriba. Un
registro de resultado que valida un recuento o una fracción de banda guarda
el `int` que lee, donde guardaba el entero de NumPy tal como se le dio.

## Un parámetro que admite números rechaza un texto antes de que la llamada se ejecute

Un parámetro que admite números se anotaba con el `ArrayLike` de NumPy, que
admite cualquier `str` y cualquier `bytes`, así que
`signals.leq("not a signal")` pasaba la comprobación de tipos de mypy y de
pyright y solo la llamada lo rechazaba. Todo parámetro, campo y constructor
declarado de ese tipo admite ahora `NumericArrayLike`: un número, una
secuencia de números anidada a cualquier profundidad, o un array de NumPy, o
cualquier objeto con un `__array__`, de tipo de dato numérico o booleano, y
ningún texto. Una lista, una tupla, una lista anidada, un array de cualquier
tipo de dato numérico y un `Signal` pasan la comprobación de tipos como
antes, y las llamadas se ejecutan como se ejecutaban.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `signals.leq("not a signal")` pasaba la comprobación de tipos, y la llamada lanzaba `TypeError` | el comprobador de tipos lo rechaza, y la llamada lanza el mismo `TypeError` |
| `levels: ArrayLike = load(); signals.leq(levels)` pasaba la comprobación de tipos | el comprobador de tipos lo rechaza, porque `ArrayLike` dice que puede haber un texto; se anota `levels` con lo que guarda, `NDArray[np.float64]`, `Sequence[float]` o `float` |
| `view = memoryview(samples); signals.leq(view)` pasaba la comprobación de tipos | el comprobador de tipos lo rechaza, como rechaza un array de `ctypes` u otro objeto que ofrece sus números solo por el protocolo de búfer, mientras la llamada se ejecuta como se ejecutaba; se pasa `np.asarray(view)` |

Las etiquetas de `environment.statistical_pass_by` (`vehicle_categories`) y
los `sites` de los resúmenes de paisaje sonoro de `environment` conservan
`ArrayLike`: admiten textos.

## Los veredictos son objetos de resultado, no diccionarios

Las tres funciones `verify_*` de la 3.3.0 devolvían `dict[str, Any]` y ahora
devuelven una dataclase congelada, como cualquier otro resultado de la
biblioteca. `filter_class_compliance`, el envoltorio público que existía solo
para empaquetar el veredicto del filtro, se fue con el cambio, ya que el
verificador devuelve ahora el objeto él mismo. Cada clave del diccionario es un
atributo del mismo nombre, salvo `passed`, que es `passes`, y todo argumento
que va detrás de aquel sobre el que trata la llamada se escribe por su nombre.

| 3.3.0 | 4.0 |
| --- | --- |
| `verify_filter_class(bank)["overall_class"]` | `filters.verify_filter_class(bank).overall_class` |
| `verify_filter_class(bank, 4096)` | `filters.verify_filter_class(bank, n_points=4096)` |
| `verify_weighting_class(wf)["overall_class"]` | `filters.verify_weighting_class(wf).overall_class` |
| `verify_aircraft_noise_system(...)["passed"]` | `aircraft.verify_aircraft_noise_system(...).passes` |
| `filter_class_compliance(bank)` | `filters.verify_filter_class(bank)`, que devuelve el mismo `FilterComplianceResult` |

`verify_intensity_class` y `verify_quasi_peak_dynamics` son posteriores a la
3.3.0, y en la 4.0.0rc1 ya devolvían sus registros.

```python
from phonometry.filters import OctaveFilterBank, verify_filter_class

verdict = verify_filter_class(OctaveFilterBank(48000, fraction=1, limits=[125, 4000]))
print(verdict.overall_class, len(verdict.bands))
```

`verify_running_rms_decay` es posterior a la 3.3.0, y en la 4.0.0rc1 devolvía
un `bool` desnudo, que tiraba el intervalo impreso y el tiempo medido que había
juzgado. Ahora devuelve un `RunningRMSDecayVerification` que conserva los dos:
el veredicto es `.passes`, junto a `.measured_time_s`, `.printed_time_s`,
`.tolerance_s` y el intervalo como `.lower_time_s` y `.upper_time_s`. El objeto
se niega a leerse como valor de verdad, así que un
`if verify_running_rms_decay(...):` escrito contra la versión candidata levanta
`TypeError` en vez de dar por buenos todos los vibrómetros.

## Un veredicto dice `passes`, se niega a ser un valor de verdad y sale de un verbo

Un juicio se nombra por lo que juzga: `verify_` un instrumento, `assess_` una
situación medida, `check_` la disposición que pide un método. Cada uno devuelve
un registro que conserva sus razones, y el apto o no apto se escribe `passes` en
todos ellos. Un registro que devuelve una función de juicio, y todo registro con
un `passes`, se niega a leerse como valor de verdad: `if verdict:` lanza
`TypeError` y el mensaje dice qué leer. En la 3.3.0 y la 4.0.0rc1 estos
registros eran siempre verdaderos, así que un `if` escrito contra ellos daba por
buenos todos los fallos: lee `.passes` en `QuasiPeakDynamicsResult`,
`AircraftSystemComplianceResult`, `WeightingVerification`, `PhaseVerification`,
`SignalBurstVerification`, `DBHRCheck`, `DBHRAssessment`, `ActivityAssessment` y
`PeriodAssessment`; `.overall_class` en `FilterComplianceResult`,
`WeightingComplianceResult` e `IntensityInstrumentComplianceResult`;
`.within_guideline` en `DamageAssessment`, porque superar un valor guía de
DIN 4150-3 no es un fallo; `.qualified` en `PrecisionCriteria`; `.adjustment` en
`TonalAssessmentResult`; y `.decisive_audibility` o `.audible` en
`ToneAudibilityResult`.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `.complies` en `DbHrCheck`, `DbHrAssessment` (ahora `DBHRCheck`, `DBHRAssessment`), `ActivityAssessment` y `PeriodAssessment` | `.passes` |
| `vibration.is_significant_change(change, zone_b_upper)` | `vibration.assess_operational_change(change, zone_b_upper).significant`, junto al `.threshold` contra el que se lee. Un cambio significativo es un motivo para investigar, no un fallo, así que la bandera conserva su nombre |
| `materials.limp_frame_applicable(k_c, criterion=...)` | `materials.check_limp_frame(k_c, criterion=...).passes`, junto a `.ratio` y `.threshold`. Una razón justo en el umbral ya no pasa: Allard y Atalla imprimen los dos criterios como desigualdades estrictas |
| `fi.field_is_stationary(limit=...)` en un `FieldIndicators` | `fi.check_field_stationarity().passes`, y banda a banda su `.stationary`. El límite es el 0,6 de la tabla B.3, que se lee en `.limit`, y ya no es un argumento |
| `room.perceptibly_different(symbol, first, second)` | `room.assess_perceptible_difference(symbol, first, second).different`; los dos valores tienen ahora que tener la misma forma |
| `materials.check_base_plate_scattering(s) == ()` | `materials.check_base_plate_scattering(s).passes`, con las bandas que superan el límite en `.exceeded_frequencies` y, junto a ellas, `.margins`, `.exceeds` y `.limits` por banda. Un coeficiente que no es finito lanza `ValueError`, donde antes pasaba |
| `corrected, limited = building.background_corrected_level(lp, lb)` | `result = building.background_corrected_level(lp, lb)`, y luego `result.corrected_levels` y `result.limited` |
| `k1, held = emission.background_noise_correction_at_workstation(lp, lb)` | `result = emission.background_noise_correction_at_workstation(lp, lb)`, y luego `result.correction` y `result.upper_bound` |

Los nombres de primer nivel de la 3.3.0 que esto renombra
(`rigid_mass_calibration_check`, `satisfies_lower_requirement`,
`satisfies_upper_requirement`, `strong_coupling_satisfied` y
`tonal_seeking_survey`) están en la tabla de los nombres que ya no están, al
final de esta página.

```python
from phonometry import building, materials

conformity = building.assess_requirement_conformity(52.0, 1.5, 50.0, bound="minimum")
print(conformity.passes, conformity.margin_db)
# True 0.5
check = materials.check_base_plate_scattering([0.02] * len(materials.BASE_PLATE_BANDS_HZ))
print(check.passes, check.exceeded_frequencies.size)
# True 0
try:
    bool(check)
except TypeError as error:
    print(type(error).__name__)
# TypeError
```

## El banco de filtros devuelve un resultado, no una tupla

`octave_filter()` y `OctaveFilterBank.filter()` devolvían dos elementos
normalmente y tres cuando `sigbands=True` pedía las señales por banda. La
longitud de la respuesta dependía de una palabra clave, que es la razón por la
que ese par necesitaba doce declaraciones `@overload` para poder tiparse, y por
la que `_, _, bands = bank.filter(...)` era una línea en la que había que contar
comas.

Ahora devuelven un `OctaveFilterResult` con campos con nombre. Las demás
respuestas del banco que eran tuplas también son registros: el espectrograma es
un `OctaveSpectrogramResult`, y el conjunto de bandas sobre el que se diseña el
banco se lee de atributos con el nombre completo.

| 3.3.0 | 4.0 |
| --- | --- |
| `spl, freq = octave_filter(x, fs)` | `r = octave_filter(x, fs)`, y luego `r.levels` y `r.frequencies` |
| `spl, _ = octave_filter(x, fs)` | `octave_filter(x, fs).levels` |
| `_, freq = octave_filter(x, fs)` | `octave_filter(x, fs).frequencies` |
| `_, _, bands = bank.filter(x, sigbands=True)` | `bank.filter(x, sigbands=True).require_bands()` |
| `levels, freq, times = bank.spectrogram(x)` | `r = bank.spectrogram(x)`, y luego `r.levels`, `r.frequencies` y `r.times` (un `OctaveSpectrogramResult`, que se dibuja con `r.plot()`) |
| `bank.freq`, `bank.freq_d`, `bank.freq_u`, `bank.nominal_freq`, `bank.num_bands` | `bank.frequencies`, `bank.lower_edges`, `bank.upper_edges`, `bank.labels`, `bank.n_bands`, de solo lectura: los arrays rechazan la escritura y `labels` es una tupla |

```python
import numpy as np
from phonometry import filters

result = filters.octave_filter(np.zeros(8000) + 1e-6, 8000, fraction=3)
print(len(result.frequencies), result.bands)
# 25 None
```

`bands` es `None` salvo que la llamada haya pedido `sigbands=True`, y `levels`
es `None` en una llamada hecha con `calculate_level=False`. El código que
necesita cualquiera de los dos puede decirlo con `require_bands()` o
`require_levels()`, que devuelven el valor o fallan nombrando el argumento que
faltaba, en vez de entregar un `None` que revienta unas líneas más adelante.

El resultado también se dibuja solo, así que el espectro de bandas es una
llamada:

```python
ax = result.plot()
```

## Otras respuestas que eran tuplas son registros

Todas las demás respuestas que volvían como una tupla de magnitudes distintas,
que había que desempaquetar por posición, son ahora registros con campos con
nombre, y ninguna se desempaqueta: una línea que aún lo haga lanza
`TypeError: cannot unpack non-iterable ...` en vez de entregar la columna
equivocada. Solo queda una tupla donde sus elementos son semejantes, como
los dos extremos de un intervalo, el inferior primero.

| 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- |
| `freq, lower, upper, labels = filters.nominal_frequencies(3)` | `b = filters.nominal_frequencies(3)`, y luego `b.frequencies`, `b.lower_edges`, `b.upper_edges` y `b.labels` (un `FractionalOctaveBands`) |
| `epnl, pnltm, kf, kl = aircraft.epnl_from_pnlt(pnlt)` | `r = aircraft.epnl_from_pnlt(pnlt)`, y luego `r.epnl`, `r.pnltm`, `r.band_limits` (el par `(kF, kL)`), `r.bandsharing_adjustment` y `r.duration_correction` (un `EPNLIntegration`) |
| `freqs, delta_l = building.improvement_octave_bands(dl, f)` | `s = building.improvement_octave_bands(dl, frequencies=f)`, y luego `s.frequencies` y `s.values` (un `OctaveBandSpectrum`, cuyo `quantity` dice qué son los valores) |
| `freqs, values = result.octave_bands()` en un `building.FloorCoveringImprovementResult` | `result.octave_bands().frequencies` y `.values`, el mismo `OctaveBandSpectrum` |
| `l_in, s_m = building.combine_subareas(l_in, areas)` | `r = building.subarea_intensity_level(l_in, areas)`, y luego `r.levels` y `r.measurement_area` (un `SubareaIntensityLevel`) |
| `freqs, u = band_uncertainty.to_arrays()` en un `building.BandUncertainty` | `band_uncertainty.frequencies` y `band_uncertainty.uncertainties`, los campos de los que se leía |
| `bx, bz, bxz = building.corrugated_plate_stiffness(...)` | `b = building.corrugated_plate_stiffness(...)`, y luego `b.b_x_n_m`, `b.b_z_n_m` y `b.b_xz_n_m` (un `CorrugatedPlateStiffness`) |
| `f, lower, upper = building.heavy_impact_source_limits(source)` | `lim = building.heavy_impact_source_limits(source)`, y luego `lim.frequencies`, `lim.lower` y `lim.upper` (un `HeavyImpactSourceLimits`) |
| `width, k = building.wall_tie_stiffness(tie)`, `building.WALL_TIE_STIFFNESS[tie][1]` | `t = building.wall_tie_stiffness(tie)`, y luego `t.cavity_width_m` y `t.stiffness` (un `WallTieStiffness`, que es también lo que guarda cada fila de `WALL_TIE_STIFFNESS`) |
| `result.ratings` en un `building.LiningImprovementResult` | `result.delta_rw`, `result.delta_ra` y `result.delta_ratr`, los campos de los que se leía la tupla |
| `f, gamma2 = electroacoustics.coherence(x, y, fs)` | `c = electroacoustics.coherence(x, y, fs)`, y luego `c.frequencies` y `c.coherence` (un `CoherenceResult`, con `.plot()`) |
| `f, levels = emission.octave_band_levels(levels, f)` | `o = emission.octave_band_levels(levels, frequencies=f)`, y luego `o.frequencies` y `o.levels` (un `OctaveBandLevels`, con `.plot()`) |
| `f, class_1, class_2 = emission.residual_index_limits(device)` | `lim = emission.residual_index_limits(device)`, y luego `lim.frequencies`, `lim.class_1` y `lim.class_2` (un `ResidualIndexLimits`) |
| `wavelengths, levels = environment.wheel_roughness(brake)`, y lo mismo con `rail_roughness`, `contact_filter` e `impact_roughness_single` | `w = environment.wheel_roughness(brake)`, y luego `w.wavelengths_mm` y `w.levels` (un `WavelengthSpectrum`, con `.plot()`) |
| `source_a, source_b = environment.traction_sound_power(vehicle)`, y lo mismo con `aerodynamic_sound_power` | `p = environment.traction_sound_power(vehicle)`, y luego `p.source_a` y `p.source_b` (un `RailSourceSpectra`) |
| `RollingStock(wheel_roughness=(wavelengths, levels), traction=(a, b), ...)`, `RailwayTrack(rail_roughness=(wavelengths, levels), ...)` | los mismos campos con un `WavelengthSpectrum(wavelengths_mm=..., levels=...)` o un `RailSourceSpectra(source_a=..., source_b=...)`; un par suelto lanza `TypeError` con el nombre del campo |
| `f, lower, upper = filters.weighting_class_limits(1)` | `lim = filters.weighting_class_limits(1)`, y luego `lim.frequencies`, `lim.lower` y `lim.upper` (un `WeightingClassLimits`) |
| `rho, kappa = materials.slit_effective_properties(f, ...)`, y lo mismo con `rectangular_duct_properties` | `p = materials.slit_effective_properties(f, ...)`, y luego `p.effective_density` y `p.bulk_modulus` (un `EffectiveFluidProperties`) |
| `fc, alpha = materials.one_third_octave_absorption(alpha, f)` | `b = materials.one_third_octave_absorption(alpha, frequencies=f)`, y luego `b.frequencies` y `b.absorption` (un `OneThirdOctaveAbsorption`, con `.plot()`) |
| `a, b, c, d = materials.wave_decomposition(...)`, `p0, pd, u0, ud = materials.face_quantities(...)` | `w = materials.wave_decomposition(...)` con `w.a` a `w.d` (un `WaveAmplitudes`), `q = materials.face_quantities(...)` con `q.p0`, `q.pd`, `q.u0` y `q.ud` (un `FaceQuantities`) |
| `k, U = result.expanded(0.95)` en un `metrology.UncertaintyResult` | `e = result.expanded(0.95)`, y luego `e.coverage_factor` y `e.expanded_uncertainty` (un `ExpandedUncertainty`) |
| `f, spl = psychoacoustics.equal_loudness_contour(40.0)`, `f, tf = psychoacoustics.hearing_threshold()` | `c = psychoacoustics.equal_loudness_contour(40.0)`, y luego `c.frequencies`, `c.levels` y `c.phon`, que es `None` en el umbral (un `LoudnessContour`, con `.plot()`) |
| `f, v = vibration.foundation_guideline_curve(building_class)` | `g = vibration.foundation_guideline_curve(building_class)`, y luego `g.frequencies` y `g.velocities_mm_s` (un `GuidelineCurve`) |
| `chi, psi = vibration.junction_wave_parameters(...)` | `w = vibration.junction_wave_parameters(...)`, y luego `w.chi` y `w.psi` (un `JunctionWaveParameters`) |
| `time, level = room.decay_curve(ir, fs)`, que aún se desempaquetaba | `curve = room.decay_curve(ir, fs)`, y luego `curve.times` y `curve.levels` (un `DecayCurve`, que ya no se desempaqueta) |
| `times, levels = environment.sound_pressure_level_history(x, fs)` | `h = environment.sound_pressure_level_history(x, fs)`, y luego `h.times` y `h.levels` (un `LevelHistory`, que ya no se desempaqueta) |

```python
import numpy as np
from phonometry import aircraft, filters

bands = filters.nominal_frequencies(1, [125, 1000])
print(bands.labels)
# ('125', '250', '500', '1k')

epnl = aircraft.epnl_from_pnlt(np.array([90.0, 95.0, 90.0]), 0.5)
print(epnl.band_limits, round(epnl.duration_correction, 2))
# (0, 2) -10.88
```

El espectro en octavas se dibuja solo con `.plot()`, rotulado con su magnitud.

## Los límites de tolerancia van primero el inferior, y con signo

`vibration.weighting_tolerance_percent` devolvía la banda de la Tabla 5 de
ISO 8041-1 como `(upper, lower)`, y las tres constantes
`CENTRAL_TOLERANCE_PERCENT`, `SKIRT_TOLERANCE_PERCENT` y
`TAIL_TOLERANCE_PERCENT` guardaban `(upper %, lower %, fase °)`. Todos los demás
pares de límites de la biblioteca son `(lower, upper)`, así que estos también lo
son ahora. El límite inferior sigue siendo negativo, como lo imprime la tabla, y
`-100.0` sigue queriendo decir que la norma no fija límite inferior.

Este cambio no renombra nada ni lanza nada: `upper, lower = ...` sigue
desempaquetando dos arrays, e intercambiados. Revisa cada desempaquetado de los
cuatro:

| 4.0.0rc1 | 4.0 |
| --- | --- |
| `upper, lower = vibration.weighting_tolerance_percent(name, f)` | `lower, upper = vibration.weighting_tolerance_percent(name, f)` |
| `vibration.CENTRAL_TOLERANCE_PERCENT == (12.0, -11.0, 6.0)` | `(-11.0, 12.0, 6.0)` |
| `vibration.SKIRT_TOLERANCE_PERCENT == (26.0, -21.0, 12.0)` | `(-21.0, 26.0, 12.0)` |
| `vibration.TAIL_TOLERANCE_PERCENT == (26.0, -100.0, inf)` | `(-100.0, 26.0, inf)` |

```python
from phonometry import vibration

lower, upper = vibration.weighting_tolerance_percent("Wk", [16.0])
print(lower, upper)
# [-11.] [12.]
```

## Los campos de un registro son obligatorios

Varios registros tenían campos que valían `None` por defecto, para que un
resultado construido a mano con unos pocos de sus números se pudiera seguir
construyendo. Cada lector tenía entonces que preguntar si el campo estaba: la
ficha rechazaba un índice desnudo solo cuando se le pedía el informe, y un
dibujo de la geometría avisaba de que el resultado «no conserva su geometría».
Ahora los campos son obligatorios, y un registro construido sin uno de ellos,
o con `None` en uno (también mediante `dataclasses.replace`), lanza
`TypeError` nombrándolo.

| Registro | Obligatorio ahora |
| --- | --- |
| `building.AirborneInsulationResult` | `l1`, `l2`, `t2`, `t0` |
| `building.ImpactInsulationResult` | `li`, `t2`, `t0` |
| `building.WeightedRatingResult`, `building.ImpactRatingResult` | `frequencies`, `measured`, `shifted_reference` |
| `building.ExtendedWeightedRatingResult`, `building.ExtendedImpactRatingResult` | `frequencies`, `measured` |
| `building.ApertureTransmissionResult` | `depth`, ahora el cuarto campo; y `width_m` para una rendija o `radius` para una abertura circular |
| `building.FacadePredictionResult` | `elements`, ahora el sexto campo |
| `emission.IntensityResult` | `spacing_m`, keyword-only |
| `environment.BarrierInsertionLoss` | `source_height_m`, `barrier_distance`, `barrier_height_m`, `receiver_distance`, `receiver_height_m`, keyword-only |
| `psychoacoustics.ZwickerLoudness` | `field` (`"free"` o `"diffuse"`), ahora el cuarto campo, antes de `n5` |
| `room.OpenPlanResult` | `positions_m`, las distancias sobre las que se ajustaron los índices |
| `materials.LayeredAbsorberResult` | `layers`, la secuencia de capas para la que se resolvió la predicción |
| `materials.DiffuserPolarResponse` | `well_width` y `n_repetitions`, por nombre; `depths` sigue siendo opcional, porque una respuesta predicha a partir de un `reflection` explícito no la tiene |
| `materials.MetadiffuserResult` | `wells`, `depth_m` y `period_m`, el panel para el que se resolvió la reflexión, por nombre |
| `materials.SlitResonatorAbsorberResult` | `resonators`, `slit_height_m`, `lattice_step_m` y `period_m`, el panel para el que se resolvió la predicción, por nombre |
| `materials.ImpedanceTubeResult` | `spacing_m` y `x1`, la separación de los micrófonos y la distancia de la muestra al micrófono más lejano, sin las que la reducción no puede hacerse, por nombre; `diameter_m` sigue siendo opcional, porque no hace falta darlo |
| `materials.InSituAbsorptionResult` | `source_height_m` y `microphone_height_m`, el montaje con el que se midió la absorción, por nombre |
| `vibration.JunctionTransmissionResult` | `thickness1_m` y `thickness2_m`, las placas de la unión, por nombre |
| `noise_control.ReactiveSilencerResult` | `plane_wave_limit`, y exactamente uno de `geometry` (un dispositivo con nombre) y `chain` (una `SilencerChain`); `resonances`, `geometry`, `plane_wave_limit` y `chain` van por nombre |

`simulation.FDTDResult` y `simulation.ElasticFDTDResult` toman dos campos
más, detrás de los demás: `snapshot_decimation`, cada cuántas celdas guarda
una instantánea en cada eje (1 para todas, como antes), y `provenance`, el
`simulation.RunProvenance` de dónde se calculó la ejecución. Un resultado
construido a mano pasa los dos, y dejar fuera uno lanza `TypeError`
nombrándolo; los resultados que devuelven las funciones de simulación ya
llevan los dos. Un `RunProvenance` construido a mano pasa todos sus campos,
entre ellos `phonometry_version`, la versión de phonometry que calculó los
pasos.

`filters.WeightingFilter(..., high_accuracy=None)` seleccionaba el valor por
defecto. Ahora `high_accuracy` es un `bool` sin más, `True` por defecto, y
`None` lanza `TypeError` en vez de leerse como falso, lo que elegiría el diseño
simple.

`building.CeilingAttenuationResult.rounded` era un campo que pasaba quien
llamaba. Ahora se lee de `measured`, redondeado al entero más próximo como
pide la cláusula 5.2 de ASTM E413 (la cláusula no dice hacia dónde va la
mitad, y la biblioteca la redondea hacia arriba), así que no puede contradecir
los datos; déjalo fuera al construir el registro a mano.

## Las formas de onda dentro de los resultados vuelven como el `Signal` del que salieron

Una transformación a la que se le entrega un `Signal` devuelve un `Signal`
desde que se escribió el contrato, pero cinco objetos de resultado todavía
guardaban su forma de onda como un array desnudo junto a un `fs` suelto. Ahora
conservan el tipo con el que llegó la entrada:

| Campo | Es un `Signal` cuando la entrada lo era |
| --- | --- |
| `envelope(...).signal` | a la frecuencia de muestreo de la entrada |
| `time_synchronous_average(...).period_waveform` | a la frecuencia de muestreo de la entrada |
| `resample_signal(...).signal` | a `fs_new` |
| `align_impulse_responses(...).aligned`, `.reference` | cada uno si su propia entrada lo era |
| `underwater.pile_strike_metrics(...).pressure` | a la frecuencia de muestreo de la entrada |

Un array desnudo sigue devolviendo un array desnudo, así que el código que
pasa arrays no lo nota. El código que pasa un `Signal` y hace aritmética con
uno de estos campos pasa por `np.asarray`, como con cualquier `Signal`, y una
entrada calibrada vuelve con `calibration_factor=1.0`, así que el campo
alimenta a la función siguiente en pascales sin que el factor se aplique otra
vez.

## Un flujo por bloques entrega bloques `Signal`

`io.read_blocks` es posterior a la 3.3.0, y en la 4.0.0rc1 entregaba arrays
float64 desnudos. Ahora entrega un `Signal` por bloque, con la frecuencia de
muestreo, la calibración, las etiquetas de canal y la procedencia que da
`io.read`, y toma el mismo `calibration_factor=` y lee el mismo sidecar. Para
un bucle escrito contra la versión candidata cambian dos cosas. Un bloque de
un archivo calibrado llega a los filtros y a las funciones de nivel en
pascales, así que un `calibration_factor` aplicado a mano encima cuenta dos
veces. Y la aritmética sobre un bloque, o sobre lo que un filtro devuelve para
él, pasa por `np.asarray`, como con cualquier `Signal`.

## Las tablas publicadas no admiten escritura

Toda tabla que la biblioteca publica a nivel de módulo es de solo lectura en
la 4.0. En la 3.3.0 las tablas publicadas eran diccionarios corrientes y los
arrays publicados admitían aritmética sobre el propio array, así que una
línea como `REFERENCE_CURVE[500] = 0.9` o `BAND_IMPORTANCE *= 2` cambiaba el
número para todo lo que se ejecutara después en el mismo proceso, sin que
nada lo avisara. Los diccionarios son ahora `types.MappingProxyType`, también
los que van anidados dentro de otra tabla, y los arrays tienen desactivada la
bandera `writeable`. Leer no cambia; escribir lanza `TypeError` en una tabla y
`ValueError` en un array.

El código que retocaba una tabla publicada tiene que copiarla antes:

```python
from phonometry import room
from phonometry.materials.absorbers import REFERENCE_CURVE

curve = dict(REFERENCE_CURVE)
curve[4000] = 1.0
curves = room.NC_CURVE_LEVELS.copy()
curves[0, 0] = 0.0
print(REFERENCE_CURVE[4000], curve[4000], curves[0, 0], room.NC_CURVE_LEVELS[0, 0])
# 0.9 1.0 0.0 78.0
```

Una tabla que lleva tablas dentro necesita copiar cada nivel, como en
`{area: dict(rows) for area, rows in GUIDE_VALUES.items()}`. La misma copia
hace falta antes de serializar una tabla con pickle, copiarla en profundidad o
escribirla como JSON, porque un mapeo de solo lectura no admite ninguna de las
tres cosas.

## Un resultado guarda una copia propia de los arrays que recibe

En la 3.3.0 y en la 4.0.0rc1 un resultado guardaba el mismo array que se le
pasaba siempre que ese array ya era del tipo que lee la función, `float64`
para niveles y frecuencias, porque en ese caso `np.asarray` devuelve su
argumento sin tocarlo. Cambiar después el array de quien llamaba,
`levels[0] = 0.0` o `frequencies *= 2`, cambiaba un resultado ya calculado y
quizá ya impreso. En la 4.0 todo array que una función o un método de la
biblioteca guarda de los argumentos que recibe es una copia propia, de solo
lectura como las tablas publicadas, y el array de quien llama queda como
estaba. Lo mismo vale para los objetos que guardan arrays para entregarlos
después: la rejilla de frecuencias de una `noise_control.SilencerChain`, los
ejes y las trayectorias con los que se construye una `aircraft.ANPDatabase`
y los mapas del medio de `simulation.FDTD2D` y `simulation.ElasticFDTD2D`,
cuyos `c`, `rho`, `c_p` y `c_s` siguen siendo ahora aquellos con los que se
calculó el paso de tiempo. Los mapas que las simulaciones derivan de ellos,
`FDTD2D.kappa` y `ElasticFDTD2D.mu` y `.lam`, son también copias de solo
lectura en NumPy: en la 4.0.0rc1 editar uno llegaba a parte del avance y no
al paso de tiempo, y ahora lanza
`ValueError`, así que otro medio es una simulación nueva construida con los
mapas editados. Un `Signal` también guarda una copia propia de sus
muestras, que sigue siendo escribible para procesarla en su sitio, como
siempre lo fueron las muestras de un fichero leído con `io.read`. Un registro
de resultado construido a mano, llamando directamente a su clase, hace la
misma copia: todo registro público que puede guardar un array copia los
arrays que recibe al construirse, lo construya quien lo construya, también
dentro de una tupla, una lista o cualquier diccionario. Un registro guardado
dentro de otro se guarda entero y responde de sus propios arrays, y un
`Signal` no es una excepción: los siete resultados que devuelven una forma de
onda como `Signal` (`filters.OctaveFilterResult`, `signals.EnvelopeResult`,
`signals.ResampledSignalResult`, `signals.AlignedImpulseResponseResult`,
`signals.SynchronousAverageResult`, `environment.DirectSoundSubtraction` y
`underwater.PileStrikeResult`) guardan una propia cuando los construye la
biblioteca, cuyas muestras siguen siendo escribibles como las de cualquier
`Signal`, y guardan la de quien llama cuando se construyen a mano con ella.
Todos los demás arrays que guarda un resultado rechazan las escrituras en su
sitio, tanto los que calculó como los que recibió, cuando en la 3.3.0 la
mayoría de los calculados las aceptaban. Escribir en uno lanza ahora
`ValueError`, así que el código que retocaba uno en su sitio tiene que
copiarlo antes:

```python
import numpy as np

from phonometry import io, room

levels = np.array([60.0, 58.0, 55.0, 52.0, 50.0, 48.0, 45.0, 42.0, 40.0, 38.0])
nc = room.noise_criterion(levels)
levels[0] = 0.0
samples = np.zeros(4)
signal = io.Signal(samples, fs=48_000)
samples[0] = 1.0
measured = np.array([1.0, 0.5, 0.25, 0.125])
response = room.ImpulseResponseResult(ir=measured, fs=48_000, method="farina")
measured[0] = 0.0
edited = nc.levels.copy()
edited[0] = 62.0
print(nc.levels[0], nc.levels.flags.writeable, response.ir[0], response.ir.flags.writeable)
print(signal.data[0, 0], signal.data.flags.writeable)
# 60.0 False 1.0 False
# 0.0 True
```

La ventana con la que se calculó un resultado espectral se guarda igual.
`signals.power_spectral_density`, `signals.cross_spectral_density`,
`signals.coherent_output_spectrum`, `signals.miso_coherence`,
`signals.spectrogram`, `signals.zoom_fft`, `signals.envelope_spectrum` y
`signals.window_metrics` guardan la `window` que recibieron, y una ventana
dada con sus parámetros guarda unos parámetros propios: los pesos de
`("general_cosine", weights)` dados como lista se guardan como una tupla de
los mismos números, donde la 3.3.0 guardaba la lista de quien llamaba, así
que `result.window == ("general_cosine", (0.5, 0.5))`; dados como array son
una copia de solo lectura, como todo array que guarda un resultado. Un
resultado construido a mano, o de nuevo con `dataclasses.replace`, guarda su
ventana igual.

## Una fila de catálogo dice lo que su fuente afirma de cada celda

Los catálogos publicados de materiales son nuevos en la 4.0: ni la 3.3.0 ni
la 4.0.0rc1 los tenían. Cambiaron de forma una vez de camino a la versión
final, y el código escrito contra la rama principal entretanto necesita los
cambios de abajo. Todas las filas de todos los catálogos comparten ahora una
base, `io.CatalogueRow` (con `io.BandedRow` para una fila que imprime un valor
por banda), y las mismas tres preguntas tienen la misma respuesta en
cualquiera de ellas.

| Antes | 4.0 |
| --- | --- |
| `SolidMaterial.estimated`, `OrthotropicWood.estimated` | `row.basis`, que asigna `"estimated"` a cada campo con la nota al pie |
| `SolidMaterial.is_estimate(field)`, `OrthotropicWood.is_estimated(field)` | `row.basis_of(field) == "estimated"` |
| `row.is_derived(field)` en un valor que la página da en una unidad que la fila no guarda (los °F y psi de la Tabla 14.1 de Ver & Beranek, los sabines de la Tabla 7.1 de Long) | `field in row.converted`; `row.converted[field]` es la cifra de la página y su unidad, como `("3e5", "psi")` |
| `row.is_derived(field)` en un valor que la página da por referencia a otra de sus filas: una celda en blanco bajo un bloque (Tabla 8.7 de Ver & Beranek, Tabla 30 de ASHRAE) o una descripción que dice «Parecido al anterior» (capítulo 32 de Harris) | `field in row.carried`; `row.carried[field]` nombra la fila |
| `OrthotropicWood(...)` y `PlateauMaterial(...)` con sus propios campos por posición | todos los campos por nombre, como en cualquier otra fila |
| `from phonometry._internal.catalogue import CatalogueRow` | `from phonometry.io import CatalogueRow` |

`is_derived` responde ahora sólo por lo que calcula la biblioteca y podría
volver a calcular con las celdas de la propia fila, como una velocidad de
barra obtenida de un módulo y una densidad. Un valor que la página da en otra
unidad sigue siendo el número de la página, y también lo es uno que da por
referencia a otra de sus filas, así que ninguno de los dos es ya derivado. `basis_of` responde con la entrada del propio campo, si no
con la de la fila, y si no con una cadena vacía, que quiere decir que la
fuente no dice cómo se obtuvo el número; las cinco cosas que puede afirmar una
fuente están en `io.CATALOGUE_BASES`.

```python
from phonometry import solids

board = solids.PUBLISHED_SOLIDS["hopkins-2007-table-a2/plasterboard_natural_gypsum"]
ear = solids.damping_named("EAR C-1002")[0]
print(board.basis_of("poisson_ratio"))
# estimated
print(ear.converted["youngs_modulus_max_pa"], ear.is_derived("youngs_modulus_max_pa"))
# ('3e5', 'psi') False
```

Las capas elásticas pasaron a ser filas de catálogo en el mismo cambio. Una
`ResilientLayer` es una `io.CatalogueRow` como cualquier otra fila, con la
clave y la atribución de las demás:

| Antes | 4.0 |
| --- | --- |
| `PUBLISHED_RESILIENT_LAYERS["mineral_wool_rock_60_30"]`, `resilient_layer("mineral_wool_rock_60_30")` | `"hopkins-2007-table-a3/mineral_wool_rock_60_30"`, la clave `"<tabla>/<fila>"` de todos los catálogos |
| `layer.attributed_to`, una cadena | `layer.attributed_to["row"]`, un mapeo como en todas las filas |
| `ResilientLayer(...)` con la rigidez, la densidad y el espesor obligatorios | todas las magnitudes opcionales, y `apparent_dynamic_stiffness_n_m3` junto a `dynamic_stiffness_n_m3` para una fuente que sólo da la aparente $s'_\mathrm{t}$ |
| `layer.natural_frequency(mass_per_area=...)` | `layer.natural_frequency(mass_per_area_kg_m2=...)`; una capa que sólo guarda $s'_\mathrm{t}$ toma además `airflow_resistivity_pa_s_m2=` y `gas_stiffness_n_m3=`, y sin el primero lanza `ValueError` |

La Tabla A3 de Hopkins imprime $s'$, la rigidez de la capa instalada tal como
la define la lista de símbolos del propio libro, así que sus quince filas
siguen guardando `dynamic_stiffness_n_m3` y devuelven las frecuencias
naturales que devolvían. Cuatro de ellas guardan una densidad que la página
imprime una sola vez para su bloque y deja en blanco en su propia línea, y
`layer.carried["density_kg_m3"]` nombra ahora la fila que la imprime; la
densidad es la misma.

```python
from phonometry import materials

rebond = materials.resilient_layer("hopkins-2007-table-a3/rebond_foam_64_20")
print(rebond.attributed_to["row"], round(rebond.natural_frequency(mass_per_area_kg_m2=120.0), 1))
# Hopkins and Hall (2006) 43.6
```

## Una fila de catálogo se comprueba al construirse

Toda fila de catálogo se comprueba en su constructor, la construya la
biblioteca a partir de una tabla empaquetada o quien llama a mano, y una celda
que nada de lo que viene después podría leer lanza `io.CatalogueError`,
nombrando la fila y el campo. El código escrito entretanto contra la rama
principal que contara con que se aceptara algo de lo siguiente tiene que
cambiar:

| Antes se aceptaba | 4.0 |
| --- | --- |
| `NaN`, un infinito, `True` o un texto como `"0,97"` en un campo numérico | `CatalogueError`; una celda que la página deja vacía es `None` |
| una fracción en un campo entero (`year`), `1` en un campo booleano (`has_section_drawing`), un número en un campo de texto | `CatalogueError` |
| un `name` o un `source` vacíos, o un matiz cuyo texto está vacío, como `misprinted={"porosity": ""}` | `CatalogueError`; `why_missing` respondía `""` para esa celda, lo que escondía el matiz |
| un matiz con la clave de un campo que la clase no tiene, como en `ranges={"no_such_field": ...}`, o un matiz sobre un número (`ranges`, `approximate`, `unquantified`, ...) con la clave de un campo de texto | `CatalogueError`, que nombra el matiz y la clave |
| `bounded_above` o `bounded_below` sobre un campo sin intervalo; un intervalo, o uno de los intervalos de las lecturas de `reported`, con un extremo que no es finito o con el extremo bajo por encima del alto; una lista de `reported` sin nada dentro; una `uncertainty` negativa | `CatalogueError` |
| un valor junto a `misprinted`, `unquantified`, `not_derivable` o `reported` en el mismo campo; una entrada de `converted` o `carried` en un campo que no guarda nada | `CatalogueError`: los cuatro primeros dicen que no hay valor que servir, y los dos últimos no tienen nada que describir |
| un valor negativo en un campo cuyo nombre acaba en `_kg_m3`, `_kg_m2`, `_kg`, `_kg_mol`, `_m_s`, `_pa`, `_pa_s_m2`, `_pa_s_m`, `_n_m3`, `_mm`, `_um`, `_m`, `_m2`, `_m_hz` o `_per_cm` (una densidad, una masa por unidad de superficie, una masa, una masa molar, una velocidad, una presión o un módulo, una resistividad al flujo, una resistencia al flujo específica, una rigidez por unidad de superficie, una longitud, un área, un producto espesor por frecuencia, una cuenta por centímetro); una porosidad fuera de 0 a 1; `shot_content_percent`, `binder_content_percent` o `adhered_area_percent` fuera de 0 a 100 | `CatalogueError`; una temperatura en grados Celsius, una tasa de decaimiento por metro y un nivel en decibelios siguen pudiendo ser negativos |
| `approximate=[...]` guardado como la lista que se le dio, un mapeo guardado como el diccionario | un `frozenset`, y todo mapeo congelado hasta el fondo, con sus pares en tuplas |
| un campo de una subclase anotado con un tipo para el que el contrato no tiene comprobación, un `float` o un `int` a secas incluidos | `TypeError` la primera vez que se construye la clase; un campo es `float \| None` (`Optional[float]` es lo mismo), `int \| None`, `bool`, `str`, `frozenset[str]` o un `Mapping[str, ...]` de ellos, porque cualquier celda de una fila puede faltar |
| `PorousMaterial.frame_constants()` sobre una fila sin `structural_loss_factor`, leída como un esqueleto que no disipa nada | `ValueError`, que dice qué tenía la página en esa celda |
| `GroundSurface.porosity` con valores de 26,9 a 58,1 en seis filas de la Tabla 6.7 de Cox y D'Antonio, que la página imprime en tanto por ciento en una columna de fracciones que no dice su unidad | `None`, con `misprinted["porosity"]` citando la cifra que imprime la página; `why_missing("porosity")` y `printed("porosity")` lo dicen |

Todas las demás filas empaquetadas cumplían ya el contrato, así que esas seis
porosidades son las únicas celdas publicadas que cambian, y todas las filas
porosas publicadas con los dos módulos imprimen su factor de pérdidas.

```python
from phonometry import io, materials

try:
    materials.PorousMaterial(name="Panel core", source="a datasheet", porosity=97.0)
except io.CatalogueError as error:
    print(error)
# 'Panel core': porosity is 97.0, and a porosity is a fraction from 0 to 1

carpet = materials.Carpet(
    name="Loop pile", source="a datasheet", pile_height_mm=6.0, approximate=["pile_height_mm"]
)
print(carpet.approximate)
# frozenset({'pile_height_mm'})
```

## La clase de un banco de filtros lee todos los requisitos de IEC 61260-1

`verify_filter_class` calificaba solo la máscara de la Tabla 1. Para la edición
de 2014 califica ahora también la desviación del ancho de banda efectivo del
5.12 y la suma de las señales de salida del 5.16, calculadas como las calcula
IEC 61260-2:2016, y la `class` de una banda y la `overall_class` del banco son
la clase más estricta que se cumple en los tres. Para la edición de 1995
califica la respuesta integrada del filtro del 4.5.3 y la suma de las señales
de salida del 4.9 junto a la Tabla 1, como las ensaya el capítulo 5 de esa
edición. En las dos ediciones cada banda se califica a la frecuencia de
entrada del banco hasta su mitad, así que una banda diezmada se califica
sobre las imágenes que su diezmado pliega sobre ella, y el diezmador del banco
las deja a más de 125 dB por debajo.

| Antes | 4.0 |
| --- | --- |
| cada banda de un banco diezmado se diezmaba hasta que su frecuencia de Nyquist de proceso era 1,25 veces su borde superior de banda | se diezma sólo hasta dejarla en dieciséis veces ese borde, así que la transformación bilineal ya no deforma la banda: el nivel de una banda se mueve hasta 0,07 dB con ruido blanco, sobre todo en las bandas más bajas, y el banco de octavas, que sumaría sus salidas hasta +0,94 dB y leería clase 2 en el 5.16, es clase 1 en todos los requisitos |
| la `class` de una banda leída de `margin_class{c}_db` | `class` sobre todos los requisitos; `margin_class{c}_db` sigue siendo el margen de la Tabla 1, junto a `bandwidth_margin_class{c}_db` y `summation_margin_class{c}_db`, que vale `None` en las dos bandas de los extremos |
| un solo requisito por el que preguntar | `requirements`, `requirement_class(name)` y `binding_margin(name, cls)` leen cada uno por separado, y `plot(requirement="summation")` lo dibuja |
| un veredicto con `edition="1995"` solo sobre la Tabla 1 | la Tabla 1, `"effective_bandwidth"` (la respuesta integrada del filtro del 4.5.3) y `"summation"` (4.9, recorrida de la frecuencia central más baja a la más alta, así que las bandas de los extremos también la llevan), las dos con la S que el 5.3.3 sube en pasos de 12 hasta que la respuesta integrada se estabiliza, que el `points_per_bandwidth` del resultado indica (36 para el banco de octavas por defecto) |
| una banda diezmada calificada hasta la frecuencia de Nyquist de su frecuencia diezmada, con `checked_to_omega` parado ahí | calificada a la frecuencia de entrada hasta su mitad, imágenes incluidas; `checked_to_omega` es la mitad de la frecuencia de entrada entre la frecuencia central, y `range_limited` marca una máscara de la Tabla 1 que sigue más allá |
| el filtro antialiasing que `scipy.signal.resample_poly` diseña por defecto, que dejaba las imágenes del banco de octavas a 8, 16 y 32 kHz 68,9 dB por debajo, sin llegar a los 70 dB de la clase 1 | un filtro de la misma longitud dimensionado para una banda atenuada de 120 dB, con sus imágenes al menos 125,4 dB por debajo; el nivel de una banda se mueve menos de 0,01 dB |

Los bancos de octavas y de tercios de octava siguen siendo clase 1.

```python
from phonometry import filters

octave = filters.verify_filter_class(
    filters.OctaveFilterBank(48000, fraction=1, limits=[125, 4000]))
print(octave.overall_class, octave.requirement_class("relative_attenuation"))
# 1 1
```

## Un veredicto lee de la norma el límite que esta imprime

Un veredicto llevaba antes como campo del constructor el límite con el que se
le juzgaba. En 3.3.0 lo hacían tres: `ToneAssessment.criterion_db`,
`ExposureAssessment.action_value` y `limit_value`, y
`RigidMassCalibrationResult.tolerance`. Otros seis, posteriores a 3.3.0, lo
hacían en 4.0.0rc1, y el resto de la tabla llegó después de 4.0.0rc1.
Cualquier código que construyera uno a mano, o que lo reescribiera con
`dataclasses.replace`, podía juzgar una medición contra cualquier número y
seguir poniendo el nombre de la norma encima del resultado. En 4.0 todo límite
que imprime una norma es una propiedad de solo lectura, leída de los campos
que la seleccionan: las bandas, la condición, la fuente, la clase, la sala. Un
veredicto que se guardaba junto a su límite se lee también de los campos
medidos, o se contrasta con ellos al construir el resultado, de modo que no
puede contradecir el límite. Las funciones que devuelven estos veredictos
reciben los mismos argumentos y dan las mismas respuestas, y cada nombre de la
tabla, con su grafía de la 4.0, sigue leyendo el mismo valor; solo cambia el código que construye un
veredicto directamente o que sustituye uno de estos campos. La última columna
indica en qué versión apareció cada veredicto.

| Veredicto | Ya no son campos del constructor | Campos que conserva o gana | Desde |
| --- | --- | --- | --- |
| `building.PositionSpreadCheck` | `limit_db`, `stage`, `spread_db`, `action`, `next_positions`, `corner_standard_deviation_db` | `levels`, del que se leen todos | después de 4.0.0rc1 |
| `building.HeavyImpactSourceCheck` | `frequencies`, `nominal`, `tolerance_db`, `deviation`, `within_tolerance`, `passes` | `source`, `measured` | 4.0.0rc1 |
| `noise_control.BandFlatnessCheck` | `limit_db`, `within_limit`, `passes` | `octave_frequencies`, `spread_db` | después de 4.0.0rc1 |
| `noise_control.SourcePositionCheck` | `n_required_positions`, `passes`, `exceeds_max` | `n_positions_used`, `max_octave_spread_db` | después de 4.0.0rc1 |
| `noise_control.EnclosureTestEnvironmentCheck` | `environmental_correction_limit_db`, `background_margin_limit_db`, `required_area_ratio`, `passes` | `base_standard`, `actual_area_ratio`, `mean_absorption_coefficient` | después de 4.0.0rc1 |
| `environment.ReflectionGridCheck` | `nominal_m`, `deviations_m`, `within` | `check`, `path_differences_m` | después de 4.0.0rc1 |
| `emission.HardWalledRoomCheck` | `limit_db`, `min_volume_m3`, `box_dimension_limit_m`, `min_microphone_distance_m` | las bandas, la sala y la caja de referencia | después de 4.0.0rc1 |
| `emission.ReferenceSoundSourceVerdict` | todos los `*_limit_db`, `adjacent_step_db`, `core_range_db`, `extended_range_db`, `frequency_range_met`, `not_judged` | las bandas, los niveles y las cifras medidas | después de 4.0.0rc1 |
| `emission.ReferenceSourceDriftResult`, `emission.SpecialRoomSuitabilityCheck` | `limit_db` | las bandas | después de 4.0.0rc1 |
| `emission.SpecialRoomReverberationCheck` | `lower_limit`, `upper_limit` | las bandas | después de 4.0.0rc1 |
| `emission.IntensityInstrumentComplianceResult` | `limit_class1`, `limit_class2`, `spacing_offset_db` | `device`, `spacing_m`; las filas por banda se leen de ellos, véase la sección siguiente | 4.0.0rc1 |
| `emission.InverseSquareLawResult`, `emission.SourceDirectionalityResult` | `tolerance_db` | lo selecciona `room`; los radios cualificados deben ser los que alcanzan los niveles | después de 4.0.0rc1 |
| `hearing.AmbientNoiseCheck` | `limits_db`, `table_bands_hz` | gana `earphone_attenuation` y `allowed_threshold_shift_db` | después de 4.0.0rc1 |
| `hearing.FixtureIsolationVerification` | `min_isolation` | las bandas | después de 4.0.0rc1 |
| `hearing.REATSoundFieldCheck` | `allowable_variation_db` | gana `free_field_rejection` | después de 4.0.0rc1 |
| `hearing.DiffuseSoundFieldCheck` | `allowable_variation_db` | gana `front_to_random_index` | después de 4.0.0rc1 |
| `hearing.FreeSoundFieldCheck` | `axis_offset_m`, `inverse_distance_difference` | los seleccionan `field` y `loudspeaker_distance_m` | después de 4.0.0rc1 |
| `electroacoustics.ProgramSignalCheck` | `offset_db`, `relative_levels`, `lower_tolerance_db`, `upper_tolerance_db` | `frequencies`, `band_levels` | después de 4.0.0rc1 |
| `electroacoustics.NeckLoopVerification` | `limits` | lo selecciona `neck_loop_type` | después de 4.0.0rc1 |
| `psychoacoustics.ToneAssessment` | `prominence_limit_db`, `prominent` | gana `method`, `"tone_to_noise_ratio"` o `"prominence_ratio"` | 3.3.0 |
| `underwater.WeightedExposureResult` | `criteria` | gana `impulsive` | 4.0.0rc1 |
| `vibration.ExposureAssessment` | `action_value`, `limit_value`, `exceeds_action`, `exceeds_limit`, `zone` | `value`, `kind`, `metric` | 3.3.0 |
| `vibration.PhaseVerification`, `vibration.WeightingVerification` | `tolerance_deg` (fase), `within_tolerance` | la ponderación y las frecuencias | 4.0.0rc1 |
| `vibration.RunningRMSDecayVerification` | `printed_time_s`, `tolerance_s` | `method`, `integration_time`, `measured_time_s` | después de 4.0.0rc1 |
| `vibration.SignalBurstVerification` | `printed`, `deviation_percent`, `tolerance_percent`, `within_tolerance` | la fila de la tabla, las columnas y `measured` | 4.0.0rc1 |
| `vibration.VibrationMeterVerification` | `lower_percent`, `upper_percent`, `within_tolerance` | gana `measured_response` | después de 4.0.0rc1 |
| `vibration.AssessmentVelocity` | `guide_value_mm_s` | lo selecciona `building_class` | después de 4.0.0rc1 |
| `vibration.MountingCheck` | `passes`, `frequency_limit_hz`, `peak_acceleration_limit_m_s2`, `device` | gana `peak_acceleration_m_s2` y `upper_frequency_hz` | después de 4.0.0rc1 |
| `vibration.DamageAssessment` | `guideline_mm_s` | gana `massive_structure`, solo por nombre | 4.0.0rc1 |
| `vibration.RigidMassCalibrationResult` | `expected`, `relative_deviation`, `within_tolerance`, `passes`, `relative_tolerance` | `frequencies`, `measured`, `mass`, `quantity` | 3.3.0 |
| `vibration.LevelDifferenceCheck` | `limit_db` | lo selecciona `condition` | después de 4.0.0rc1 |
| `vibration.OutputMassCheck` | `mass_limit_kg` | gana `output_apparent_mass_kg`, la fuerza de salida medida entre la aceleración de salida | después de 4.0.0rc1 |

También cambian dos llamadas. `rigid_mass_calibration_check`, hoy
`verify_rigid_mass_calibration`, ya no recibe `tolerance`: el apartado 7.5.2 de ISO 7626-2:2015 dice que el bloque «shall
agree within ±5 %», así que una aceptación interna más estricta se lee de
`.relative_deviation`. Y `HeavyImpactSourceCheck` y `RigidMassCalibrationResult`, cuyo
`passes` era un campo almacenado, se niegan a leerse como valor de verdad
igual que los demás veredictos: `if check:` lanza `TypeError` y el veredicto
es `.passes`.

```python
import dataclasses

from phonometry import vibration

check = vibration.check_blocked_output(frequencies=[100.0, 200.0], input_acceleration_level=[90.0, 95.0], output_acceleration_level=[60.0, 70.0])
print(check.limit_db, check.passes)
# 20.0 True
try:
    dataclasses.replace(check, limit_db=10.0)
except TypeError as error:
    print(type(error).__name__)
# TypeError
calibration = vibration.verify_rigid_mass_calibration([0.104, 0.093], frequencies=[50.0, 500.0], mass=10.0)
print(calibration.relative_tolerance, calibration.within_tolerance.tolist())
# 0.05 [True, False]
```

Los límites que una norma deja en manos del usuario siguen siendo campos: los
límites de rugosidad y de tasa de decaimiento «por defecto» de ISO 3095, la
tolerancia que ISO/DIS 16032 7.6 no imprime para «aproximadamente 30 s», el
periodo de curado que fija la especificación del producto según ISO 10140-1
G.4, el desplazamiento de umbral que ISO 8253-1 deja aceptar al examinador, y
los límites de especificación, de caso de ensayo y de fila de límites que se
pasan a las comprobaciones de conformidad, de ISO 17534-1 y del
RD 1367/2007. Los registros de requisitos de ISO 8297 y de IEC 60118-4,
`PlantRequirement` y `LoopRequirement`, también conservan como campo el límite
de cada fila: un mismo tipo de registro reúne requisitos cuyos límites mezclan
cifras impresas con la geometría de la planta, la intensidad de campo
especificada o el ruido medido con el bucle apagado.

## Un veredicto se lee de los valores que guarda

La sección anterior sacó de los constructores los límites impresos. Las
banderas del veredicto se quedaron dentro: `passes`, `qualified`,
todos los `*_met` y `*_ok`, los avisos y la clase de cada banda de un
veredicto de filtro, de ponderación o de instrumento de intensidad. La función
que construía el resultado las calculaba y las guardaba junto a las lecturas
de las que salían, así que un resultado construido a mano, o reescrito con
`dataclasses.replace`, podía guardar lecturas que no cumplen y una bandera que
dice que sí. En 4.0 todas son propiedades de solo lectura, leídas de los
valores que guarda el resultado y del límite que imprime la norma. El
resultado conserva aquello de lo que se lee su veredicto: las lecturas, los
márgenes, las posiciones, las cifras medidas. Una cifra que solo alimentaba el
veredicto, como el nivel redondeado de un periodo del RD 1367/2007 o la
fracción de gotas de lluvia dentro de su tolerancia, también es una propiedad.
Las funciones que devuelven estos resultados reciben los mismos argumentos y
dan los mismos veredictos, y cada nombre de la tabla sigue leyendo el mismo
valor; solo cambia el código que construye uno de estos resultados
directamente o que sustituye uno de los campos de la lista. «Solo por nombre»
marca un campo que solo se pasa por nombre.

| Resultado | Ya no son campos del constructor | Se lee de | Desde |
| --- | --- | --- | --- |
| `building.JointTestElementCheck` | `length_ok`, `width_ok`, `passes` | `joint_length_m`, `joint_width_mm`, `window_or_door_gap` | después de 4.0.0rc1 |
| `building.GapWidthCheck` | `gap_width_mm`, `spread_mm`, `enough_positions`, `uniform`, `passes` | `readings_mm` | después de 4.0.0rc1 |
| `building.JointGapSeriesCheck` | `nominal_measured`, `min_measured`, `working_range_measured`, `passes` | `gap_widths_mm`, `nominal_gap_mm`, `min_gap_mm` | después de 4.0.0rc1 |
| `building.LiningCuringCheck` | `cured`, `lag_within_third`, `passes` | `curing_time_days`, `time_lag_days`, `required_curing_days` | después de 4.0.0rc1 |
| `building.RainGeneratorVerification` | `rate_deviation_mm_h`, `rate_ok`, `drop_share`, `drops_ok`, `velocity_share`, `velocities_ok`, `passes` | `rain_type`, `rainfall_rate_mm_h`, `drop_diameters_mm`, `fall_velocities_m_s` | después de 4.0.0rc1 |
| `building.ServiceEquipmentPositionCheck` | `separation_m`, `surface_distance_m`, `source_distance_m`, `heights_m`, `corner_height_m`, `corner_wall_distances_m` y los seis `*_ok` | la sala, la esquina y las posiciones | después de 4.0.0rc1 |
| `building.DBHRCheck` | `reported`, `margin`, `passes` | `requirement`, `value` | 4.0.0rc1 |
| `building.LowFrequencyIntensityResult`, `building.LowFrequencyElementResult` | `qualified` | `surface_pressure_intensity_indicator`, frente al límite de 6.4.2 que selecciona `absorbing_specimen_surface` | 4.0.0rc1 |
| `electroacoustics.BackgroundNoiseAssessment` | `reference_signal_to_noise_ratio_db`, `category`, `report_required` | `noise_levels`, `noise_is_tonal` | después de 4.0.0rc1 |
| `electroacoustics.FeedbackStabilityResult` | `is_stable` | `loop_gain`, `stability_margin` | 4.0.0rc1 |
| `emission.FreeFieldCheck` | `room`, `frequencies`, `band_radius_m`, `max_qualified_radius_m`, todos los `*_met`, `full_frequency_range`, `conforming_range_hz`, `conforming_radius_m`, `not_judged` | los argumentos de `check_free_field`: gana `source_directionality`, `reflecting_plane_absorption_coefficient`, `reflecting_plane_margin_m`, `paths_in_working_area`, `speed_of_sound` | después de 4.0.0rc1 |
| `emission.IntensityInstrumentComplianceResult` | `bands`, `overall_class`, `range_limited` | `frequencies`, `residual_index`, `device`, `spacing_m` | 4.0.0rc1 |
| `emission.ReferenceSourceCalibration` | `sound_power_level`, `intensity_bands`, `intensity_agreement`, `room_qualified` | gana `intensity_sound_power_level` y `room_qualification` | después de 4.0.0rc1 |
| `emission.HardWalledSoundPowerResult` | `background_requirement_met`, `upper_bound` | gana `background_margin_db`, `reference_background_margin_db` | después de 4.0.0rc1 |
| `emission.InSituSoundPowerResult` | `background_requirement_met`, `upper_bound`, `grade`, `sigma_r0`, `sigma_tot`, `expanded_uncertainty` | gana `background_margin_db`, `reference_background_margin_db`, los menores de todas las posiciones, y `excess_levels`, `directivity_range_db`, los dos indicadores con los que la tabla 2 asigna el grado | 4.0.0rc1 |
| `emission.SpecialRoomSoundPowerResult` | `background_requirement_met`, `background_requirement_met_a` | gana `background_margin_db`, `reference_background_margin_db`, `background_margin_a_db` | después de 4.0.0rc1 |
| `emission.EmissionPressureResult` | `upper_bound` | gana `background_margin_db`, solo por nombre | 4.0.0rc1 |
| `emission.PrecisionCriteria` | de `criterion_1` a `criterion_5`, `qualified` | gana las lecturas: `indicators`, `scan_intensity_level_1`, `scan_intensity_level_2`, `frequencies`, `repeatability_limit_db`, `pressure_residual_index`, `field_nonuniformity_1`, `field_nonuniformity_2` | 3.3.0 |
| `emission.DiscretePointIntensityResult` | todo salvo los indicadores y el grado: `partial_power`, `sound_power`, `sound_power_level`, `achieved_grade`, los dos criterios, las cifras con ponderación A y el resto | gana `normal_intensity`, `segment_areas_m2`, `pressure_residual_index`, `fraction` | 4.0.0rc1 |
| `emission.TurbineTestEnvironmentCheck` | `correction_ok`, `wind_ok`, `windscreen_advised` | `environmental_correction`, `ratio`, `wind_speed_m_s` | después de 4.0.0rc1 |
| `environment.ImpulseOnset` | `level_difference`, `prominence`, `qualifies` | `level_start`, `level_end`, `onset_rate` | 3.3.0 |
| `environment.ImpulseProminenceResult` | `per_impulse`, `qualifies`, `prominence`, `adjustment` | `onset_rates`, `level_differences`, `assessment_period_minutes` | 3.3.0 |
| `environment.ResidualCorrectionResult` | `reliable` | `margin` | 3.3.0 |
| `environment.PeriodAssessment` | `reported_level`, `reported_long_term`, `max_phase_level`, `phase_pass`, `daily_pass`, `long_term_pass` | `phases`, los dos niveles y `limit`; gana `new_activity`, solo por nombre | 4.0.0rc1 |
| `environment.ModulationPeriod` | `modulation_depths_db`, `fundamental_frequencies_hz`, `n_valid_blocks`, `rated`, `rating_db`, `mean_modulation_frequency_hz`, `mode_modulation_frequency_hz` | `blocks` | después de 4.0.0rc1 |
| `environment.SoundRelevantTurbines` | `relevant`, `total_level`, `relevant_level` | `predicted_levels` | después de 4.0.0rc1 |
| `environment.WindShearProfile` | `typical` | `shear_exponent` | después de 4.0.0rc1 |
| `environment.WindTurbineTonalityResult` | `is_audible` | `tonal_audibility`, `has_identified_tone`, que también es de solo lectura (sección siguiente) | 3.3.0 |
| `filters.FilterComplianceResult` | `bands`, `overall_class`, `range_limited` | gana `band_margins`, las filas sin su clase | 3.3.0 |
| `filters.WeightingComplianceResult` | `bands`, `overall_class`, `range_limited` | gana `band_margins`, las filas sin su clase | 4.0.0rc1 |
| `hearing.AscendingThresholdResult` | `threshold_level`, `determined`, `series_exhausted` | `ascent_levels`, `shortened` | después de 4.0.0rc1 |
| `hearing.TaskContribution` | `spread_advisory` | `n_samples`, `sample_range_db` | 3.3.0 |
| `hearing.ExposureResult` | `sampling_advisory` | gana `sample_range_db`, `n_workers`, `sample_duration_hours`, solo por nombre | 3.3.0 |
| `hearing.AttenuationDifferenceResult` | `difference`, `significance_limit_db`, `significant` | las dos medias y sus incertidumbres expandidas | después de 4.0.0rc1 |
| `materials.CeilingSpecimenCheck` | `area_error_m2`, `deflection_ok`, `substructure_ok`, `fixture_ok`, `supports_ok`, `humidity_ok`, `ce_marking_depth`, `passes` | gana las cifras medidas: `deflection_mm`, `substructure_width_mm`, `substructure_height_mm`, `fixture_density_kg_m2`, `support_width_mm`, `support_height_mm`, `support_center_distance_m`, `lowest_relative_humidity_percent` | después de 4.0.0rc1 |
| `metrology.TrendTestResult` | `trend_free`, `bounds` | `statistic`, frente a la región que dan `values`, `method`, `alpha` y `median` | 3.3.0 |
| `metrology.StationarityTestResult` | `stationary`, `bounds` | `trend_statistic`, frente a la región que dan `segment_values`, `method` y `alpha` | 3.3.0 |
| `metrology.CouplerCheck` | `ratio_recommended`, `approximation_valid`, `full_solution_advised`, `conditions_valid` | gana `heat_conduction_method`, `temperature_c`, `static_pressure_pa`, `relative_humidity_percent`, `in_air`, solo por nombre | después de 4.0.0rc1 |
| `metrology.FreeFieldArrangementCheck` | `distances_ok`, `support_ok`, `annex_a_range`, `attenuation_accuracy` | gana `air_attenuation` | después de 4.0.0rc1 |
| `noise_control.CabinUncertainty` | `ratio_satisfied`, `stateable`, `stated_band_range_hz`, `increased_uncertainty_band_range_hz`, `excess_standard_deviation_db` | `method`, `volume_ratio` | después de 4.0.0rc1 |
| `room.RoomAcousticsResult` | `edt_valid`, `t20_valid`, `t30_valid` | `dynamic_range` y los tiempos de caída | 3.3.0 |
| `room.BackgroundMarginCheck` | `needs_correction`, `unusable`, `passes` | `margins_db` | después de 4.0.0rc1 |
| `room.PredictionDetailCheck` | `passes`, `room_ok`, `fittings_ok`, `sources_ok` | gana `room_detail`, `fitting_detail`, `source_detail` | después de 4.0.0rc1 |
| `underwater.WeightedExposureResult` | `exceeds_injury`, `exceeds_tts` | `sel_margin`, `peak_margin`, `tts_margin`, `tts_peak_margin` | 4.0.0rc1 |
| `vibration.PeopleAssessment` | `passes`, `criterion`, `within_uncertainty` | `kb_fmax`, `kb_ftr`, `guide`, `source`; gana `rare_short_events`, solo por nombre | después de 4.0.0rc1 |
| `vibration.RailwayChange` | `passes`, `kb_fmax_met`, `kb_ftr_met`, `kb_fmax_increase_percent`, `kb_ftr_increase_percent` | gana `kb_fmax_before`, `kb_fmax_after`, `kb_ftr_before`, `kb_ftr_after` | después de 4.0.0rc1 |
| `vibration.TransferStiffnessResult` | `valid` | gana `transmissibility`, el \|T\| del método indirecto | 3.3.0 |
| `vibration.DrivingPointStiffnessResult` | `adequate` | gana `blocked_output_difference`, `unwanted_input_difference` | después de 4.0.0rc1 |
| `aircraft.AircraftSystemComplianceResult` | `passes`, `checks` | gana `directional`, `frequency_response`, `linearity`, `resolution`, los argumentos de `verify_aircraft_noise_system` | 4.0.0rc1 |
| `broadcast.QuasiPeakDynamicsResult` | `passes`, `worst_margin_db`, `worst_deviation_db`, `stimuli` | gana `readings_percent`, las once lecturas en el orden de las tablas 2 y 3 | 4.0.0rc1 |
| `building.FloorCoveringImprovementResult` | `limited` | gana `background_margin_db`, el menor margen de todas las posiciones y de los dos forjados | 3.1.0 |
| `building.VibrationReductionResult` | `single_number`, `bracketed` | `frequencies`, `k_ij`; gana `modal_overlap`, `fraction` | 3.1.0 |
| `building.ServiceEquipmentBackgroundResult` | `difference`, `correction`, `corrected_levels`, `regime` | `measured_levels`, `background_levels` | después de 4.0.0rc1 |
| `building.ServiceEquipmentResult` | `standardizable` | `frequencies`, `fraction` | después de 4.0.0rc1 |
| `emission.SoundPowerIntensityResult` | `partial_power_level`, `sound_power`, `sound_power_level`, `negative_band`, `negative_partial_power_index`, `dynamic_capability_index`, `achieved_grade`, `a_weighting_omitted_bands`, `sound_power_level_a` | `partial_power` y los indicadores; gana `pressure_residual_index`, `fraction`, `repeatability_limit_db` | 3.1.0 |
| `emission.PrecisionIntensityResult` | `sound_power`, `sound_power_level`, `sound_power_level_normalized`, `not_applicable_band`, `sound_power_level_a` | `partial_power`; gana `temperature_c`, `static_pressure_pa`, solo por nombre | 3.1.0 |
| `emission.InDuctSoundPowerResult` | `information_only_band` | `frequencies`, `flow_velocity` | 4.0.0rc1 |
| `emission.SourceLocationPlan` | `spectral_character`, `a_weighted_spectral_character` | `standard`, `standard_deviation_db`, `a_weighted_standard_deviation_db` | después de 4.0.0rc1 |
| `environment.ImpulsiveSoundResult` | `prominence`, `adjustment`, `category`, `adjusted_laeq` | `onsets`, `laeq` | 3.3.0 |
| `environment.ModulationBlock` | `status` | `prominence`; gana `excluded`, solo por nombre | después de 4.0.0rc1 |
| `environment.ReferenceTrackCheck` | `conditions` | la rugosidad, las tasas de decaimiento y los límites; gana `curve_radius_m`, `track_gradient_ratio`, solo por nombre | después de 4.0.0rc1 |

`FilterComplianceResult` y `WeightingComplianceResult` guardan sus filas por
banda como `band_margins`: las filas que guardaba `bands`, sin la clave
`"class"`. Una fila que declara una clase se rechaza, y la propiedad `bands`
añade a cada fila la clase que ganan sus márgenes, de modo que
`result.bands[i]["class"]` se lee como antes.
`IntensityInstrumentComplianceResult` ya no recibe filas por banda: guarda las
frecuencias y el índice presión-intensidad residual medido, y lee de ellos,
del dispositivo y de la separación de los micrófonos las filas, la clase y
`range_limited`.

Las filas de las que se lee un veredicto son de solo lectura. `band_margins` y
`between_nominals` se copian en diccionarios de solo lectura al construir el
resultado, de modo que escribir en una lanza `TypeError` y escribir después en
los diccionarios con los que se construyó no mueve la clase; para cambiar una
fila, cópiela con `dict(row)`, porque `copy.deepcopy` no puede copiar un
diccionario de solo lectura. Las filas de `AircraftSystemComplianceResult.checks`,
`QuasiPeakDynamicsResult.stimuli` y `ReferenceTrackCheck.conditions` se
construyen, cada vez que se leen, a partir de lo que guarda el resultado y de
las tablas de la norma.

```python
import dataclasses

from phonometry import building, filters

gap = building.check_gap_width([5.0, 5.1, 5.2, 5.1])
print(gap.passes, round(gap.spread_mm, 1))
# True 0.2
try:
    dataclasses.replace(gap, passes=False)
except TypeError as error:
    print(type(error).__name__)
# TypeError
wider = dataclasses.replace(gap, readings_mm=(5.0, 5.1, 5.6, 5.1))
print(wider.uniform, wider.passes)
# False False
bank = filters.OctaveFilterBank(fs=48000, fraction=1, order=6, limits=[125, 4000])
result = filters.verify_filter_class(bank)
print(result.overall_class, result.bands[0]["class"], "class" in result.band_margins[0])
# 1 1 False
```

Una bandera sigue siendo un campo cuando no es un veredicto contra un límite y
nada de lo que guarda el resultado la decide: una opción que fija quien llama,
como `small_room` o `noise_is_tonal`; una rama que eligió quien llama con lo
que pasó, como `InverseSquareLawResult.origin_fitted`; un hecho de una entrada
que el resultado no guarda, como `TimeWeightedEnvelope.calibrated`; una
propiedad del fichero leído; si un resolvedor iterativo convergió; y una
columna de una fila de una tabla publicada. `CriticalCouplingResult.converged`
conserva el desenlace de su resolución, que el resultado no puede repetir,
pero ya no puede declarar la convergencia junto a una absorción que no supera
0,999, la tercera condición de la bandera. Un régimen que el resultado podría
leer de sus propios valores es un veredicto, y la sección siguiente enumera los
que se han movido. `PlantRequirement` y `LoopRequirement` no cambian: sus
filas conservan cada límite como campo por la razón que da la sección
anterior, y `PlantRequirement.holds` sigue junto a él. `TrackCondition`
conserva su `holds` como fila del informe, pero `ReferenceTrackCheck`
construye sus condiciones a partir de la vía que guarda, así que ningún
veredicto lee una construida en otro sitio. También se quedan los `checks` de
sí o no de `SoundLevelMeterPeriodicRequirement`: son lo que vio quien ensaya,
una sobrecarga indicada o un indicador enclavado, no un límite juzgado.

## Un resultado lee su régimen de los valores que guarda

Algunos resultados guardaban un régimen o una clasificación junto a los
valores de los que se leía: el régimen de una válvula, si un martillo rebota,
si el terreno apantalla un trayecto, si se encontró un tono, si un promediado
síncrono tuvo que interpolar. La función comparaba valores que el resultado
guarda, o podría guardar, con una constante o con un umbral que imprime su
fuente, y guardaba la respuesta, así que un resultado construido a mano podía
guardar la rigidez de un martillo en régimen subcrítico y decir que es
sobrecrítico. En 4.0 cada una es una propiedad de solo lectura, leída de los
valores que conserva el resultado, y un resultado que no conservaba lo que lee
la prueba ahora lo conserva, con la unidad en el nombre. «Solo por nombre»
marca un campo que solo se pasa por nombre.

Un valor justo en un límite cae donde lo pone la fuente. Hopkins imprime el
caso sobrecrítico como K m ≥ 4 Zdp², así que el amortiguamiento crítico es
sobrecrítico, e IEC TS 61400-11-2 pide un total «al menos 3 dB» por encima del
fondo para la resta logarítmica, así que una diferencia de 3 dB la recibe.
IEC 60534-8-4 no zanja su umbral de cavitación en un solo sentido: la prueba de
5.1 no deja el umbral mismo de ningún lado, la región de la Ecuación (9) y la
Ecuación (19b) lo ponen con los puntos con cavitación, y 4.1, la Ecuación (18b)
y 6.3 con los turbulentos. La biblioteca lo lee como turbulento, donde la
Ecuación (9) devuelve cero y las dos ramas se encuentran sin escalón.

Las funciones reciben los mismos argumentos y devuelven los mismos números.
Tiene que cambiar el código que construye uno de estos resultados directamente
o que sustituye uno de los campos de los que se lee su régimen, y también el que
lee `fraction` de `vibration_reduction_index` (véase debajo de la tabla).

| Resultado | Ya no es campo del constructor | Se lee de | Desde |
| --- | --- | --- | --- |
| `building.TappingForceResult` | `over_critical`, K m ≥ 4 Zdp² (Hopkins, ecuación 3.95) | `contact_stiffness`, `impedance`; gana `mass`, solo por nombre | 4.0.0rc1 |
| `noise_control.HydrodynamicValveNoise` | `regime`, con cavitación cuando Δp supera x_Fzp1 (p1 - pv) (IEC 60534-8-4, 5.1) | `differential`, `corrected_ratio`; gana `inlet_pressure_pa`, `vapor_pressure_pa` | 4.0.0rc1 |
| `noise_control.AerodynamicValveNoise` | `regime`, los cinco intervalos de IEC 60534-8-3, 5.2 | `pressure_ratio`, `boundaries`; gana `specific_heat_ratio`, `pressure_recovery`, `efficiency_correction`, solo por nombre | 4.0.0rc1 |
| `aircraft.TerrainScreeningResult` | `screened`, terreno estrictamente por encima de la línea de visión | `source`, `receiver`, `distances_m`, `heights_m` | 3.3.0 |
| `hearing.AutomaticThresholdResult` | `is_peak`, `retained` (ISO 8253-1, 6.3.5 a)) | `reversal_levels` | después de 4.0.0rc1 |
| `hearing.SweepThresholdResult` | `is_peak` | `reversal_levels` | después de 4.0.0rc1 |
| `metrology.WaveMotionCorrection` | `interpolated` | `frequencies`, `speed_of_sound_ratio` | después de 4.0.0rc1 |
| `noise_control.CabinInsulationResult` | `apparent` (ISO 11957, 3.6) | `method` | después de 4.0.0rc1 |
| `noise_control.WeightedCabinInsulation` | `apparent` (ISO 11957, 3.9) | `method`, que `weighted_cabin_insulation` recibe ahora como lo recibe `cabin_insulation` | después de 4.0.0rc1 |
| `environment.WindTurbineTonalityResult` | `has_identified_tone` (IEC 61400-11, 9.5.2 a 9.5.4) | `levels`, `frequencies`; gana `candidate_frequency_hz`, solo por nombre | 3.3.0 |
| `building.LaboratoryJointInsulationResult` | `regime` (ISO 10140-1, J.1) | `r_s_prime`, `r_s_max`; gana `limit_at_max`, solo por nombre | después de 4.0.0rc1 |
| `environment.TurbineSoundLevels` | `regimes` (IEC TS 61400-11-2, 11.7) | `total_levels`, `background_levels` | después de 4.0.0rc1 |
| `underwater.WestonPropagationResult` | `regime` | `range_m`, `boundaries` | 4.0.0rc1 |
| `signals.SynchronousAverageResult` | `interpolated`, f_s T no es un número entero de muestras | `fs`, `period_s` | 4.0.0rc1 |

`building.VibrationReductionResult.fraction` es un campo, el conjunto de
bandas que declara quien llama: `octave_bands()` declara `fraction=1`, porque
una sola banda de octava no se distingue de una de tercio de octava por su
espaciado. `vibration_reduction_index` ya no lo rellena con
el conjunto de bandas que leía de las frecuencias; lo deja en `None`, y el
resultado lee el espaciado cada vez que calcula la media del anexo A, que da la
misma media que antes.

Los números que elige un régimen quedan atados a él, así que un resultado
construido a mano ya no puede llevar un régimen junto a los valores de otro.
Al construirse, cada uno de estos resultados rechaza:

- `TappingForceResult`: una frecuencia de corte, una frecuencia límite, un
  espectro de fuerza o una potencia inyectada que no sean los que dan K, Zdp y
  m en su régimen, y unos límites de las ecuaciones (3.99) y (3.100) que no
  estén a un factor 2 el uno del otro.
- `HydrodynamicValveNoise`: una presión de vapor igual o superior a la presión
  de entrada; un x_F o un x_Fzp1 que no sean los que dan la Ecuación (1) o la
  (3c) a partir de los campos de al lado; un punto en la evaporación o más
  allá, x_F = 1; campos de cavitación en un punto turbulento, o ninguno en uno
  con cavitación.
- `AerodynamicValveNoise`: unos límites que no sean los de su gas y su
  guarnición, y un número de Mach o una eficiencia acústica de otro régimen.
- `TerrainScreeningResult`: una fuente o un receptor que no sean un punto
  finito, una fuente en el receptor o más allá, una sección que no vaya de uno
  al otro, y una diferencia de camino o unas aristas de difracción que no sean
  las de la goma elástica sobre esa sección.
- `AutomaticThresholdResult` y `SweepThresholdResult`: inversiones que no se
  alternan, un trazado que no conserva ningún pico o ningún valle, y una media,
  un umbral o un umbral continuo que no sean los que dan las inversiones.
- `WaveMotionCorrection`: una frecuencia más allá de la última fila de la
  tabla C.3, y una corrección que la tabla no da en su frecuencia.
- `CabinInsulationResult`: un aislamiento ponderado A con cualquier método que
  no sea el del ruido real.
- `WindTurbineTonalityResult`: una candidata que no sea una línea del espectro
  a 20 Hz o más, y una cadena de las fórmulas 30 a 34 que no sea la que da el
  espectro en torno a ella.
- `LaboratoryJointInsulationResult`: un índice corregido por otra regla de J.1.
- `TurbineSoundLevels`: una diferencia de niveles que no sea el total menos el
  fondo, un nivel del aerogenerador por otra regla de 11.7, y una
  incertidumbre en un intervalo cuyo nivel no se puede determinar.
- `WestonPropagationResult`: una pérdida compuesta que no sea la ley del
  régimen vigente.
- `SynchronousAverageResult`: una rejilla de periodo de más o menos muestras
  que `round(fs * period_s)`.

```python
import dataclasses

import numpy as np

from phonometry import building

bands = np.array([100.0, 200.0, 400.0, 800.0])
force = building.tapping_force_spectrum(bands, 1.0e6, 3.0e4)
print(force.over_critical)
# False
print(building.tapping_force_spectrum(bands, 1.0e6, 100.0).over_critical)
# True
try:
    dataclasses.replace(force, impedance=100.0)
except ValueError as error:
    print("cut_off_frequency" in str(error))
# True
```

## Un tipo equivocado lanza `TypeError`, una clave que falta `KeyError`, y cada aviso tiene su tema

La documentación de Python traza la línea entre los dos rechazos: `TypeError`
se lanza «cuando una operación o una función se aplica a un objeto de tipo
inapropiado», y `ValueError` «cuando una operación o una función recibe un
argumento que tiene el tipo correcto pero un valor inapropiado». En 3.3.0 y en
4.0.0rc1 setenta y seis rechazos preguntaban el tipo de un argumento y lanzaban
`ValueError`, otros treinta y dos capturaban un `TypeError` y lo relanzaban
como `ValueError`, y las guardas compartidas de todo parámetro escalar
rechazaban así también un array, mientras que unos pocos más lanzaban
`TypeError` por el mismo error. La 4.0 lanza `TypeError` para un tipo equivocado y `ValueError` para un
tipo correcto con un valor equivocado, en todas partes. Una llamada envuelta en
`except ValueError` para absorber cualquier entrada mala debe capturar
`(TypeError, ValueError)`.

| Lo que se pasa | 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- | --- |
| un array, `None`, un texto o un objeto que no es un número donde va un número, en cualquier parámetro escalar | `ValueError`, y un texto que se lee como número, como `"20"`, se tomaba como ese número | `TypeError`, con el nombre del parámetro, tanto para `"20"` como para `"fifty"`: un texto es del tipo equivocado donde va un número, se lea como se lea |
| un elemento que no es un número dentro de un array de números (`[None, 1.0]`, `["94.0", "94.1"]`, un `bytearray` en un array de objetos) | `ValueError`, y el texto que numpy lee como números se tomaba por ellos | `TypeError`, para un texto se lea como se lea |
| un texto en cualquier forma que no sea un `str` (un `bytes`, un `bytearray`, un texto o un `bytearray` dentro de una secuencia o de un array), `None` donde no es una opción, o un objeto que no es un número, donde una elección junto a números toma sus números: `termination=` de `materials.layered_absorber` y `materials.diffuse_field_absorption`, `initial_state=` de `filters.time_weighting`, `coefficients=` de `materials.delany_bazley`, `target=` de `room.shaped_sweep_signal`, `flow_resistivity=` de `aircraft.terrain_screening_adjustment` y `aircraft.RotorcraftGround`, `speech_spectrum=` de `speech.speech_intelligibility_index` | un texto que se leía como un número se tomaba por él (`termination=["400", "400"]` como una impedancia de 400 Pa s/m, `coefficients=b"12345678"` como los códigos de sus ocho caracteres, `speech_spectrum=["60"] * 18` como dieciocho niveles de 60 dB), y el resto fallaba con un error que no nombraba nada, `None` se leía como `nan` o el registro lo guardaba | `TypeError`, que nombra el parámetro y sus opciones; `RotorcraftGround` lo rechaza al construirse. Escribe la opción como un `str` (`"rigid"`) y los números como números (`[400.0, 400.0]`) |
| un anidamiento irregular como `initial_state=` de `filters.time_weighting` | `TypeError` | `ValueError`, que nombra el parámetro, como para `termination=` de `materials.layered_absorber` |
| un `target=` de `room.shaped_sweep_signal` con más o menos de dos arrays | los arrays después del segundo quedaban sin leer | `ValueError`, que nombra el parámetro, al empezar la llamada |
| un número o un array complejo donde va uno real, en cualquier parámetro que leen las guardas compartidas, también `initial_state=` de `filters.time_weighting`, incluido un array de objetos que guarda un número complejo de NumPy; un array así entre los valores de escala o las variables correlacionadas de las funciones de paisaje sonoro de `environment`, y una posición compleja de `environment.method_a_scale_values` | `ValueError`, y un estado complejo, un array así y una posición compleja de NumPy se leían como su parte real sin más que un `ComplexWarning` | `TypeError`, que dice que debe ser real |
| un número complejo de NumPy donde va un número real (`np.complex128(343 + 50j)`), en cualquier parámetro que leen las guardas compartidas, o dentro de un array de objetos; un valor complejo o un texto en una entrada real de los motores FDTD: un mapa de `simulation.FDTD2D` o de `simulation.ElasticFDTD2D` (`c`, `rho`, `c_p`, `c_s`, `damping`), `dx`, `cfl`, los números de las fuentes y de `simulation.Material`, `simulation.ContourProbe`, `simulation.ContourPhasors` y `simulation.far_field_from_contour`; cualquier cosa que no sea un único número real (un número complejo, un texto, `None`, una lista o un array, un `bytearray` entre ellos) como tiempo `t` del `value(t)` de `simulation.GaussianPulse`, `CWSource` y `SignalSource`, o como muestra que devuelve la forma de onda de una fuente mientras avanza un motor | se leía su parte real, con no más que un `ComplexWarning`: el motor elástico avanzaba la parte real de un `c_p`, un `c_s` o un `rho` complejos, o de una muestra compleja de una `ExplosionSource` o una `ForceSource`, una `PlaneWaveSource` fallaba con ella con el error de conversión de NumPy, cada mapa de los dos motores tomaba un texto por el número que escribe (`c="343"`), y `None`, una lista o un array como tiempo o como muestra fallaban con un error de Python o de NumPy que no nombraba nada | `TypeError`, que dice que debe ser real, que debe ser números y no texto, o que debe ser un único número real |
| un valor complejo, un texto o un `bytearray` entre los números de cualquier parámetro que toma números (un espectro, un eje de frecuencias, una señal, un campo de un registro, un factor de reflexión o una impedancia), y un número complejo de cualquiera de los dos tipos donde va un número, en cualquier parámetro que leen las guardas escalares compartidas | un complejo de NumPy o un array complejo se leía como su parte real, con no más que un `ComplexWarning` (`environment.method_b_scale_values(np.complex128(0.5 + 0.3j))` puntuaba la marca de 0,5), mientras que un complejo de Python, solo o en una lista, lanzaba un `TypeError` sin nombre; se interpretaba un texto (`["94.0"]` como 94 dB) y un `bytearray` se leía como los códigos de sus caracteres (`[bytearray(b"12")]` como niveles de 49 y 50 dB) | `TypeError`, que nombra el parámetro: debe ser real, no complejo, o números, no texto; un parámetro que toma números complejos rechaza solo el texto. Tome el módulo o la parte real de una magnitud compleja antes de la llamada, y escriba los números como números |
| un texto, unos `bytes` o un número complejo de NumPy dados como un número a un parámetro que su función leía con `float()` o `complex()`, o con el que calculaba antes: `temperature_c=` de `aircraft.npd_atmosphere_increment`, una contribución de `metrology.combined_standard_uncertainty`, la altitud de `aircraft.Aerodrome.pressure_ratio`, los dos números de `aircraft.MeanGroundPlaneResult.equivalent_height`, `delay=` y `n=` de `materials.in_situ_reflection_factor`, `efficiency_correction` de un `noise_control.AerodynamicValveNoise` que construye usted, y unos trescientos más | se interpretaba como el número que escribe (`temperature_c="25"` como 25 °C, `[b"12"]` como 12), se leía su parte real, con no más que un `ComplexWarning`, o, si se calculaba antes con él, daba un `TypeError` de la aritmética que no nombraba nada | `TypeError`, que nombra el parámetro |
| un número demasiado grande para un float: un entero de Python como `10**400`, o un long double o un `Decimal` más allá del mayor float, solo o entre los números de un array | un `OverflowError` de la aritmética o de NumPy para un entero, y un infinito, con no más que un aviso, para un long double o un `Decimal` | `ValueError`, que nombra el parámetro; un infinito que se da se sigue leyendo como tal |
| un `collections.UserString`, o un `bytes`, donde va un par o una lista de etiquetas, de nombres o de índices: `shape=` de `simulation.FDTD2D`, `excluded=` de `building.loudest_corner`, `labels=` de `filters.FractionalOctaveBands`, una contribución de `metrology.combined_standard_uncertainty`, la lista de un participante de `environment.method_b_source_ranking`, `bands=` de `environment.bin_amplitude_modulation`, `ffmpeg_options=` de `io.VideoOptions`, `channel_labels=` de `io.Signal`, un material de `simulation.scholte_speed` y del motor elástico | se medía o se partía en sus caracteres (un `bytes` en sus códigos, así que `b"car"` ordenaba las fuentes `'99'`, `'97'` y `'114'`), y se rechazaba como un valor de longitud equivocada o con un error sobre su anidamiento, o se aceptaba | se rechaza como el texto que envuelve, nombrando el parámetro |
| un `collections.UserString`, o un `bytes`, donde un nombre puede valer por una lista de nombres: `parameters=` de `environment.binaural_indicators`, `targets=` de `emission.MicrophoneTraverse`, `vocal_efforts=` de `speech.standard_speech_spectra`, `basic_standards=` de `emission.NoiseEmissionDeclaration` | se partía en sus caracteres, cada uno rechazado como el nombre de ninguna fila, o se guardaba como una lista de caracteres | se rechaza entero por el nombre del parámetro, como algo que no es un texto |
| un `pathlib.Path` u otro objeto de ruta como `path` del `.report()` de un resultado | la ficha se construía y luego fallaba con el error de ReportLab | el PDF se escribe ahí, y `.report()` devuelve la ruta como texto |
| un índice que no es un entero (un indicador, un float, una fracción, un texto o un array de otro dtype): `order=` de `signals.miso_coherence`, los canales de `io.Signal.pick` | se leía con `int()`: `order=(0.5, 1.7)` condicionaba las entradas como `(0, 1)` y `order="10"` como `(1, 0)`, `pick([1.5])` tomaba el canal 1 y `pick("01")` los canales 0 y 1 | `TypeError`, con el nombre del parámetro |
| un array de la clase equivocada: una máscara que no es booleana (`obstacle_mask=` de `simulation.FDTD2D` y `simulation.fdtd_simulation`, las máscaras de región de `simulation.ElasticFDTD2D.from_regions`, `valid=` de `vibration.band_averaged_stiffness`), unos `line_counts` de `vibration.BandAveragedStiffness` que no son enteros, unos indicadores de exclusión que no son ni booleanos ni enteros (`excluded_blocks=` de `environment.amplitude_modulation_period`, `excluded=` de `environment.bin_amplitude_modulation`), texto donde van las lecturas, las distancias y las duraciones de las funciones de equipos de servicio de `building` (`building.verify_calibration_deviation`, `building.check_background_duration` y las demás) | `ValueError` | `TypeError` |
| una secuencia donde va una sola medida: las presiones y las temperaturas de `noise_control.normal_air_density`, `noise_control.total_pressure`, `noise_control.total_pressure_loss` y `noise_control.pressure_loss_coefficient`, `altitude` de `emission.static_pressure_from_altitude`, `tolerance_s=` de `building.check_background_duration` | `ValueError`, y las funciones de `noise_control` leían una secuencia de un elemento como ese elemento | `TypeError`, también una secuencia de un elemento |
| un número entero (un recuento, un índice, una clase, un número de puntos o de decimales: cualquier parámetro escrito como `int`) dado como texto, como booleano o como array: `signals.zoom_fft(..., n_points=)`, `signals.window_metrics(window, n)`, `signals.min_phase(..., oversample=)`, `electroacoustics.swept_sine_distortion(..., n_harmonics=)`, `metrology.stationarity_test(..., n_segments=)`, `vibration.story_fundamental_frequency(n_stories)`, `n_events=` de las funciones de energía acústica y de `emission.SoundEnergyResult` y `emission.ReverberationSoundEnergyResult`, `n=` de `building.prediction_input_uncertainty` y `building.intensity_element_normalized_difference`, `oversample=` de `signals.lc_peak` y `broadcast.true_peak_level`, `max_order=` de `room.image_source_rir` y `room.audible_image_count`, los índices de malla y los recuentos de pasos de `simulation.FDTD2D`, `duration_days=` de `vibration.construction_guide_values`, `start_band=` de `aircraft.tone_correction`, `n_level_ranges=` de `metrology.SoundLevelMeterFeatures`, `n_impacts` de `vibration.ImpactMobilityResult`, los recuentos de posiciones de `ReportMetadata` | `ValueError`, o, donde el valor pasaba por `int()`, un booleano tomado como 0 o 1, un texto convertido y una fracción truncada sin aviso (`n_points=100.6` dibujaba 100 puntos) | `TypeError`. Un número que no es entero, o que queda por debajo del mínimo del recuento, es `ValueError`, y un flotante entero como `5.0` se toma como `5` |
| un indicador que no es `True` ni `False`: `small_room=` de `building.check_service_equipment_positions`, `absorbing_specimen_surface=` del aislamiento de ISO 15186, las declaraciones de la cualificación de campo libre de `emission`, las prestaciones de `metrology.SoundLevelMeterFeatures` y las observaciones de `metrology.SoundLevelMeterPeriodicMeasurements` | `ValueError` | `TypeError` |
| un nombre que no es texto: los tipos de área, los usos y los periodos de las funciones del RD 1367/2007 y del DB-HR (`environment.activity_limits` y las demás), los elementos del Anexo A de `environment.SoundscapeAcousticEnvironment`, las descripciones de `emission.turbine_noise_declaration`, y cualquier elección entre opciones con nombre dada como algo que no es un texto (`period=5`) | `ValueError` | `TypeError`; un texto vacío, o uno que no nombra ninguna de las opciones, sigue siendo `ValueError` |
| un objeto de la clase equivocada: las cajas de `emission.turbine_measurement_surface`, `surface=` de `emission.turbine_microphone_positions`, `correction=` de `emission.check_turbine_test_environment`, las determinaciones de `emission.turbine_noise_declaration`, las partes de `environment.SoundscapeReport`, un material del FDTD elástico que no es `Material`, ni fila de catálogo, ni terna, una `waveform` que no se puede llamar, un array suelto en `io.write(..., sidecar=True)`, una calibración por bandas donde `emission.high_frequency_sound_power_comparison` compara tonos | `ValueError` | `TypeError` |
| un texto donde va una secuencia, un número donde va un par o una lista, o un par que contiene un array: `rankings` de `environment.method_b_source_ranking`, `bands=` de `environment.bin_amplitude_modulation`, `exclude_hz=` y los pares de frecuencias de la movilidad de ISO 7626-5, `microphones=` de las correcciones de IEC 61094-8, los límites de un banco de filtros, `shape=` de `simulation.FDTD2D`, los bordes de banda de `electroacoustics.LoudspeakerCharacteristics` y `electroacoustics.MicrophoneCharacteristics` | `ValueError` | `TypeError` |
| un `bytearray` entero donde va un par, una lista de etiquetas o de índices, o una secuencia de números o de arrays: `labels` de `filters.FractionalOctaveBands`, `excluded=` de `building.loudest_corner`, `band_hz=` y los pares de frecuencias de la movilidad de ISO 7626-5, `microphones=` de las correcciones de IEC 61094-8, los bordes de banda de `electroacoustics.LoudspeakerCharacteristics` y `electroacoustics.MicrophoneCharacteristics`, las curvas de `electroacoustics.LoudspeakerDirectivity`, `MicrophoneDirectivity`, `MicrophoneNoise` y `MicrophoneOverload`, `terrain=` de `aircraft.RotorcraftGround`, `coefficients=` de `materials.delany_bazley`, `shape=` de `simulation.FDTD2D`, `simulation.ElasticFDTD2D` y `simulation.ElasticFDTD2D.from_regions`, `order=` de `signals.miso_coherence`, los canales de `io.Signal.pick`, `low_band_microphones=` de `environment.reflection_index`; y un mapping o un conjunto donde van esas curvas, ese terreno o esos coeficientes | se leía como los códigos de sus caracteres (`labels=bytearray(b"1k")` como las etiquetas `"49"` y `"107"`, `pick(bytearray(b"\x01"))` como el canal 1), como las claves del mapping (`coefficients={0: 1.0, ...}` como C1 a C8 de 0 a 7) o como los miembros del conjunto sin orden | `TypeError`, que nombra el parámetro |
| una prestación de `hearing.assumed_protection_value` o de `hearing.hml_rating` que no es un número, un `clause=` de `metrology.max_expanded_uncertainty` que no es un número, un `part=` de `environment.method_a_scale_values` que es un booleano | `ValueError` | `TypeError`; un número que la Tabla 1 no tabula, o un apartado o una parte que no existen, siguen siendo `ValueError` |

Una consulta que no encuentra lo que busca lanza lo que lanza un mapeo cuando
el resultado se lee como uno, y `ValueError` cuando un número cae fuera de lo
que cubre:

| Lo que se pide | 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- | --- |
| `RegulationLimits[period]` para un periodo que no guarda | `ValueError` | `KeyError`. La clave se compara tal cual, como la de un `dict`: `limits["Day"]` y `limits[" night "]`, que se leían como `"day"` y `"night"`, ahora también lanzan `KeyError`. El periodo de `environment.PeriodAssessment`, que es una elección, sigue lanzando `ValueError` |
| `emission.measurement_positions("hemisphere", ..., n_reflecting_planes=3, grade="survey")` | `NotImplementedError` | las posiciones 14, 21 y 22 de la Tabla B.2 de ISO 3746:2010 |
| `emission.measurement_positions("hemisphere", ..., grade="survey")` sobre un plano reflectante | las posiciones 4, 5, 6 y 10 de la Tabla B.1 de ISO 3744, el conjunto para una fuente con tonos | las posiciones 4, 5, 6 y 10 de la Tabla B.1 de ISO 3746:2010, las que prescribe el apartado 8.2.1: las posiciones de banda ancha con esos números de la Tabla B.2 de ISO 3744 |
| un `instrument=` que la tabla C.5 no enumera (`"Class 1"` por `"class1"`), en `hearing.task_based_exposure`, `hearing.job_based_exposure` y `hearing.full_day_exposure` | `KeyError` | `ValueError`, y `TypeError` para un valor que no es texto: el instrumento es una elección, no una clave que el llamador vuelve a leer |
| `fluids.FluidPropertyUnavailable` | la excepción | `fluids.FluidPropertyUnavailableError`, que sigue siendo un `AttributeError`, así que `hasattr` y `getattr` con un valor por defecto se comportan como antes |

Estos avisos derivan ahora de `PhonometryWarning`, cada uno con un tema propio,
así que `warnings.simplefilter("error", phonometry.PhonometryWarning)` los
alcanza a todos y un filtro sobre el tema alcanza a uno. Siguen siendo
`UserWarning`, así que un filtro escrito sobre esa clase sigue casando:

| Lo emite | 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- | --- |
| `environment.sound_absorption_rating` y `environment.sound_reflection_rating` en el tope de 0,99 | `environment.RoadDeviceWarning`, un `UserWarning` fuera de la jerarquía | `environment.RoadDeviceWarning`, un `PhonometryWarning` |
| `building.equivalent_impact_level`, `building.weighted_lining_improvement` y `building.lining_improvement` fuera del intervalo para el que se enuncia su relación | `UserWarning` | `building.BuildingPredictionWarning` |
| `building.intensity_element_normalized_difference` con `n > 1` | `UserWarning` | `building.LaboratoryInsulationWarning` |
| `room.room_criterion` sobre un espectro al que le falta una banda de 31,5 Hz a 4000 Hz | `UserWarning` | `room.NoiseCriterionWarning` |
| `aircraft.approach_profile` ante un paso Level-Idle cuya altitud o CAS de inicio no casa con el paso Level-Idle siguiente (Doc 29 B7.1.4) | `UserWarning` | `aircraft.FlightProfileWarning`, que también avisa ante un paso siguiente que no es Level-Idle ni Descend-Idle (caso 2) |
| `signals.tone_burst` cuando `fs` y `frequency` son inconmensurables | `PhonometryWarning` | `signals.ToneBurstWarning` |
| `underwater.normal_modes`, `underwater.eigenrays` y `underwater.gaussian_beams` | `PhonometryWarning` | `underwater.NumericalPropagationWarning` |
| un banco de filtros que descarta las bandas por encima de la frecuencia de Nyquist (`Low sampling rate`) | `PhonometryWarning` | `filters.FilterBankWarning` |

```python
import phonometry
from phonometry import environment, vibration

limits = environment.activity_limits("a")
try:
    limits["noon"]
except KeyError:
    print("KeyError")
for n_stories in ("5", 2.5):
    try:
        vibration.story_fundamental_frequency(n_stories)
    except (TypeError, ValueError) as refusal:
        print(type(refusal).__name__)
print(issubclass(environment.RoadDeviceWarning, phonometry.PhonometryWarning))
# KeyError
# TypeError
# ValueError
# True
```

## Un aviso nombra la línea de tu código que lo causó

Cada aviso de la biblioteca se muestra ahora en la primera línea del código de
quien llama, sean cuales sean las funciones de la biblioteca por las que se
llegó a él. La acción `default` de Python lo muestra entonces una vez por cada
línea tuya que lo causa, y un filtro por módulo lee tu módulo. Una traza nombra
el aviso por el paquete que lo exporta:

| Qué | 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- | --- |
| el fichero y la línea en que se muestra un aviso | la línea hasta la que contaba su `stacklevel`, una línea de la biblioteca en 33 de ellos, como `filters/core.py:698` para cada banco de filtros que descartaba una banda | la línea de tu código que hizo la llamada |
| `warnings.filterwarnings("ignore", module="phonometry")` | silenciaba los avisos mostrados en una línea de la biblioteca, y ningún otro | no silencia ninguno; filtra por clase, `warnings.filterwarnings("ignore", category=phonometry.PhonometryWarning)`, o por tema |
| `warnings.filterwarnings("error", module="my_analysis")` | no alcanzaba los avisos mostrados en una línea de la biblioteca | alcanza cada aviso que causa una llamada de `my_analysis` |
| `filters.OctaveFilterBank(44100)`, `filters.octave_filter(x, 44100)` y los demás bancos sobre el intervalo por defecto, a una frecuencia de muestreo que no admite sus bandas altas (44,1, 32, 22,05, 16 u 8 kHz) | `FilterBankWarning: Low sampling rate: frequencies above fs/2 removed` | ningún aviso, y las mismas bandas: el intervalo por defecto se recorta a lo que admite `fs` |
| un banco sobre unos `limits` que das y pasan de fs/2 | el mismo aviso, sólo en la primera llamada, porque el diseño se guarda en caché | `FilterBankWarning: Low sampling rate: fs = 44100 Hz cannot hold the 20 kHz band, whose upper edge 22387 Hz is above fs/2 = 22050 Hz; it was left out of the bank.`, en cada llamada; un filtro sobre el mensaje `Low sampling rate` sigue casando |
| un banco a una frecuencia de muestreo que no admite ninguna banda de su intervalo, el de por defecto o el tuyo, como `filters.OctaveFilterBank(20, fraction=3)` | `FilterBankWarning: Low sampling rate: frequencies above fs/2 removed`, y un banco sin bandas cuyo análisis volvía vacío | `ValueError: fs = 20 Hz cannot hold any band from 12.5 Hz to 20 kHz: the upper edge of the lowest, 14.13 Hz, is above fs/2 = 10 Hz.` |
| `vibration.transfer_stiffness_indirect` con una transmisibilidad que contiene `inf` o `nan` | un array con `-inf+nanj` | `ValueError: 'transmissibility' must contain only finite values.` |
| el nombre que dan una traza, un repr o pickle a los 14 avisos escritos en módulos privados, `PhonometryWarning` entre ellos | el módulo privado, `phonometry.fluids._state.FluidAssumptionWarning` | el paquete que lo exporta, `phonometry.fluids.FluidAssumptionWarning`; la clase es la misma, e `inspect.getsource` sobre ella lanza `OSError` |

## Una opción se compara tal como se escribe

Un parámetro o un campo de registro tipado con un `Literal` de sus opciones,
cuyo código limpiaba el texto antes de comprobarlo, acepta ahora las grafías
que ese `Literal` enumera, y solo esas. Antes de 4.0, 198 de ellos cambiaban
mayúsculas y minúsculas, quitaban espacios, intercambiaban `_`, `-` y
espacios, traducían un alias propio o convertían en texto cualquier valor con
`str()` antes de buscar la opción, de modo que una llamada que un comprobador
de tipos rechazaba se ejecutaba igualmente:
`filters.WeightingFilter(48000, "a")`, `filters.time_weighting(x, fs,
mode="FAST")`, `vibration.guide_values("residential", edition=1999)`. Otros
dos leían una opción y tomaban cualquier otro valor por la segunda: el
`onset_rate_method` de `environment.detect_onsets` y de
`environment.impulsive_sound_adjustment` ajustaba como mínimos cuadrados todo
lo que no fuera `"upper_half"`. En 4.0 esa llamada lanza `ValueError`, o
`TypeError` para un valor que no es texto, y el arreglo es escribir la opción
tal como la enumera su `Literal`. Los alias
que un `Literal` enumera a propósito siguen valiendo: `"docente"` por
`"educational"` en `building.db_hr_facade_requirement`, `"dnt_w"` por `"r_w"`
en `building.single_number_uncertainty`. Los ficheros que lee la biblioteca,
como una base de datos ANP, se siguen leyendo escriban sus palabras con las
mayúsculas que escriban.

```python
from phonometry import filters

try:
    filters.WeightingFilter(48000, "a")
except ValueError as refusal:
    print(type(refusal).__name__)
print(filters.WeightingFilter(48000, "A").weighting)
# ValueError
# A
```

Cada fila es un parámetro que dejó de aceptar una grafía, con un ejemplo de cada
clase que aceptaba y todos sus alias propios. Los ejemplos salen de ejecutar,
con la grafía cambiada, las llamadas que hace la batería de pruebas y unas pocas
escritas a propósito, sobre el código justo anterior a 4.0. Algunos de los
parámetros son posteriores a 4.0.0rc1, o se renombraron después; sus filas solo
afectan al código escrito desde entonces.

| Parámetro | Aceptaba antes de 4.0 | 4.0 lanza |
| --- | --- | --- |
| `aircraft.ANPAircraft.event_level(metric=)` | otras mayúsculas (`"EXPOSURE"` por `"exposure"`); espacios alrededor (`" exposure "` por `"exposure"`) | `ValueError` |
| `aircraft.ANPAircraft.event_level(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPAircraft.noise_contour(metric=)` | otras mayúsculas (`"EXPOSURE"` por `"exposure"`); espacios alrededor (`" exposure "` por `"exposure"`) | `ValueError` |
| `aircraft.ANPAircraft.noise_contour(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPAircraft.npd_curves(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPAircraft.profile(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPAircraft.revised_npd_curves(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPAircraft.spectral_class(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPDatabase.event_level(metric=)` | otras mayúsculas (`"EXPOSURE"` por `"exposure"`); espacios alrededor (`" exposure "` por `"exposure"`) | `ValueError` |
| `aircraft.ANPDatabase.event_level(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPDatabase.flight_profile(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPDatabase.noise_contour(metric=)` | otras mayúsculas (`"EXPOSURE"` por `"exposure"`); espacios alrededor (`" exposure "` por `"exposure"`) | `ValueError` |
| `aircraft.ANPDatabase.noise_contour(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPDatabase.npd_curves(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" A "` por `"A"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPDatabase.procedural_profile(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPDatabase.procedural_steps(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPDatabase.profile(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.ANPDatabase.revised_npd_curves(operation=)` | otras mayúsculas (`"DEPARTURE"` por `"departure"`); espacios alrededor (`" departure "` por `"departure"`); alias propios (`"a"`, `"approach"`, `"arrivals"`, `"d"`, `"departures"`, `"landing"`, `"take-off"`, `"takeoff"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.AircraftSystemComplianceResult(linearity=)` | claves que no son texto pero se escriben como opciones | `TypeError` para un valor que no es texto |
| `aircraft.PerformanceAircraft.flap(operation=)` | otras mayúsculas (`"d"` por `"D"`); espacios alrededor (`" D "` por `"D"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `aircraft.engine_installation_correction(mounting=)` | otras mayúsculas (`"WING"` por `"wing"`); espacios alrededor (`" wing "` por `"wing"`); alias propios (`"prop"`) | `ValueError` |
| `aircraft.event_level(metric=)` | otras mayúsculas (`"EXPOSURE"` por `"exposure"`); espacios alrededor (`" exposure "` por `"exposure"`) | `ValueError` |
| `aircraft.event_level(mounting=)` | otras mayúsculas (`"WING"` por `"wing"`); espacios alrededor (`" wing "` por `"wing"`) | `ValueError` |
| `aircraft.ground_effect_adjustment(flow_resistivity=)` | otras mayúsculas (`"g"` por `"G"`); espacios alrededor (`" G "` por `"G"`) | `ValueError` |
| `aircraft.noise_contour(metric=)` | otras mayúsculas (`"EXPOSURE"` por `"exposure"`); espacios alrededor (`" exposure "` por `"exposure"`) | `ValueError` |
| `aircraft.noise_contour(mounting=)` | otras mayúsculas (`"WING"` por `"wing"`); espacios alrededor (`" wing "` por `"wing"`) | `ValueError` |
| `aircraft.start_of_roll_directivity(engine=)` | otras mayúsculas (`"JET"` por `"jet"`); espacios alrededor (`" jet "` por `"jet"`); alias propios (`"prop"`, `"propeller"`, `"turbofan"`) | `ValueError` |
| `aircraft.terrain_screening_adjustment(flow_resistivity=)` | otras mayúsculas (`"d"` por `"D"`); espacios alrededor (`" D "` por `"D"`) | `ValueError` |
| `building.d2m_nt_a(spectrum=)` | otras mayúsculas (`"RAILWAY"` por `"railway"`); espacios alrededor (`" railway "` por `"railway"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `building.d2m_nt_atr(spectrum=)` | otras mayúsculas (`"TRAFFIC"` por `"traffic"`); espacios alrededor (`" traffic "` por `"traffic"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `building.db_hr_airborne_requirement(receiving_room=)` | otras mayúsculas (`"PROTECTED"` por `"protected"`); espacios alrededor (`" protected "` por `"protected"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `building.db_hr_airborne_requirement(source_room=)` | otras mayúsculas (`"SAME_UNIT"` por `"same_unit"`); espacios alrededor (`" same_unit "` por `"same_unit"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `building.db_hr_facade_requirement(building_use=)` | otras mayúsculas (`"RESIDENTIAL"` por `"residential"`); espacios alrededor (`" residential "` por `"residential"`) | `ValueError` |
| `building.db_hr_facade_requirement(dominant_noise=)` | otras mayúsculas (`"ROAD"` por `"road"`); espacios alrededor (`" road "` por `"road"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `building.db_hr_facade_requirement(room_type=)` | otras mayúsculas (`"BEDROOMS"` por `"bedrooms"`); espacios alrededor (`" bedrooms "` por `"bedrooms"`) | `ValueError` |
| `building.db_hr_global_index(spectrum=)` | otras mayúsculas (`"PINK"` por `"pink"`); espacios alrededor (`" pink "` por `"pink"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `building.db_hr_impact_requirement(receiving_room=)` | otras mayúsculas (`"PROTECTED"` por `"protected"`); espacios alrededor (`" protected "` por `"protected"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `building.db_hr_impact_requirement(source_room=)` | otras mayúsculas (`"OTHER_UNIT"` por `"other_unit"`); espacios alrededor (`" other_unit "` por `"other_unit"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `building.db_hr_reverberation_requirement(room_use=)` | otras mayúsculas (`"CLASSROOM"` por `"classroom"`); espacios alrededor (`" classroom "` por `"classroom"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `building.estimate_reverberation_index(room=)` | otras mayúsculas (`"G"` por `"g"`); espacios alrededor (`" g "` por `"g"`); alias propios (`"other"`, `"others"`) | `ValueError` |
| `building.single_number_uncertainty(quantity=)` | otras mayúsculas (`"R_W"` por `"r_w"`); espacios alrededor (`" r_w "` por `"r_w"`) | `ValueError` |
| `building.uncertain_value(quantity=)` | otras mayúsculas (`"R_W"` por `"r_w"`); espacios alrededor (`" r_w "` por `"r_w"`) | `ValueError` |
| `environment.activity_limits(area_type=)` | otras mayúsculas (`"A"` por `"a"`); espacios alrededor (`" a "` por `"a"`) | `ValueError` |
| `environment.adjacent_premises_limits(building_use=)` | otras mayúsculas (`"RESIDENTIAL"` por `"residential"`); espacios alrededor (`" residential "` por `"residential"`) | `ValueError` |
| `environment.adjacent_premises_limits(room_type=)` | otras mayúsculas (`"BEDROOMS"` por `"bedrooms"`); espacios alrededor (`" bedrooms "` por `"bedrooms"`) | `ValueError` |
| `environment.assess_activity(period_hours=)` | otras mayúsculas (claves: `{"Day": 12.0}`); espacios alrededor (claves: `{" day ": 12.0}`); claves que no son texto pero se escriben como opciones | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.bridge_transfer(bridge=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.detect_onsets(onset_rate_method=)` | cualquier valor: todo lo que no fuera exactamente `"upper_half"` se ajustaba como `"least_squares"` (`"UPPER_HALF"`, `" upper_half "`, `"banana"`, `5`) | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.impulsive_sound_adjustment(onset_rate_method=)` | cualquier valor: todo lo que no fuera exactamente `"upper_half"` se ajustaba como `"least_squares"` (`"UPPER_HALF"`, `" upper_half "`, `"banana"`, `5`) | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.indoor_quality_objectives(building_use=)` | otras mayúsculas (`"RESIDENTIAL"` por `"residential"`); espacios alrededor (`" residential "` por `"residential"`) | `ValueError` |
| `environment.indoor_quality_objectives(room_type=)` | otras mayúsculas (`"LIVING"` por `"living"`); espacios alrededor (`" living "` por `"living"`) | `ValueError` |
| `environment.infrastructure_limits(area_type=)` | otras mayúsculas (`"E"` por `"e"`); espacios alrededor (`" e "` por `"e"`) | `ValueError` |
| `environment.max_infrastructure_limit(area_type=)` | otras mayúsculas (`"E"` por `"e"`); espacios alrededor (`" e "` por `"e"`) | `ValueError` |
| `environment.measured_insertion_loss_indirect(receiver_type_after=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.measured_insertion_loss_indirect(receiver_type_before=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.outdoor_quality_objectives(area_type=)` | otras mayúsculas (`"E"` por `"e"`); espacios alrededor (`" e "` por `"e"`) | `ValueError` |
| `environment.outdoor_quality_objectives(urbanization=)` | otras mayúsculas (`"EXISTING"` por `"existing"`); espacios alrededor (`" existing "` por `"existing"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.pass_by_regression(vehicle_category=)` | espacios alrededor (`" 1 "` por `"1"`); un número (`1` por `"1"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.rail_roughness(roughness=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.road_propulsion_noise(category=)` | un número (`1` por `"1"`); un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.road_propulsion_noise(surface=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.road_rolling_noise(category=)` | un número (`1` por `"1"`); un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.road_rolling_noise(surface=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.road_source_power(surface=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.road_surface_coefficients(surface=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.road_vehicle_sound_power(category=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.road_vehicle_sound_power(surface=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.statistical_pass_by(corrected_vehicle_sound_levels=)` | otras mayúsculas (claves: `{"1": 78.8, "2A": 81.1, "2B": 83.8}`); espacios alrededor (claves: `{" 1 ": 78.8, " 2a ": 81.1, " 2b ": 83.8}`); claves que no son texto pero se escriben como opciones | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.statistical_pass_by(reference_levels=)` | otras mayúsculas (claves: `{"1": 80.0, "2A": 85.0, "2B": 89.0}`); espacios alrededor (claves: `{" 1 ": 80.0, " 2a ": 85.0, " 2b ": 89.0}`); claves que no son texto pero se escriben como opciones | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.statistical_pass_by(weighting_factors=)` | otras mayúsculas (claves: `{"1": 0.9, "2A": 0.075, "2B": 0.025}`); espacios alrededor (claves: `{" 1 ": 0.9, " 2a ": 0.075, " 2b ": 0.025}`); claves que no son texto pero se escriben como opciones | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.statistical_pass_by_index(vehicle_sound_levels=)` | otras mayúsculas (claves: `{"1": 78.5, "2A": 81.1, "2B": 83.8}`); espacios alrededor (claves: `{" 1 ": 78.5, " 2a ": 81.1, " 2b ": 83.8}`); claves que no son texto pero se escriben como opciones | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.statistical_pass_by_index(weighting_factors=)` | otras mayúsculas (claves: `{"1": 0.8, "2A": 0.1, "2B": 0.1}`); espacios alrededor (claves: `{" 1 ": 0.8, " 2a ": 0.1, " 2b ": 0.1}`); claves que no son texto pero se escriben como opciones | `ValueError`, y `TypeError` para un valor que no es texto |
| `environment.track_transfer(track=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.traction_sound_power(vehicle=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `environment.vibration_quality_objective(building_use=)` | otras mayúsculas (`"RESIDENTIAL"` por `"residential"`); espacios alrededor (`" residential "` por `"residential"`) | `ValueError` |
| `environment.wheel_roughness(brake=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `filters.OctaveFilterBank.filter(mode=)` | otras mayúsculas (`"RMS"` por `"rms"`) | `ValueError` |
| `filters.OctaveFilterBank.spectrogram(mode=)` | otras mayúsculas (`"RMS"` por `"rms"`) | `ValueError` |
| `filters.TimeWeighting(mode=)` | otras mayúsculas (`"FAST"` por `"fast"`) | `ValueError` |
| `filters.WeightingFilter(weighting=)` | otras mayúsculas (`"a"` por `"A"`) | `ValueError` |
| `filters.time_weighting(initial_state=)` | otras mayúsculas (`"ZERO"` por `"zero"`) | `ValueError` |
| `filters.time_weighting(mode=)` | otras mayúsculas (`"FAST"` por `"fast"`) | `ValueError` |
| `fluids.sea_water(sound_speed_model=)` | otras mayúsculas (`"UNESCO"` por `"unesco"`); espacios alrededor (`" unesco "` por `"unesco"`) | `ValueError` |
| `fluids.sea_water_sound_speed(model=)` | otras mayúsculas (`"MACKENZIE"` por `"mackenzie"`); espacios alrededor (`" mackenzie "` por `"mackenzie"`) | `ValueError` |
| `materials.check_ceiling_specimen(mounting=)` | otras mayúsculas (`"e"` por `"E"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `materials.mounting_type(letter=)` | otras mayúsculas (`"e"` por `"E"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `metrology.CalibratorTableRow.for_class(calibrator_class=)` | otras mayúsculas (`"1/m"` por `"1/M"`); espacios alrededor (`" 1 "` por `"1"`); un número (`1` por `"1"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `metrology.sensitivity(calibrator_class=)` | espacios alrededor (`" 1 "` por `"1"`); un número (`1` por `"1"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `metrology.verify_sound_calibrator(calibrator_class=)` | espacios alrededor (`" 1 "` por `"1"`); un número (`1` por `"1"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `metrology.verify_sound_calibrator(environmental_test=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.applicable_methods(condition=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.applicable_methods(source_kind=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.cabin_insulation(method=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.check_enclosure_test_environment(base_standard=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.enclosure_artificial_source_insulation(condition=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.enclosure_artificial_source_insulation(quantity=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.enclosure_sound_power_insulation(condition=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.enclosure_sound_power_insulation(source_kind=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.enclosure_sound_pressure_insulation(condition=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.enclosure_sound_pressure_insulation(source_kind=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.screen_attenuation(source_kind=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.uncertainty_conditions(method=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.weighted_cabin_insulation(method=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `noise_control.weighted_enclosure_insulation(quantity=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `signals.ln_levels(mode=)` | otras mayúsculas (`"FAST"` por `"fast"`) | `ValueError` |
| `signals.ln_levels(weighting=)` | otras mayúsculas (`"a"` por `"A"`) | `ValueError` |
| `signals.sel(weighting=)` | otras mayúsculas (`"a"` por `"A"`) | `ValueError` |
| `underwater.VolumeAbsorption(model=)` | otras mayúsculas (`"THORP"` por `"thorp"`); espacios alrededor (`" thorp "` por `"thorp"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.WeightedExposureResult(group=)` | otras mayúsculas (`"vhf"` por `"VHF"`); espacios alrededor (`" VHF "` por `"VHF"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.WeightedExposureResult(guidance=)` | otras mayúsculas (`"NMFS-2024"` por `"nmfs-2024"`); espacios alrededor (`" nmfs-2024 "` por `"nmfs-2024"`); otro separador (`"nmfs_2024"` por `"nmfs-2024"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.audiogram_parameters(group=)` | otras mayúsculas (`"hf"` por `"HF"`); espacios alrededor (`" HF "` por `"HF"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.auditory_weighting(group=)` | otras mayúsculas (`"hf"` por `"HF"`); espacios alrededor (`" HF "` por `"HF"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.auditory_weighting(guidance=)` | otras mayúsculas (`"NMFS-2018"` por `"nmfs-2018"`); espacios alrededor (`" nmfs-2018 "` por `"nmfs-2018"`); otro separador (`"nmfs_2018"` por `"nmfs-2018"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.detection_range(law=)` | otras mayúsculas (`"SPHERICAL"` por `"spherical"`); espacios alrededor (`" spherical "` por `"spherical"`) | `ValueError` |
| `underwater.detection_range(model=)` | otras mayúsculas (`"FRANCOIS-GARRISON"` por `"francois-garrison"`); espacios alrededor (`" francois-garrison "` por `"francois-garrison"`) | `ValueError` |
| `underwater.detection_range_from_curve(crossing=)` | otras mayúsculas (`"FIRST"` por `"first"`); espacios alrededor (`" first "` por `"first"`) | `ValueError` |
| `underwater.effective_depth(seabed=)` | otras mayúsculas (`"SAND"` por `"sand"`); espacios alrededor (`" sand "` por `"sand"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.eigenrays(bottom=)` | otras mayúsculas (`"PRESSURE-RELEASE"` por `"pressure-release"`); espacios alrededor (`" pressure-release "` por `"pressure-release"`) | `ValueError` |
| `underwater.exposure_criteria(group=)` | otras mayúsculas (`"lf"` por `"LF"`); espacios alrededor (`" LF "` por `"LF"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.exposure_criteria(guidance=)` | otras mayúsculas (`"SOUTHALL-2019"` por `"southall-2019"`); espacios alrededor (`" southall-2019 "` por `"southall-2019"`); otro separador (`"southall_2019"` por `"southall-2019"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.gaussian_beams(bottom=)` | otras mayúsculas (`"RIGID"` por `"rigid"`); espacios alrededor (`" rigid "` por `"rigid"`) | `ValueError` |
| `underwater.group_audiogram(group=)` | otras mayúsculas (`"hf"` por `"HF"`); espacios alrededor (`" HF "` por `"HF"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.hearing_groups(guidance=)` | otras mayúsculas (`"SOUTHALL-2019"` por `"southall-2019"`); espacios alrededor (`" southall-2019 "` por `"southall-2019"`); otro separador (`"southall_2019"` por `"southall-2019"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.normal_modes(bottom=)` | otras mayúsculas (`"PRESSURE-RELEASE"` por `"pressure-release"`); espacios alrededor (`" pressure-release "` por `"pressure-release"`) | `ValueError` |
| `underwater.propagation_loss(law=)` | otras mayúsculas (`"SPHERICAL"` por `"spherical"`); espacios alrededor (`" spherical "` por `"spherical"`) | `ValueError` |
| `underwater.propagation_loss(model=)` | otras mayúsculas (`"FRANCOIS-GARRISON"` por `"francois-garrison"`); espacios alrededor (`" francois-garrison "` por `"francois-garrison"`) | `ValueError` |
| `underwater.reflection_loss_gradient(seabed=)` | otras mayúsculas (`"SAND"` por `"sand"`); espacios alrededor (`" sand "` por `"sand"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.seawater_absorption(model=)` | otras mayúsculas (`"THORP"` por `"thorp"`); espacios alrededor (`" thorp "` por `"thorp"`) | `ValueError` |
| `underwater.ship_source_spectrum(model=)` | otras mayúsculas (`"JOMOPANS-ECHO"` por `"jomopans-echo"`); espacios alrededor (`" jomopans-echo "` por `"jomopans-echo"`) | `ValueError` |
| `underwater.ship_source_spectrum(vessel_class=)` | otras mayúsculas (`"BULKER"` por `"bulker"`); espacios alrededor (`" bulker "` por `"bulker"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.sound_speed_profile(model=)` | otras mayúsculas (`"MEDWIN"` por `"medwin"`); espacios alrededor (`" medwin "` por `"medwin"`) | `ValueError` |
| `underwater.spreading_loss(law=)` | otras mayúsculas (`"SPHERICAL"` por `"spherical"`); espacios alrededor (`" spherical "` por `"spherical"`) | `ValueError` |
| `underwater.waveguide_cutoff_frequency(seabed=)` | otras mayúsculas (`"SAND"` por `"sand"`); espacios alrededor (`" sand "` por `"sand"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.weighted_exposure(group=)` | otras mayúsculas (`"vhf"` por `"VHF"`); espacios alrededor (`" VHF "` por `"VHF"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.weighted_exposure(guidance=)` | otras mayúsculas (`"NMFS-2024"` por `"nmfs-2024"`); espacios alrededor (`" nmfs-2024 "` por `"nmfs-2024"`); otro separador (`"nmfs_2024"` por `"nmfs-2024"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.weighting_parameters(group=)` | otras mayúsculas (`"hf"` por `"HF"`); espacios alrededor (`" HF "` por `"HF"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.weighting_parameters(guidance=)` | otras mayúsculas (`"NMFS-2018"` por `"nmfs-2018"`); espacios alrededor (`" nmfs-2018 "` por `"nmfs-2018"`); otro separador (`"nmfs_2018"` por `"nmfs-2018"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.weston_propagation_loss(seabed=)` | otras mayúsculas (`"SAND"` por `"sand"`); espacios alrededor (`" sand "` por `"sand"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `underwater.weston_regime_boundaries(seabed=)` | otras mayúsculas (`"SAND"` por `"sand"`); espacios alrededor (`" sand "` por `"sand"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `vibration.PhaseVerification(weighting=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.RunningRMSDecayVerification(method=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.WeightingVerification(weighting=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.admissible_exposure_s(time_of_day=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.angular_average_transmission_coefficient(junction=)` | otras mayúsculas (`"x"` por `"X"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `vibration.angular_average_transmission_coefficient(section=)` | otras mayúsculas (`"CORNER"` por `"corner"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `vibration.assess_people_in_buildings(source=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.assess_railway_change(time_of_day=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.assessment_vibration_severity(time_of_day=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.band_limited_weighting_factor(name=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.check_loose_mounting(direction=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.check_loose_mounting(surface=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.construction_guide_values(area=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.construction_guide_values(stage=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.corner_transmission_coefficient(junction=)` | otras mayúsculas (`"x"` por `"X"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `vibration.foundation_to_floor_level_difference(floor=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.foundation_to_floor_level_difference(statistic=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.geometric_exponent(character=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.geometric_exponent(geometry=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.geometric_exponent(wave=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.ground_to_floor_level_difference(floor=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.ground_to_foundation_level_difference(level=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.ground_to_foundation_level_difference(statistic=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.guide_values(area=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.guide_values(edition=)` | un número (`1999` por `"1999"`); un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.guide_values(source=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.guide_values(time_of_day=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.indication_tolerance_percent(name=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.instrument_confidence_limit_percent(quantity=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.junction_transmission(junction=)` | otras mayúsculas (`"l"` por `"L"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `vibration.kb_fmax_from_peak_velocity(kind=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.phase_tolerance_deg(name=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.railway_assessment_severity(time_of_day=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.railway_guide_values(alignment=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.railway_guide_values(area=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.railway_guide_values(time_of_day=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.reference_indication(name=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.running_rms_decay_time(method=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.sawtooth_burst(application=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.signal_burst_indications(application=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.signal_burst_indications(name=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.straight_transmission_coefficient(junction=)` | otras mayúsculas (`"t1"` por `"T1"`); un valor que no es texto pero se escribe como una opción | `ValueError`, y `TypeError` para un valor que no es texto |
| `vibration.train_assessment_severity(time_of_day=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.train_decay_exponent(fitted_with=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.train_weighting_factor(alignment=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.train_weighting_factor(kind=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.verify_phase_response(name=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.verify_running_rms_decay(method=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.verify_signal_burst_response(application=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.verify_signal_burst_response(name=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.verify_weighting(name=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |
| `vibration.weighting_tolerance_percent(name=)` | un valor que no es texto pero se escribe como una opción | `TypeError` para un valor que no es texto |

## Un registro rechaza una opción al construirse

Un registro que construye quien llama comprueba en su `__post_init__`, tal
como se escribe, cada campo tipado con un `Literal`: un texto que no ofrece
lanza `ValueError` y un valor que no es texto lanza `TypeError`, al construir
el registro. Antes de 4.0 la mayoría guardaba cualquier valor y lo dejaba a
quien lo leyera, de modo que una errata fallaba más tarde, en otra llamada, o
no fallaba; los cuatro que sí comprobaban rechazaban con `ValueError` un valor
que no es texto. El arreglo es escribir la opción tal como la enumera su
`Literal` donde se construye el registro.

| Registro | Antes de 4.0 | 4.0 |
| --- | --- | --- |
| `aircraft.ANPNPDCurves(metric=, operation=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `aircraft.SpectralClass(operation=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `aircraft.RotorcraftAtmosphere(atmospheric_method=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `aircraft.RotorcraftGround(flow_resistivity=)` | guardaba cualquier valor, rechazado más tarde o nunca | `ValueError` para una letra que no ofrece y para un número que no es positivo y finito, `TypeError` para un valor que no es ni una letra ni números (un `bytes`, `None`, un valor complejo, un texto entre números), al construirse |
| `building.BandPath(kind=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `building.FlankingPath(kind=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `electroacoustics.MicrophoneNoise(weighting=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `emission.MicrophoneTraverse(targets=)` | `ValueError` para cualquier objetivo que no conocía, texto o no | `ValueError` para un texto que no ofrece, `TypeError` para un objetivo que no es texto |
| `environment.BinnedSoundLevels(averaging=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `environment.RoadEmissionCoefficients` (las claves de categoría de sus tablas por categoría) | guardaba cualquier clave, rechazada más tarde o nunca | `ValueError` para un texto que no es un código de la Tabla [2.2.a], `TypeError` para una clave que no es texto, cada clave al construirse |
| `environment.RoadSurfaceCoefficients(alpha=, beta=)` (sus claves de categoría) | guardaba cualquier clave, rechazada más tarde o nunca | `ValueError` para un texto que no es un código de la Tabla [2.2.a], `TypeError` para una clave que no es texto, cada clave al construirse |
| `filters.FilterDesign(filter_type=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `filters.EQSection(filter_type=)` | `ValueError` para cualquier valor que no conocía, texto o no | `ValueError` para un texto que no ofrece, `TypeError` para un valor que no es texto |
| `hearing.Task(instrument=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `materials.FiberResistivityFit(direction=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `metrology.SoundLevelMeterPeriodicMeasurements` (las claves de sus diccionarios por ponderación, por rango y por respuesta) | `ValueError` para cualquier clave que no conocía | `ValueError` para un texto que no conoce, `TypeError` para una clave que no es texto, cada clave al construirse |
| `noise_control.DesignCriterion(family=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `noise_control.SourceRoom(model=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `noise_control.LiquidTrim(coefficient=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `noise_control.ValveTrim(coefficient=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `phonometry.ReportMetadata(tube_shape=)` | `ValueError` para cualquier valor que no conocía, texto o no | `ValueError` para un texto que no ofrece, `TypeError` para un valor que no es texto |
| `simulation.ElasticBoundaries(sides=)` | guardaba cualquier valor; la ejecución que contenía el registro rechazaba un lado o un nombre desconocido con `ValueError`, fuera texto o no | `ValueError` para un lado o un nombre que no ofrece, `TypeError` para uno que no es texto, al construirse |
| `simulation.FDTDBoundaries(sides=)` | guardaba cualquier valor; la ejecución que contenía el registro rechazaba un lado o un nombre desconocido con `ValueError`, fuera texto o no, ejecutaba un booleano como una impedancia de 1 Pa s/m y rechazaba `None` como una impedancia que no es finita | `ValueError` para un lado o un nombre que no ofrece, `TypeError` para un lado que no es texto y para una terminación que no es un nombre ni un número real ni un array de ellos (un booleano, `None`, un booleano entre los números de un perfil), al construirse; una impedancia se guarda como un float, y un perfil como un array float64 de solo lectura |
| `simulation.ElasticRecording(probe_fields=, snapshot_field=)` | `ValueError` para cualquier campo que no conociera, fuera texto o no; `probe_fields="vy"` se leía letra a letra y rechazaba `"v"` | `ValueError` para un texto que no ofrece, `TypeError` para un campo que no es texto; un solo nombre registra ese campo |
| `simulation.ForceSource(direction=)` | `ValueError` para cualquier dirección que no conociera, fuera texto o no | `ValueError` para un texto distinto de `"x"` y `"y"`, `TypeError` para un valor que no es texto |
| `simulation.PlaneWaveSource(direction=)` | guardaba cualquier valor; `FDTD2D.add_source` y la ejecución que lo contenía rechazaban uno que no conocían | rechazado al construirse |
| `vibration.GuideValues(time_of_day=, edition=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |
| `vibration.FaultLine(family=)` | guardaba cualquier valor, rechazado más tarde o nunca | rechazado al construirse |

Las funciones comprueban también la opción en todos los caminos. Una que se
leía solo en algunos caminos aceptaba cualquier valor en los demás, y una que
se comprobaba con una comparación rechazaba con `ValueError` un valor que no es
texto, o con un error ajeno:

| Llamada | Antes de 4.0 | 4.0 |
| --- | --- | --- |
| `environment.ground_effect(model=)` | aceptaba cualquier valor sin `flow_resistivity_pa_s_m2` | `ValueError` para un texto que no ofrece, `TypeError` para un valor que no es texto, se dé lo que se dé |
| `environment.barrier_insertion_loss(ground_model=)` | aceptaba cualquier valor sin `ground_flow_resistivity_pa_s_m2` | lo mismo |
| `environment.atmospheric_parabolic_equation(model=)` | aceptaba cualquier valor sin `flow_resistivity_pa_s_m2` | lo mismo |
| `metrology.coupler_transfer_impedance(heat_conduction_method=)` | aceptaba cualquier valor con un `PlaneWaveCoupler` | lo mismo |
| `noise_control.elbow_insertion_loss(lined_side=)` | aceptaba cualquier valor con `model="ashrae"` | lo mismo |
| `noise_control.fan_sound_power(assembly=)` | aceptaba cualquier valor con `model="ashrae"` | lo mismo |
| `noise_control.fan_sound_power(fan_type=)` | aceptaba cualquier valor con `model="vdi2081"` | lo mismo |
| `signals.time_delay(weighting=)` | aceptaba cualquier valor salvo con `method="gcc"` | lo mismo |
| `underwater.ship_source_spectrum(vessel_class=)` | aceptaba cualquier valor salvo con `model="jomopans-echo"` | lo mismo |
| `emission.reference_source_calibration(arrangement=)`, `emission.reference_source_reproducibility(arrangement=)` | aceptaba cualquier valor en una cámara reverberante | lo mismo; allí se sigue aceptando `None` |
| `building.single_number_uncertainty(situation=)` con `upper_limit=True` | `ValueError` para todo lo que no fuera `"A"`, texto o no | `ValueError` para un texto distinto de `"A"`, `TypeError` para un valor que no es texto |
| `io.write(subtype=)` con muestras enteras | `ValueError` para todo lo que no fuera el subtipo propio de las muestras, texto o no | `TypeError` para un valor que no es texto |
| `io.write_catalogue(delimiter=, decimal=)` junto a un documento JSON | `ValueError` para todo lo que no fuera el dialecto por defecto, texto o no | `TypeError` para un valor que no es texto |
| `underwater.gaussian_beams(absorption=)` | `AttributeError` para un valor que no es texto ni un `VolumeAbsorption` | `TypeError` |
| `filters.FilterPeriodicVerification.clause()` | `KeyError` para cualquier nombre que no se hubiera medido | `ValueError` para un texto que no nombra ninguna de las cinco cláusulas, `TypeError` para un valor que no es texto; `KeyError` para una cláusula que no se midió |
| `simulation.FDTD2D(absorbing_sides=, edge_impedance=)`, `simulation.ElasticFDTD2D(absorbing_sides=, free_sides=)` | `ValueError` para cualquier lado que no conociera, fuera texto o no, con un mensaje que listaba los lados desconocidos | `ValueError` para un texto que no es un lado, `TypeError` para un lado que no es texto, con el mensaje que lanza toda opción (`'free_sides' must be one of ('left', 'right', 'top', 'bottom'); got 'north'.`) |
| `simulation.FDTD2D.add_plane_wave(direction=)`, `simulation.ElasticFDTD2D.collocated(field)`, `simulation.FDTDResult.plot(kind=)`, `simulation.ElasticFDTDResult.plot(kind=)` | `ValueError` para cualquier valor que no conociera, fuera texto o no | `ValueError` para un texto que no ofrece, `TypeError` para un valor que no es texto |
| `simulation.FDTD2D(edge_impedance=)` con una impedancia que no es un número real | un booleano, solo o entre los números de un perfil, se ejecutaba como una impedancia de 1 Pa s/m, `None` lanzaba `ValueError` como una impedancia que no es finita, un texto `ValueError` desde la conversión a float | `TypeError` |

Cada clave de un diccionario y cada elemento de una secuencia se comprueba uno
a uno: `environment.assess_activity` ignoraba un periodo que no conocía junto
a otro que sí, y ahora lanza `ValueError` por él; una clave de
`environment.pleasantness_eventfulness` que no es texto lanzaba `ValueError` y
ahora lanza `TypeError`; las comprobaciones del campo sonoro de ISO 8253-2,
ISO 4869-1 e ISO 4869-3 tropezaban con esa clave con un `TypeError` ajeno, al
ordenar, y ahora nombran el parámetro; las claves de los límites de
decaimiento de la vía de referencia y de la `geometry` del dibujo de un
silenciador lanzan `TypeError` cuando no son texto; una clave de la `section`
de un conducto que
`noise_control.duct_path` no admite lanzaba el `TypeError` de un argumento por
nombre desconocido y ahora lanza `ValueError`; y los balances de
incertidumbre de la comparación, de la reciprocidad y de las correcciones de
campo libre conservan su mensaje para un componente desconocido y lanzan
`TypeError` para una clave que no es texto. Doce `.plot()` de los resultados
de protectores auditivos, de reducción activa de ruido, de atenuación en oído
real y de baja frecuencia de ISO 15186-3, y
`building.SoundReductionResult.report`, aceptaban cualquier `language` y ahora
rechazan el que no ofrecen, como el resto de los gráficos. Quien indexa con
tipos una tabla publicada con un `str` libre (una variable `str` en
`room.TABLE_A1` o en `hearing.EARPHONES`) necesita ahora el `Literal` por el
que está indexada; los valores no cambian.

El grosor de la esponja de `simulation.FDTDBoundaries` y
`simulation.ElasticBoundaries` se guarda como el número entero de celdas que
nombra y se comprueba al construir el registro: un valor que no es un número
lanza `TypeError` y una fracción `ValueError`, cuando antes se guardaba tal
cual y solo lo leía una ejecución con un lado absorbente
(`FDTDBoundaries(sides="rigid", absorbing_layer_cells=2.5)` se construía y se
ejecutaba). La `shape` que se da a `simulation.FDTD2D`,
`simulation.ElasticFDTD2D`, `simulation.FDTDRun` o `simulation.ElasticRun` se
lee siempre que se da: una ejecución la guarda como un par de enteros, desde
cualquier secuencia de los dos recuentos (también una lista o un `range`) o un
array de enteros de una dimensión, cuando antes solo admitía una tupla o una
lista, una mal formada se rechaza aunque acompañe a un mapa, y una
que nombra una malla distinta de la del mapa lanza `ValueError` (`shape (4, 8)
does not match the c map, whose shape is (8, 8)`), cuando antes un motor
ignoraba la `shape` que acompañaba a un mapa y una ejecución la guardaba tal
cual. `simulation.ElasticFDTD2D.from_regions` lee su `shape` del mismo modo:
un tercer recuento lanza `ValueError` y un texto `TypeError`, cuando antes el
tercer recuento se descartaba. Un entero de `numpy` se admite dondequiera que
estos registros y los motores admiten un recuento, y listas anidadas
dondequiera que admiten un mapa. Una `simulation.ContourProbe` construida a
mano, `ContourProbe(engine, ix0, ix1, iy0, iy1, frequencies)`, se une a su
motor y muestrea desde el paso siguiente, como la que devuelve
`FDTD2D.add_contour_probe`; antes nunca muestreaba, y su `phasors` se negaba
por falta de muestras. Cualquier cosa que no sea un `FDTD2D` como su `engine`
lanza `TypeError` nombrando `engine`, donde un `ElasticFDTD2D`, `None` o
cualquier otro objeto fallaban con un `AttributeError` que nombraba un atributo
privado o el campo de presión.

## Un registro que construye quien llama guarda lo que dicen sus campos

Antes de 4.0 un registro guardaba una lista, una tupla o un array de otro tipo
tal como se le daba, aunque su campo dijera que guardaba un array o una tupla:
`environment.WavelengthSpectrum(levels=[...])` guardaba la lista, de modo que
`spectrum.levels * 2` repetía la lista en lugar de doblar los niveles, y el
registro congelado guardaba una lista a la que cualquiera podía seguir
añadiendo elementos. En 4.0 un registro que construye quien llama convierte lo
que recibe y guarda lo que dice su campo: un campo de array guarda un array de
solo lectura de su tipo, un campo de tupla una tupla y un par un par de
números, y un único número donde un valor por banda puede serlo sigue siendo
el número que era. El código que añadía elementos a una lista entregada a un
registro, o que volvía a leer un campo esperando la lista que dio, lee ahora el
array: `record.levels.tolist()` devuelve la lista. Un comprobador de tipos lee
el constructor que cada uno de estos registros declara para él, de modo que una
lista pasa la comprobación donde el registro la convierte.

| Registro | Antes de 4.0 | 4.0 |
| --- | --- | --- |
| `aircraft.ANPNPDCurves(powers=, distances_m=, levels=)` | guardaba una lista tal cual | arrays `float64` de solo lectura |
| `aircraft.FlightSegmentState(ground_roll=, landing_roll=, bank=)` | guardaba una lista tal cual | arrays de solo lectura, las máscaras `bool` y el alabeo `float64` |
| `aircraft.FlightConditionInterpolation(triangles=)` | guardaba una lista de filas tal cual | un array de enteros de solo lectura |
| `aircraft.PerformanceAircraft(jet_coefficients=, propeller_coefficients=, aerodynamic_coefficients=)` | guardaba los diccionarios tal cual, también los de la propia base de datos, de modo que una tabla se podía editar después de comprobar el avión | copias de solo lectura (`dict(aircraft.jet_coefficients)` devuelve una que editar) |
| `aircraft.RotorcraftGround(ground_elevation=, flow_resistivity=, terrain=)` | guardaba una lista tal cual; un modelo de elevación de más o menos de tres ejes se rechazaba cuando un evento lo leía | un valor por receptor como array `float64` de solo lectura y el modelo de elevación como sus tres ejes, cada uno un array `float64` de solo lectura; un modelo de elevación de más o menos de tres ejes se rechaza con `ValueError` al construirse; un número o una letra de clase tal cual; un texto entre los números de cualquiera de ellos se rechaza con `TypeError`, y una elevación del terreno que no es finita con `ValueError`, al construirse |
| `aircraft.RotorcraftHemisphere(frequencies=, azimuth_deg=, polar_deg=, levels=)` | guardaba una lista tal cual | arrays `float64` de solo lectura |
| `aircraft.RotorcraftTrackState(airspeed=, path_angle_deg=, heading=, bank_angle_deg=)` | guardaba una lista tal cual | una secuencia como array `float64` de solo lectura; un número tal cual |
| `building.BandPath(values=)` | guardaba una lista tal cual | un array `float64` de solo lectura |
| `building.FacadeElement(r=, dn_e=, insertion_loss=)` | guardaba una lista tal cual | un valor por banda como array `float64` de solo lectura; un número tal cual |
| `building.LowFrequencyProcedure(corner_levels=)` | guardaba la lista tal cual | un array `float64` de solo lectura |
| `electroacoustics.LoudspeakerDirectivity(polar=)`, `electroacoustics.MicrophoneDirectivity(polar=)`, `electroacoustics.MicrophoneNoise(spectrum=)`, `electroacoustics.MicrophoneOverload(distortion=)` | guardaba el par tal cual, también una lista; lo que no fuera un par fallaba al leerse | una tupla de dos arrays `float64` de solo lectura; `TypeError` para un número o un texto, o para un texto o un valor complejo entre los números de un miembro, y `ValueError` para más o menos de dos miembros, al construirse |
| `electroacoustics.LoudspeakerRatings(frequency_range=)` | guardaba el par tal cual y lo comprobaba al leerse | un par `(low, high)` de floats, comprobado al construirse como los demás pares de frecuencias (`TypeError`, `ValueError`) |
| `emission.RoomEnvironment(absorption_area=, reverberation_time=, mean_absorption_coefficient=)` | guardaba una lista tal cual | un valor por banda como array `float64` de solo lectura; un número tal cual |
| `environment.AtmosphericAttenuation(frequencies, attenuation_db_per_m, ...)` | guardaba una lista tal cual | arrays `float64` de solo lectura |
| `environment.WavelengthSpectrum(wavelengths_mm=, levels=)`, `environment.RailSourceSpectra(source_a=, source_b=)` | guardaba una lista tal cual | arrays `float64` de solo lectura |
| `environment.RollingStock(wheel_transfer=, superstructure_transfer=)`, `environment.RailwayTrack(track_transfer=, bridge_transfer=)` | guardaba una lista o una tupla tal cual | arrays `float64` de solo lectura |
| `environment.RoadEmissionCoefficients(studded_a=, studded_b=)` | guardaba una lista o un array tal cual | una tupla de floats; `TypeError` para un número, un texto o un miembro que no es un número |
| `environment.RoadSurfaceCoefficients(speed_range_kmh=, alpha=, beta=)` | guardaba el par y los dos diccionarios tal cual, de modo que las tablas se podían editar después de construir la fila | un par de floats (`TypeError` para un número, un texto o un miembro que no es un número, `ValueError` para más o menos de dos) y dos mapeos de solo lectura |
| `hearing.Task(samples=, duration_observations_hours=, duration_range_hours=)` | guardaba una lista o un array tal cual | tuplas de floats, el intervalo un par; `TypeError` para un número o un texto dado como observaciones o como intervalo, `ValueError` para un intervalo de más o menos de dos valores |
| `io.Signal(channel_labels=)` | guardaba una lista tal cual; un texto de tantas letras como canales nombraba un canal por letra | una tupla; `TypeError` para un único texto |
| `materials.FiberResistivityFit(bulk_density_range_kg_m3=)` | guardaba una lista tal cual | un par de floats; `TypeError` para un número o un texto, `ValueError` para más o menos de dos valores |
| `materials.MetadiffuserWell(resonators=)` | guardaba una lista tal cual | una tupla |
| `materials.TransferMatrix(t11, t12, t21, t22, frequencies=)` | guardaba cada elemento tal cual: un `complex`, una lista o un array real | arrays `complex128` de solo lectura: un elemento escalar es un array de dimensión cero, ya no es un `complex` ni es hashable (`complex(m.t11)` o `m.t11.item()` devuelve el número), y un elemento real tiene parte imaginaria nula; `frequencies` un array `float64` de solo lectura |
| `room.ImpulseResponseResult(ir=)` | guardaba una lista tal cual | un array `float64` de solo lectura |
| `vibration.MultipleShockResult(peaks=, risk_thresholds=)` | guardaba una lista tal cual | los picos como array `float64` de solo lectura y los umbrales como tupla de tres floats; `TypeError` para un número o un texto y `ValueError` para más o menos de tres umbrales |
| `vibration.TransferStiffnessResult(frequencies=, transfer_stiffness=, transmissibility=)` | guardaba una lista tal cual | arrays de solo lectura, las frecuencias `float64`, la rigidez y la transmisibilidad `complex128` (un valor real con parte imaginaria nula) |

Cuatro resultados que guardaban un `dict` editable guardan en su lugar un mapeo
de solo lectura, como las tablas publicadas, y asignar en uno de ellos lanza
`TypeError`: `building.FacadePredictionResult.element_r`,
`environment.RailwayEmissionResult.components`,
`noise_control.ReactiveSilencerResult.geometry` y
`psychoacoustics.MooreGlasbergTimeVaryingLoudness.percentiles`. El código que
editaba uno lo copia antes, con `dict(result.element_r)`. Las frecuencias
centrales y las formas de onda por banda del `filters.OctaveFilterResult` que
devuelven `filters.octave_filter` y `OctaveFilterBank.filter` son tuplas donde
eran listas, listas a las que quien llama aún podía añadir elementos:
`result.frequencies.index(1000.0)` y la indexación se leen como antes, y
`list(result.frequencies)` devuelve una lista que editar. Un intervalo o una
serie de números dados como un texto (`"12"`) se rechazan con un `TypeError`
que nombra el campo, se lea como se lea el texto. Un registro que vuelve de
`pickle` o de `copy.deepcopy` guarda sus arrays de solo lectura, como los
guardaba al salir, donde antes volvían modificables: `np.array(record.levels)`
devuelve una copia en la que escribir.

```python
from phonometry import environment, materials

spectrum = environment.WavelengthSpectrum(wavelengths_mm=[2000.0, 1600.0], levels=[5.0, 4.0])
matrix = materials.TransferMatrix(1.0, 0.0, 0.0, 1.0)
print(type(spectrum.levels).__name__, spectrum.levels.flags.writeable, spectrum.levels.tolist())
print(matrix.t11.shape, matrix.t11.dtype, complex(matrix.t11))
# ndarray False [5.0, 4.0]
# () complex128 (1+0j)
```

## Un lector rechaza un nombre que no guarda un fichero regular

Un nombre que se le pasa a un lector puede guardar algo que no es un fichero.
Una tubería con nombre en la que nadie escribe dejaba `io.read` esperando en
su primera apertura a un escritor que no llegaba nunca, y lo mismo las tablas
de una exportación ANP; un enlace a `/dev/zero` mantenía una lectura sin fin,
y un directorio lanzaba lo que lanzara su primera apertura. En la 4.0 cada
lector mira el nombre antes de abrirlo y lanza un `ValueError` que nombra el
fichero y lo que guarda. Una llamada que capturaba `OSError` para un
directorio captura ahora `ValueError`; un nombre sin nada detrás sigue
lanzando `FileNotFoundError`, y un enlace a un fichero regular se sigue
leyendo.

| Se pasa | 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- | --- |
| una tubería con nombre a `io.read`, `io.info`, `io.read_blocks` o como origen de `io.convert` | la llamada esperaba en la apertura a un escritor | `ValueError`: `"<ruta>: is a named pipe (FIFO), and audio is read only from a regular file"` |
| un directorio a esas cuatro | `IsADirectoryError` (`PermissionError` en Windows) | `ValueError`, `"... is a directory, ..."` |
| un dispositivo a esas cuatro (`/dev/zero`, o un enlace a él) | `ValueError`: no es un fichero de audio reconocido | `ValueError`, `"... is a character device, ..."` |
| un directorio a `aircraft.load_anp_database` que guarda una tubería, un dispositivo o un directorio con el nombre de una de sus tablas | la llamada esperaba, leía sin fin o lanzaba `IsADirectoryError` | `ValueError`, `"ANP table <ruta>: is ..., and an ANP table is read only from a regular file"`; un fichero cuyo nombre no casa con ninguna clave de tabla ya no se abre |
| una tabla ANP de más de 32 MiB | se leía entera | `ValueError`, antes de leer un byte |
| una celda ANP con `nan`, `inf`, `-Infinity` o `1e999`, una cabecera como `L_infft`, o una celda que no guarda ningún número | una celda no finita se tomaba tal cual y salía como NaN en cada nivel de evento; una celda sin número lanzaba el `ValueError` de Python, que no nombraba ni la tabla ni la línea | `ValueError` que nombra la tabla, la línea y la columna |
| una tabla ANP que no es UTF-8 | `UnicodeDecodeError`, sin nombrar el fichero | `ValueError` que nombra la tabla y el byte |
| un recuento ANP (una longitud de etapa, un número de punto o de paso, un número de motores) de `1.5`, o un número de motores en blanco | se tomaba como `1`, y el número de motores en blanco como `0`; una longitud de etapa de los pesos o de los pasos de despegue, escrita así o `nan`, lanzaba el `ValueError` de un argumento `stage_length`, que no nombraba ninguna tabla | `ValueError` que nombra la tabla, la línea y la columna |

```python
import tempfile
from pathlib import Path

from phonometry import io

with tempfile.TemporaryDirectory() as folder:
    try:
        io.read(Path(folder))
    except ValueError as refusal:
        print(str(refusal).split(": ", 1)[1])
# is a directory, and audio is read only from a regular file
```

## Una ruta de otra biblioteca llega al fichero que nombra

`io.write`, `io.read`, `io.info`, `io.read_blocks` e `io.convert` pasaban una
ruta a SciPy y a python-soundfile como `str(path)`. Para un `str` o un
`pathlib.Path` eso es la ruta; para cualquier otro `os.PathLike`, un
`os.DirEntry` o una clase de ruta de otra biblioteca, es el repr del objeto.
En la 4.0 cada una toma la ruta que nombra el objeto, los mensajes la
escriben, y las anotaciones dicen `str | os.PathLike[str]`, como ya decían las
de los escritores de vídeo. Un `str` o un `pathlib.Path` se comportan como
antes.

| Se pasa | 4.0.0rc1 | 4.0 |
| --- | --- | --- |
| un `os.PathLike` que no es ni un `str` ni un `pathlib.Path`, a `io.write` (un WAV de 16 o 32 bits, un WAV en coma flotante, un FLAC, o `bext="loudness"`) | el fichero iba a un nombre hecho con el repr del objeto, `<... object at 0x...>`, en el directorio de trabajo | el fichero que nombra el objeto |
| lo mismo a `io.read`, o como origen de `io.convert`, y un FLAC a `io.info` o `io.read_blocks` | `FileNotFoundError` con el repr, o el `LibsndfileError` de python-soundfile para un FLAC | se lee el fichero que nombra el objeto |
| lo mismo a `io.info` | `AudioFileInfo.path` guardaba el repr | `AudioFileInfo.path` es la ruta |

## Un escritor pone su fichero en el nombre sólo cuando está entero

`io.write`, el destino de `io.convert`, cada `.report()` y la gráfica de
respuesta de un banco de filtros escribían directamente en el nombre que
recibían. Un error o una interrupción a medias dejaban ahí un fichero empezado,
encima de la grabación o de la ficha de una ejecución anterior, y una ficha
demasiado larga para su página se construía en el nombre y se borraba después,
y con ella la ficha anterior. En la 4.0, si en el nombre no hay nada o hay un
fichero regular, cada uno escribe un fichero oculto a su lado y lo renombra
sobre el nombre cuando está entero, con los bits de permiso del fichero
antiguo, y solo su propietario puede leerlo mientras se escribe sobre un
fichero. El fichero nuevo es del escritor: toma su propietario y su grupo, y no
conserva ni las listas de control de acceso ni los atributos extendidos del
fichero antiguo. Su nombre oculto se recorta a lo que admite el directorio, así
que un nombre tan largo como el directorio permite se escribe como cualquier
otro. Un enlace, una tubería, un dispositivo o un directorio en el nombre se
abren ahí como antes, así que una grabación que se envía a una tubería a
propósito sigue entrando en la tubería.

| Se pasa | 3.3.0 o 4.0.0rc1 | 4.0 |
| --- | --- | --- |
| una escritura, una conversión, una ficha o una gráfica de respuesta detenidas a medias por un error o una interrupción | un fichero empezado en el nombre, en lugar de lo que había | el nombre como estaba, y nada a su lado |
| una ficha demasiado larga para su página, en el nombre de una ficha anterior | `ValueError`, y la ficha anterior borrada | `ValueError`, y la ficha anterior intacta |
| un nombre cuyo fichero tiene un enlace duro en otro sitio | los bytes nuevos en el fichero, y por tanto bajo los dos nombres | el fichero nuevo en el nombre; el otro nombre conserva los bytes antiguos |
| un fichero con permiso de escritura en un directorio que no admite ficheros nuevos | se escribía en su sitio | el `PermissionError` del fichero de al lado, y el fichero antiguo intacto |

## Los patrones lobulados de un ventilador entubado son velocidades de giro, no líneas

`vibration.blade_pass_frequencies(..., n_vanes=...)` devolvía los patrones de
interacción rotativos de un ventilador entubado entre sus líneas, como entradas
`FaultLine` de la familia `"blade"` llamadas `lobe n=1 m=2`, con la velocidad de
la Ec. (8.17) como frecuencia de la línea en hercios. Norton sitúa el ruido de
esos patrones en el armónico de paso de pala del que salen, así que un espectro
no tiene línea en esas velocidades, y `.plot()` y `combine_fault_lines` la
marcaban igualmente. El número de lóbulos perdía además su signo, que es el
sentido en que gira el patrón.

En la 4.0 la función devuelve un `BladePassResult`, un `FaultFrequencyResult`
cuyas líneas son solo los tonos del eje y de paso de pala, y guarda aparte los
patrones en `lobe_patterns`, un `LobePattern` por armónico de pala y orden de
álabe con su signo: `harmonic`, `vane_order`, `n_lobes` (negativo para un patrón
que gira contra el rotor) y `speed_rpm`, la velocidad de la Ec. (8.17) en
r/min, como la imprime Norton. `within` conserva los patrones;
`combine_fault_lines` junta solo las líneas.

| 4.0.0rc1 | 4.0 |
| --- | --- |
| `res["lobe n=N m=M"]`, la velocidad sin signo en hercios del patrón del armónico de pala `N` con `M` lóbulos en cualquier sentido | `abs(next(p for p in res.lobe_patterns if p.harmonic == N and abs(p.n_lobes) == M).speed_rpm) / 60` |
| `res.names` con entradas `lobe n=… m=…` | `res.names` solo con las líneas del eje y de paso de pala; los patrones en `res.lobe_patterns` |
| un patrón con $m_\mathrm{L} < 0$ nombrado por $\lvert m_\mathrm{L} \rvert$, con velocidad positiva | `n_lobes` y `speed_rpm` negativos, y un patrón de $+m_\mathrm{L}$ a su lado conservado como otro |
| las velocidades marcadas como líneas por `.plot()` y llevadas por `combine_fault_lines` | líneas solo en el eje y en el paso de pala |

```python
from phonometry import vibration

res = vibration.blade_pass_frequencies(3500.0, 6, n_harmonics=1, n_vanes=4)
print(res.names)
print([(p.n_lobes, p.speed_rpm) for p in res.lobe_patterns])
# ('shaft', 'BPF')
# [(2, 10500.0), (10, 2100.0)]
```

## Los setenta y ocho nombres que ya no están

Todo lo demás se movió. Estos setenta y ocho no existen en ningún módulo público:

| Ya no está | Qué escribir en su lugar |
| --- | --- |
| `octavefilter`, `getansifrequencies`, `normalizedfreq` | `filters.octave_filter`, `filters.nominal_frequencies`, `filters.normalized_frequencies`. Eran las grafías originales de PyOctaveBand, renombradas en la 3.1 y conservadas como alias hasta la 4.0 |
| `calculate_sensitivity` | `metrology.sensitivity`, el mismo renombrado de la 3.1 |
| `filter_class_compliance` | `filters.verify_filter_class` |
| `air_density_iso`, `speed_of_sound_iso` | `materials.air_density_iso10534`, `materials.speed_of_sound_iso10534`, y lee el aviso de los kelvin de más arriba |
| `speed_of_sound` | `materials.speed_of_sound_iso17497(temperature_c=...)`, la misma fórmula de la ISO 17497-1 y el mismo número. No `fluids.air(...).speed_of_sound`, que calcula aire húmedo con otro modelo: 343,99 m/s frente a 343,20 m/s a 20 °C, como dice la sección del arreglo evidente |
| `depth_to_pressure` | `fluids.depth_to_gauge_pressure_mpa(depth_m=...)`, que devuelve el mismo número, o `fluids.depth_to_absolute_pressure_pa` para la absoluta. Las dos son keyword-only y las dos toman un `latitude_deg` opcional |
| `TransmissionLossResult` | `PropagationLossResult`, con `.tl` renombrado a `.pl` |
| `partial_exposure` | `vibration.daily_exposure`, llamada con el valor y la duración de una sola operación. `partial_exposure` era un segundo nombre de la misma función, y el número no se mueve |
| `insitu_reflection_factor`, `insitu_absorption_from_reflection`, `insitu_absorption_coefficient`, `insitu_absorption_spectrum`, `InsituAbsorptionResult` | `materials.in_situ_reflection_factor`, `materials.in_situ_absorption_from_reflection`, `materials.in_situ_absorption_coefficient`, `materials.in_situ_absorption_spectrum`, `materials.InSituAbsorptionResult`: in situ se escribe `in_situ` en todas partes, como ya lo escribían los nombres in situ de building, emission y noise_control |
| `DEFAULT_SPEED_OF_SOUND` | `materials.ISO13472_SPEED_OF_SOUND_M_S`, los 340 m/s del Anexo A de la ISO 13472-1. Los 343 m/s que toman por omisión los módulos de salas son privados ahora; pasa `speed_of_sound=` para decir cuál quieres |
| `OCTAVE_BANDS`, `THIRD_OCTAVE_BANDS` | `materials.RATING_OCTAVE_BANDS_HZ`, `materials.RATING_THIRD_OCTAVE_BANDS_HZ`, las bandas de la clasificación de la ISO 11654 |
| `BASE_PLATE_BANDS` | `materials.BASE_PLATE_BANDS_HZ` |
| `DEFAULT_POLAR_ANGLES` | `materials.DEFAULT_POLAR_ANGLES_DEG` |
| `DEFAULT_MIC_HEIGHT`, `DEFAULT_SOURCE_HEIGHT` | `materials.DEFAULT_MICROPHONE_HEIGHT_M`, `materials.DEFAULT_SOURCE_HEIGHT_M` |
| `PART1_FREQUENCY_RANGE`, `SPOT_FREQUENCY_RANGE`, `SPOT_NARROW_BAND_RANGE` | `materials.PART1_FREQUENCY_RANGE_HZ`, `materials.SPOT_FREQUENCY_RANGE_HZ`, `materials.SPOT_NARROW_BAND_RANGE_HZ` |
| `REFERENCE_ACCELERATION` | `vibration.ACCELERATION_LEVEL_REFERENCE_M_S2`, el 1 µm/s² de la ISO 1683. `vibration.REFERENCE_ACCELERATION_M_S2` es otra cosa, las condiciones de referencia de la Tabla 1 de la ISO 8041-1 |
| `REFERENCE_AREA` | `building.REFERENCE_AREA_M2` |
| `REFERENCE_VELOCITY` | `emission.REFERENCE_VELOCITY_M_S` |
| `DEFAULT_FREQUENCIES` | `environment.DEFAULT_FREQUENCIES_HZ` |
| `NOY_BANDS` | `aircraft.NOY_BANDS_HZ` |
| `UNDERWATER_REFERENCE_PRESSURE` | `underwater.UNDERWATER_REFERENCE_PRESSURE_PA` |
| `UNDERWATER_REFERENCE_EXPOSURE` | `underwater.UNDERWATER_REFERENCE_EXPOSURE_PA2_S`, el 1 µPa² s de la ISO 1683 en Pa² s |
| `NORMALIZED_IMPEDANCE` | `emission.NORMALIZED_IMPEDANCE_PA_S_M`, los 411 Pa s/m de la ISO/TS 7849 |
| `NO_TONE_AUDIBILITY` | `psychoacoustics.NO_TONE_AUDIBILITY_DB` |
| `REFERENCE_STIFFNESS` | `vibration.REFERENCE_STIFFNESS_N_M` |
| `HAV_EAV_A8`, `HAV_ELV_A8`, `WBV_EAV_A8`, `WBV_ELV_A8` | `vibration.HAV_EAV_A8_M_S2`, `vibration.HAV_ELV_A8_M_S2`, `vibration.WBV_EAV_A8_M_S2`, `vibration.WBV_ELV_A8_M_S2`, los valores de A(8) de la Directiva 2002/44/CE. `WBV_EAV_VDV` y `WBV_ELV_VDV` conservan su nombre, porque un valor de dosis de vibración tiene una sola unidad, m/s^1,75 |
| `combine_uncertainties` | `metrology.combined_standard_uncertainty`, la única raíz de la suma de cuadrados, que toma las contribuciones como una sola secuencia: `combine_uncertainties(3.0, 4.0)` es `combined_standard_uncertainty([3.0, 4.0])` |
| `combine_uncertainty` | `metrology.uncertainty_propagation`, la propagación GUM a través de un modelo, con los mismos `model`, `quantities` y `correlation` |
| `expanded_uncertainty` | `building.insulation_expanded_uncertainty(u, coverage, one_sided=...)`, la función de la ISO 12999-1 a la que remitía el nombre de primer nivel de la 3.3.0, con el mismo número: `expanded_uncertainty(1.2)` e `insulation_expanded_uncertainty(1.2)` dan los dos 2,352 dB. La incertidumbre expandida GUM de un resultado propagado es `result.expanded(coverage)`. `environmental.expanded_uncertainty`, la función de la ISO 1996-2 con el mismo nombre, es `environment.environmental_expanded_uncertainty(u, coverage=...)`, 2,4 dB para el mismo 1,2 dB |
| `combine_linings`, `combine_subareas`, `combine_partial_exposures`, `combine_age_and_noise` | `building.combined_lining_improvement`, `building.subarea_intensity_level`, `vibration.combined_daily_exposure`, `hearing.age_and_noise_threshold`: un cálculo se nombra por lo que devuelve |
| `air_attenuation_m` | `environment.air_power_attenuation_per_m`. La m que devuelve es el coeficiente de atenuación de potencia de la ISO 354, en 1/m, no una longitud |
| `attenuation_from_alpha`, `air_attenuation_coefficient` | `materials.power_attenuation_from_alpha`, la única conversión que hacen la ISO 354 y la ISO 17497-1. Su argumento es `attenuation_db_per_m`, donde las dos funciones antiguas lo llamaban `alpha` y `pressure_attenuation_db_per_m`. Rechaza un alfa NaN o infinito, que `attenuation_from_alpha` dejaba pasar |
| `HtlanResult`, `NiptsResult` | `hearing.HTLANResult`, `hearing.NIPTSResult`: un acrónimo se escribe en mayúsculas, como en `HMLRatingResult` |
| `AnpAircraft`, `AnpDatabase`, `AnpNpdCurves`, `AnpProfile`, `NpdLevelResult` | `aircraft.ANPAircraft`, `aircraft.ANPDatabase`, `aircraft.ANPNPDCurves`, `aircraft.ANPProfile`, `aircraft.NPDLevelResult`; el número de motores es `ANPAircraft.n_engines` |
| `HvacSpectrumResult` | `noise_control.HVACSpectrumResult` |
| `mic_calibration_factor`, `apply_mic_calibration` | `materials.microphone_calibration_factor`, `materials.apply_microphone_calibration` |
| `lab_airborne_insulation`, `lab_impact_insulation`, `LabAirborneInsulationResult`, `LabImpactInsulationResult`, `LabInsulationWarning` | `building.laboratory_airborne_insulation`, `building.laboratory_impact_insulation`, `building.LaboratoryAirborneInsulationResult`, `building.LaboratoryImpactInsulationResult`, `building.LaboratoryInsulationWarning` |
| `EnclosureResult` | `noise_control.EnclosureInsertionLossResult`, lo que devuelve `enclosure_insertion_loss`, junto a `EnclosureInsulationResult` |
| `maximum_repeatability_standard_deviation`, `minimum_cumulative_duration_hours`, `minimum_phase` | `building.max_repeatability_standard_deviation`, `hearing.min_cumulative_duration_hours`, `signals.min_phase`: `max` y `min` en todo nombre público |
| `rigid_mass_calibration_check` | `vibration.verify_rigid_mass_calibration`, con los mismos argumentos y el mismo `RigidMassCalibrationResult`: juzga una cadena de medida, así que su verbo es `verify_` |
| `satisfies_lower_requirement`, `satisfies_upper_requirement` | `building.assess_requirement_conformity(rating, expanded_uncertainty_db, required_rating, bound="minimum")` o `bound="maximum"`. El booleano es su `.passes`, junto al `.margin_db` del que se lee, y las dos fórmulas siguen siendo estrictas |
| `strong_coupling_satisfied` | `building.check_strong_coupling`, con los mismos argumentos. El array booleano es su `.holds`, y `.passes` es todas las bandas |
| `tonal_seeking_survey` | `environment.assess_tonal_survey(levels, frequencies=frequencies)`. El array booleano es su `.prominent`, junto a los `.min_level_differences` y `.level_differences` de los que se lee |
| `air_density_astm`, `speed_of_sound_astm` | `materials.air_density_astm_e2611`, `materials.speed_of_sound_astm_e2611`, junto a `air_density_iso10534`: la designación de una norma en un nombre se escribe de una sola forma |
| `sae_band_attenuation` | `aircraft.band_attenuation_arp5534`, el documento que sigue |
| `itu_r_468_weighting` | `electroacoustics.weighting_bs468` |

## Lo que no ha cambiado

Casi todos los números. Cada renombrado de esta página devuelve lo que devolvía
su predecesor, salvo donde esta sección diga otra cosa, y si cualquier otro
resultado se mueve después de que termines de actualizar, eso es un defecto y
merece la pena [avisar](https://github.com/jmrplens/phonometry/issues). Los
números que sí se movieron están abajo. Cada uno se movió porque la 3.3.0 no
coincidía con el documento que sigue, o porque cambió un valor por defecto.

`verify_filter_class` califica todos los requisitos de IEC 61260-1 a la
frecuencia de entrada del banco, no solo la máscara de la Tabla 1, y una banda
de un banco diezmado se mueve hasta 0,07 dB con ruido blanco: la sección sobre
las clases de filtro de más arriba explica cómo.

| Lo que se movió | 3.3.0 | 4.0 |
| --- | --- | --- |
| Todas las curvas, A, B, C, D, G y AU, a través de `WeightingFilter.filter` y de `filters.weighting_filter`, que ahora se diseñan a la frecuencia de entrada en vez de sobremuestreadas, y por tanto todo nivel que pondera una señal con ellas, `signals.laeq` entre ellos | A a 48 kHz: −2,60 dB, −7,03 dB y −10,15 dB en las filas de 10, 16 y 20 kHz de la Tabla 3 de IEC 61672-1; a 16 kHz, A −13,1 dB y C −16,7 dB en la fila de 8 kHz; a 32 kHz, B −23,9 dB, D −17,1 dB y AU −35,9 dB a 16 kHz | −2,49 dB, −6,60 dB y −9,32 dB, los objetivos de diseño con 0,02 dB de diferencia como mucho; −1,11 dB y −3,01 dB en la fila de 8 kHz; B −8,42 dB, D −0,69 dB y AU −19,61 dB, de nuevo los objetivos de diseño |
| `WeightingFilter(..., stateful=True)`, que en la 3.3.0 ejecutaba A con el diseño bilineal simple y G con secciones diseñadas para una frecuencia sobremuestreada, las dos a la frecuencia de entrada, y ahora ejecuta el diseño preciso | A a 48 kHz: −7,05 dB en la fila de 12,5 kHz; G en su propia referencia de 10 Hz: −26,3 dB a 8 kHz y −36,3 dB a 1 kHz | −4,32 dB, el objetivo de diseño; 0 dB a cualquier frecuencia de muestreo |
| `verify_weighting_class` | calificaba las secciones diseñadas, y daba la clase 1 a una ponderación A a 16 kHz que perdía 12 dB en la fila de 8 kHz | califica el camino que recorre una señal a través de `WeightingFilter.filter` |
| `itu_r_468_weighting`, ahora `electroacoustics.weighting_bs468` | la Tabla 1 de UIT-R BS.468-4 interpolada entre sus filas: 4,45 dB a 11,06 kHz | la curva de la red que imprime la Recomendación: 5,06 dB ahí, y a unos 0,05 dB como mucho de la Tabla 1 en sus filas |
| `sae_band_attenuation`, ahora `aircraft.band_attenuation_arp5534` | la presión de vapor de saturación de la ISO 9613-1 | la que imprime SAE ARP 5534: unos 0,01 dB menos en 1 km a 8 kHz y 10 kHz |
| `extended_tube_chamber` con una prolongación de entrada o de salida | el tramo recto entre las dos ramas laterales tomado sobre toda la longitud L de la cámara | sobre L − L_a − L_b, que reproduce la Figura 8.20 de Bies: para L = 0,5 m, una relación de áreas m = 16 y prolongaciones de 0,125 m y 0,25 m, 22,7 dB a 200 Hz donde daba 0,6 dB |
| `underwater.ray_trace` y `environment.atmospheric_ray_paths` en una reflexión | un paso entero dado a través de la frontera y plegado de vuelta | un subpaso que acaba en la frontera, así que un rayo que rebota llega a otro sitio: un rayo de un canal de 100 m acaba a 5 km a 9,4 m de profundidad, donde acababa a 0,3 m |
| `room.open_plan_metrics` cuando el STI nunca baja hasta el umbral | una distancia de distracción o de privacidad de 10¹⁵ m o más | NaN |
| `effective_kappa` y `thermal_boundary_layer_thickness` con su aire por defecto | los cinco valores que imprime el Anexo A.3 de la ISO 9053-2 | el aire de IEC 61094-2 en el mismo estado, que mueve la corrección en su quinta cifra, como dice la sección sobre `fluid=` |
| un valor que cae justo en un límite que imprime una norma | se juzgaba por los últimos bits de su valor en coma flotante | se asienta antes a nueve decimales, igual en cualquier máquina |

El propio módulo de diseño de ponderaciones es nuevo en 4.0.0rc1, así que tres
de sus cambios se miden contra la versión candidata y no contra 3.3.0:

| Lo que se movió | 4.0.0rc1 | 4.0 |
| --- | --- | --- |
| `WeightingFilter.sos` en macOS y Windows, con glibc en x86-64 sin FMA, y en Linux en seis de los diseños comprobados y a frecuencias con las que no se comprueba la biblioteca | la biblioteca C de cada plataforma redondeaba a su manera las exponenciales, potencias, logaritmos, `sin`, `tan` y arcotangentes del diseño, y numpy compilado con clang, en macOS y Windows, fusionaba en multiply-adds los productos complejos de la transformada bilineal, así que la ponderación A a 48 kHz tenía un digest por plataforma, entre ellos `43f786ffab5c4dd4` con glibc sin FMA | en el diseño no queda ninguna rutina de la biblioteca C ni ningún producto complejo de numpy: toda plataforma diseña la ponderación A a 48 kHz con `991833ff389afe91`, y cada una de las demás curvas con unos mismos bytes también, porque las raíces y las secciones de la cascada son también aritmética propia del paquete; en Linux la arcotangente correctamente redondeada mueve en sus últimos bits las ponderaciones A y C a 44,1 y 88,2 kHz, la D a 88,2 kHz y la G a 1,5 kHz (la A a 44,1 kHz pasa de `74d1e53f498988c5` a `dbea4b7fc4ad972b`), y de 1 399 307 diseños (frecuencia, curva) a frecuencias enteras entre 100 Hz y 200 kHz, 5 864 encuentran un `sin` o una `tan` que glibc redondea al otro lado y 45 526 leen un nivel objetivo que su arcotangente cambia, y pueden moverse, entre las frecuencias habituales 50 kHz para A, B, C y D, 100 kHz para AU y 176,4 kHz para A, B y C |
| `WeightingFilter(fs, "468").sos` a cualquier frecuencia de muestreo, y `WeightingFilter(fs, "AU").sos` a 100 y 200 Hz | los polos del prototipo 468, de LAPACK a través de `numpy.roots`, y las secciones del `zpk2sos` de SciPy, que emparejaba polos con ceros por el módulo complejo de numpy | las raíces correctamente redondeadas del polinomio exacto de la red y las secciones propias del diseño: la respuesta 468 se mueve como mucho 0,0072 dB en las diecinueve frecuencias comprobadas, de 100 Hz a 192 kHz (0,000012 dB a 48 kHz, donde el digest pasa de `08f94c9ff182cff1` a `eee92dba5dcc41f7`), y la AU hasta dos unidades en el último lugar de ocho coeficientes a 100 Hz y una unidad de seis a 200 Hz |
| `WeightingFilter(fs, "B", high_accuracy=False).sos`, y lo mismo para C y G | el módulo complejo detrás de la ganancia, del valor absoluto complejo propio de numpy | del `hypot` fijado: una unidad en el último lugar de la ganancia en Linux |

La ficha ISO 3382 de un análisis en tercios de octava toma su tiempo de
reverberación de un solo número sobre las seis bandas de 400 Hz a 1250 Hz,
como imprime el apartado 9.1, donde promediaba las bandas de 500 Hz y 1 kHz. La
ficha ISO 10846 de una determinación indirecta enmarca la rigidez en la línea
más baja que admite la Desigualdad (2) de la ISO 10846-3, con una
transmisibilidad de 0,1 o menos, donde enmarcaba la línea más baja del barrido,
dentro de la zona de la resonancia. La ficha del micrófono escribe dB(468) para
la ponderación UIT-R BS.468-4, que la 3.3.0 te dejaba etiquetar como CCIR. Una
gráfica dibuja una banda sin lectura como ninguna barra, donde dibujaba un cero medido. Hay dos más en las secciones
de arriba: `installed_dynamic_stiffness` por debajo de 100 kPa·s/m², y las
posiciones del método de control de la ISO 3746 de
`emission.measurement_positions`.

Para el código escrito contra la 4.0.0rc1, el contrato de `Signal` es el que
era, ahora cumplido en dos sitios más, los bloques de `read_blocks` y las
formas de onda dentro de cinco resultados. Cualquier otra fórmula está intacta.
La 4.0 recolocó los muebles y puso la unidad en la etiqueta; salvo lo que
recoge esta sección, no recalculó nada.
