@c English version: 2011-06-11
@menu
* Introducción a ezunits::
* Introducción a physical_constants::
* Funciones y variables para ezunits::
@end menu

@node Introducción a ezunits, Introducción a physical_constants, ezunits, ezunits
@section Introducción a ezunits

@code{ezunits} es un paquete para trabajar con magnitudes dimensionales, incluyendo
algunas funciones para realizar análisis dimensional.
@code{ezunits} puede hacer operaciones aritméticas con magnitudes dimensionales y
efectuar conversiones entre unidades.
Las unidades que se definen son las del Sistema Internacional (SI) y otras comunes en
los Estados Unidos, siendo posible declarar otras nuevas.

Véase también @code{physical_constants}, una colección de constantes físicas.

Es necesario ejecutar primero @code{load(ezunits)} para utilizar este paquete. 
Con @code{demo(ezunits)} se podrán ver algunos ejemplos de utilización.
La función @code{known_units} devuelve una lista con todas las unidades
que están definidas y @code{display_known_unit_conversions} muestra
las conversiones conocidas por el sistema en un formato de lectura sencilla.

Una expresión tal como @math{a ` b} representa una magnitud dimensional, siendo
@code{a} una magnitud adimensional y @code{b} las unidades.
Se puede utilizar un símbolo como unidad, sin necesidad
de declararlo como tal ni de que deba cumplir propiedades especiales.
Tanto la magnitud como la unidad de una expresión de la forma @math{a ` b}
pueden extraerse invocando las funciones @code{qty} y @code{units},
respectivamente.

Una expresión tal como @code{a ` b `` c} convierte las unidades @code{b}
en @code{c}. El paquete @code{ezunits} contiene funciones conversoras para
unidades fundamentales del SI, unidades derivadas, así como
algunas otras unidades ajenas al SI.
Las conversiones entre unidades que no estén programadas en @code{ezunits}
podrán declararse a posteriori.
Las conversiones conocidas por @code{ezunits} están especificadas en la
variable global @code{known_unit_conversions}, incluyendo tanto las ya
declaradas por defecto como aquéllas introducidas por el usuario.
Las conversiones para los productos, cocientes y potencias de unidades
se derivan del conjunto de conversiones ya conocidas.

En general, Maxima prefiere números exactos (enteros o racionales)
a inexactos (decimales en coma flotante), por lo que @code{ezunits}
respetará los exactos cuando aparezcan en expresiones de magnitudes
dimensionales. Todas las conversiones del paquete se han definido en
términos de números exactos.

No hay un sistema de representación de unidades que se considere preferible,
razón por la cual las unidades no se convierten a otras a menos que se
indique de forma explícita. @code{ezunits} reconoce los prefijos
m-, k-, M y G- para mili-, kilo-, mega- y giga-, respectivamente, tal como se
utilizan en el SI; estos prefijos sólo se utilizan cuando así
se indica de forma explícita.

Las operaciones aritméticas con magnitudes dimensionales se realizan
de la forma convencional.

@itemize
@item @code{(x ` a) * (y ` b)} es igual a @math{(x * y) ` (a * b)}.
@item @code{(x ` a) + (y ` a)} es igual a @math{(x + y) ` a}.
@item @code{(x ` a)^y} es igual a @math{x^y ` a^y} si @code{y} es adimensional.
@end itemize

@code{ezunits} no necesita que las unidades en una suma tengan las mismas 
dimensiones; estos términos serán sumados sin emitirse mensaje de error.

@code{ezunits} incluye funciones para el análisis dimensional elemental,
como las dimensiones fundamentales, las unidades fundamentales de una
magnitud dimensional o el cálculo de magnitudes adimensionales y
unidades naturales. Las funciones de análisis dimensional son
adaptaciones de funciones semejantes escritas por Barton Willis en
otro paquete.

Con el fin de poder llevar a cabo análisis dimensionales, se 
mantiene una lista de dimensiones fundamentales y otra lista asociada
de unidades fundamentales; por defecto, las dimensiones fundamentales son
longitud, masa, tiempo, carga, temperatura y cantidad de materia, siendo
las unidades fundamentales las propias del Sistema Internacional.
En cualquier caso, es posible declarar otras dimensiones y unidades
fundamentales.



@node Introducción a physical_constants, Funciones y variables para ezunits, Introducción a ezunits, ezunits
@section Introducción a physical_constants

@code{physical_constants} contiene constantes físicas
recomendadas por el CODATA 2006 (@url{http://physics.nist.gov/constants}).
La instrucción @code{load(physical_constants)} carga este paquete
en memoria junto con el propio @code{ezunits}, si éste no estaba
previamente cargado.

Una constante física se representa por un símbolo
con la propiedad de ser un valor constante. El valor constante es una magnitud
dimensional en la sintaxis de @code{ezunits}. La función @code{constvalue}
extrae el valor constante, el cual no es el valor ordinario del símbolo,
por lo que las constantes físicas se mantienen inalteradas en las
expresiones evaluadas hasta que sus valores sea extraído con
la función @code{constvalue}.

@code{physical_constants} incluye cierta información adicional,
como la descripción de cada constante, una estimación del error 
de su valor numérico y una propiedad para ser representada en TeX.
Para identificar constantes físicas, cada símbolo
tiene la propiedad @code{physical_constant}, de forma que 
@code{propvars(physical_constant)} muestra la lista de todas
las constantes físicas.

@code{physical_constants} contiene las siguientes constantes:

@table @code
@item %c
velocidad de la luz en el vacío
@item %mu_0
constante magnética
@item %e_0
constante eléctrica
@item %Z_0
impedancia característica del vacío
@item %G
constante gravitatoria de Newton
@item %h
constante de Planck
@item %h_bar
constante de Planck
@item %m_P
masa de Planck
@item %T_P
temperature de Planck
@item %l_P
longitud de Planck
@item %t_P
tiempo de Planck
@item %%e
carga elemental
@item %Phi_0
flujo magnético cuántico
@item %G_0
conductancia cuántica
@item %K_J
constante de Josephson
@item %R_K
constante de von Klitzing
@item %mu_B
magnetón de Bohr
@item %mu_N
magnetón nuclear
@item %alpha
constante de estructura fina
@item %R_inf
constante de Rydberg
@item %a_0
radio de Bohr
@item %E_h
energía de Hartree
@item %ratio_h_me
cuanto de circulación
@item %m_e
masa del electrón
@item %N_A
número de Avogadro
@item %m_u
constante de masa atómica
atomic mass constant
@item %F
constante de Faraday
@item %R
constante molar de los gases
@item %%k
constante de Boltzmann
@item %V_m
volumen molar del gas ideal
@item %n_0
constante de Loschmidt
@item %ratio_S0_R
constante de Sackur-Tetrode (constante de entropía absoluta)
@item %sigma
constante de Stefan-Boltzmann
@item %c_1
primera constante de radiación
@item %c_1L
primera constante de radiación para radiancia espectral
@item %c_2
segunda constante de radiación
@item %b
Constante de la ley del desplazamiento de Wien
@item %b_prime
Constante de la ley del desplazamiento de Wien
@end table

Ejemplos:

Lista de todos los símbolos que tienen la propiedad
@code{physical_constant}.

@c ===beg===
@c load (physical_constants)$
@c propvars (physical_constant);
@c ===end===
@example
(%i1) load (physical_constants)$
(%i2) propvars (physical_constant);
(%o2) [%c, %mu_0, %e_0, %Z_0, %G, %h, %h_bar, %m_P, %T_P, %l_P, 
%t_P, %%e, %Phi_0, %G_0, %K_J, %R_K, %mu_B, %mu_N, %alpha, 
%R_inf, %a_0, %E_h, %ratio_h_me, %m_e, %N_A, %m_u, %F, %R, %%k, 
%V_m, %n_0, %ratio_S0_R, %sigma, %c_1, %c_1L, %c_2, %b, %b_prime]
@end example


Propiedades de la constante física @code{%c}.

@c ===beg===
@c load (physical_constants)$
@c constantp (%c);
@c get (%c, description);
@c constvalue (%c);
@c get (%c, RSU);
@c tex (%c);
@c ===end===
@example
(%i1) load (physical_constants)$
(%i2) constantp (%c);
(%o2)                         true
(%i3) get (%c, description);
(%o3)               speed of light in vacuum
(%i4) constvalue (%c);
                                      m
(%o4)                     299792458 ` -
                                      s
(%i5) get (%c, RSU);
(%o5)                           0
(%i6) tex (%c);
$$c$$
(%o6)                         false
@end example


Energía equivalente de una libra-masa. El símbolo
@code{%c} se mantiene hasta que su valor es extraído
con la llamada a la función @code{constvalue}.

@c ===beg===
@c load (physical_constants)$
@c m * %c^2;
@c %, m = 1 ` lbm;
@c constvalue (%);
@c E : % `` J;
@c E `` GJ;
@c float (%);
@c ===end===
@example
(%i1) load (physical_constants)$
(%i2) m * %c^2;
                                2
(%o2)                         %c  m
(%i3) %, m = 1 ` lbm;
                              2
(%o3)                       %c  ` lbm
(%i4) constvalue (%);
                                            2
                                       lbm m
(%o4)              89875517873681764 ` ------
                                          2
                                         s
(%i5) E : % `` J;
Computing conversions to base units; may take a moment. 
                     366838848464007200
(%o5)                ------------------ ` J
                             9
(%i6) E `` GJ;
                      458548560580009
(%o6)                 --------------- ` GJ
                         11250000
(%i7) float (%);
(%o7)              4.0759872051556356e+7 ` GJ
@end example



@node Funciones y variables para ezunits, , Introducción a physical_constants, ezunits
@section Funciones y variables para ezunits

@deffn {Operador} `

Operador de magnitud dimensional. 
Una expresión tal como @math{a ` b} representa una magnitud dimensional, siendo
@code{a} una magnitud adimensional y @code{b} las unidades.
Se puede utilizar un símbolo como unidad, sin necesidad
de declararlo como tal ni de que deba cumplir propiedades especiales.
Tanto la magnitud como la unidad de una expresión de la forma @math{a ` b}
pueden extraerse invocando las funciones @code{qty} y @code{units},
respectivamente.

Las operaciones aritméticas con magnitudes dimensionales se realizan
de la forma convencional.

@itemize
@item @code{(x ` a) * (y ` b)} es igual a @math{(x * y) ` (a * b)}.
@item @code{(x ` a) + (y ` a)} es igual a @math{(x + y) ` a}.
@item @code{(x ` a)^y} es igual a @math{x^y ` a^y} si @code{y} es adimensional.
@end itemize

@code{ezunits} no necesita que las unidades en una suma tengan las mismas 
dimensiones; estos términos serán sumados sin emitirse mensaje de error.

Para utilizar este operador ejecútese primero @code{load(ezunits)}.

Ejemplos:

Unidades del Sistema Internacional.

@c ===beg===
@c load (ezunits)$
@c foo : 10 ` m;
@c qty (foo);
@c units (foo);
@c dimensions (foo);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) foo : 10 ` m;
(%o2)                        10 ` m
(%i3) qty (foo);
(%o3)                          10
(%i4) units (foo);
(%o4)                           m
(%i5) dimensions (foo);
(%o5)                        length
@end example


Unidades definidas por el usuario.

@c ===beg===
@c load (ezunits)$
@c bar : x ` acre;
@c dimensions (bar);
@c fundamental_units (bar);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) bar : x ` acre;
(%o2)                       x ` acre
(%i3) dimensions (bar);
                                   2
(%o3)                        length
(%i4) fundamental_units (bar);
                                2
(%o4)                          m
@end example

Unidades ad hoc.

@c ===beg===
@c load (ezunits)$
@c baz : 3 ` sheep + 8 ` goat + 1 ` horse;
@c subst ([sheep = 3*goat, horse = 10*goat], baz);
@c baz2 : 1000`gallon/fortnight;
@c subst (fortnight = 14*day, baz2);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) baz : 3 ` sheep + 8 ` goat + 1 ` horse;
(%o2)           8 ` goat + 3 ` sheep + 1 ` horse
(%i3) subst ([sheep = 3*goat, horse = 10*goat], baz);
(%o3)                       27 ` goat
(%i4) baz2 : 1000`gallon/fortnight;
                                gallon
(%o4)                   1000 ` ---------
                               fortnight
(%i5) subst (fortnight = 14*day, baz2);
                          500   gallon
(%o5)                     --- ` ------
                           7     day
@end example


Operaciones aritméticas y magnitudes dimensionales.

@c ===beg===
@c load (ezunits)$
@c 100 ` kg + 200 ` kg;
@c 100 ` m^3 - 100 ` m^3;
@c (10 ` kg) * (17 ` m/s^2);
@c (x ` m) / (y ` s);
@c (a ` m)^2;
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) 100 ` kg + 200 ` kg;
(%o2)                       300 ` kg
(%i3) 100 ` m^3 - 100 ` m^3;
                                  3
(%o3)                        0 ` m
(%i4) (10 ` kg) * (17 ` m/s^2);
                                 kg m
(%o4)                      170 ` ----
                                   2
                                  s
(%i5) (x ` m) / (y ` s);
                              x   m
(%o5)                         - ` -
                              y   s
(%i6) (a ` m)^2;
                              2    2
(%o6)                        a  ` m
@end example


@end deffn

@deffn {Operador} `@w{}`

Operador de conversión de unidades.
Una expresión tal como @math{a ` b `@w{}` c} convierte las unidades @code{b}
en @code{c}. El paquete @code{ezunits} contiene funciones conversoras para
unidades fundamentales del SI, unidades derivadas, así como
algunas otras unidades ajenas al SI.
Las conversiones entre unidades que no estén programadas en @code{ezunits}
podrán declararse a posteriori.
Las conversiones conocidas por @code{ezunits} están especificadas en la
variable global @code{known_unit_conversions}, incluyendo tanto las ya
declaradas por defecto como aquéllas introducidas por el usuario.
Las conversiones para los productos, cocientes y potencias de unidades
se derivan del conjunto de conversiones ya conocidas.

No hay un sistema de representación de unidades que se considere preferible,
razón por la cual las unidades no se convierten a otras a menos que se
indique de forma explícita. Del mismo modo, @code{ezunits}
no transforma prefijos (milli-, centi-, deci-, etc) a menos que se le
indique.

Para utilizar este operador ejecútese primero @code{load(ezunits)}.

Ejemplos:

Conjunto de conversiones conocidas.

@c ===beg===
@c load (ezunits)$
@c display2d : false$
@c known_unit_conversions;
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) display2d : false$
(%i3) known_unit_conversions;
(%o3) @{acre = 4840*yard^2,Btu = 1055*J,cfm = feet^3/minute,
       cm = m/100,day = 86400*s,feet = 381*m/1250,ft = feet,
       g = kg/1000,gallon = 757*l/200,GHz = 1000000000*Hz,
       GOhm = 1000000000*Ohm,GPa = 1000000000*Pa,
       GWb = 1000000000*Wb,Gg = 1000000*kg,Gm = 1000000000*m,
       Gmol = 1000000*mol,Gs = 1000000000*s,ha = hectare,
       hectare = 100*m^2,hour = 3600*s,Hz = 1/s,inch = feet/12,
       km = 1000*m,kmol = 1000*mol,ks = 1000*s,l = liter,
       lbf = pound_force,lbm = pound_mass,liter = m^3/1000,
       metric_ton = Mg,mg = kg/1000000,MHz = 1000000*Hz,
       microgram = kg/1000000000,micrometer = m/1000000,
       micron = micrometer,microsecond = s/1000000,
       mile = 5280*feet,minute = 60*s,mm = m/1000,
       mmol = mol/1000,month = 2629800*s,MOhm = 1000000*Ohm,
       MPa = 1000000*Pa,ms = s/1000,MWb = 1000000*Wb,
       Mg = 1000*kg,Mm = 1000000*m,Mmol = 1000000000*mol,
       Ms = 1000000*s,ns = s/1000000000,ounce = pound_mass/16,
       oz = ounce,Ohm = s*J/C^2,
       pound_force = 32*ft*pound_mass/s^2,
       pound_mass = 200*kg/441,psi = pound_force/inch^2,
       Pa = N/m^2,week = 604800*s,Wb = J/A,yard = 3*feet,
       year = 31557600*s,C = s*A,F = C^2/J,GA = 1000000000*A,
       GC = 1000000000*C,GF = 1000000000*F,GH = 1000000000*H,
       GJ = 1000000000*J,GK = 1000000000*K,GN = 1000000000*N,
       GS = 1000000000*S,GT = 1000000000*T,GV = 1000000000*V,
       GW = 1000000000*W,H = J/A^2,J = m*N,kA = 1000*A,
       kC = 1000*C,kF = 1000*F,kH = 1000*H,kHz = 1000*Hz,
       kJ = 1000*J,kK = 1000*K,kN = 1000*N,kOhm = 1000*Ohm,
       kPa = 1000*Pa,kS = 1000*S,kT = 1000*T,kV = 1000*V,
       kW = 1000*W,kWb = 1000*Wb,mA = A/1000,mC = C/1000,
       mF = F/1000,mH = H/1000,mHz = Hz/1000,mJ = J/1000,
       mK = K/1000,mN = N/1000,mOhm = Ohm/1000,mPa = Pa/1000,
       mS = S/1000,mT = T/1000,mV = V/1000,mW = W/1000,
       mWb = Wb/1000,MA = 1000000*A,MC = 1000000*C,
       MF = 1000000*F,MH = 1000000*H,MJ = 1000000*J,
       MK = 1000000*K,MN = 1000000*N,MS = 1000000*S,
       MT = 1000000*T,MV = 1000000*V,MW = 1000000*W,
       N = kg*m/s^2,R = 5*K/9,S = 1/Ohm,T = J/(m^2*A),V = J/C,
       W = J/s@}
@end example


Converiones de unidades fundamentales.

@c ===beg===
@c load (ezunits)$
@c 1 ` ft `` m;
@c %, numer; 
@c 1 ` kg `` lbm; 
@c %, numer;
@c 1 ` W `` Btu/hour;
@c %, numer;
@c 100 ` degC `` degF;
@c -40 ` degF `` degC;
@c 1 ` acre*ft `` m^3;
@c %, numer;
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) 1 ` ft `` m;
Computing conversions to base units; may take a moment. 
                            381
(%o2)                       ---- ` m
                            1250
(%i3) %, numer;
(%o3)                      0.3048 ` m
(%i4) 1 ` kg `` lbm;
                            441
(%o4)                       --- ` lbm
                            200
(%i5) %, numer;
(%o5)                      2.205 ` lbm
(%i6) 1 ` W `` Btu/hour;
                           720   Btu
(%o6)                      --- ` ----
                           211   hour
(%i7) %, numer;
                                        Btu
(%o7)               3.412322274881517 ` ----
                                        hour
(%i8) 100 ` degC `` degF;
(%o8)                      212 ` degF
(%i9) -40 ` degF `` degC;
(%o9)                     (- 40) ` degC
(%i10) 1 ` acre*ft `` m^3;
                        60228605349    3
(%o10)                  ----------- ` m
                         48828125
(%i11) %, numer;
                                          3
(%o11)                1233.48183754752 ` m
@end example

Transformando pies a metros y viceversa.

@c ===beg===
@c load (ezunits)$
@c 100 ` m + 100 ` ft;
@c (100 ` m + 100 ` ft) `` ft;
@c %, numer;
@c (100 ` m + 100 ` ft) `` m;
@c %, numer;
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) 100 ` m + 100 ` ft;
(%o2)                  100 ` m + 100 ` ft
(%i3) (100 ` m + 100 ` ft) `` ft;
                           163100
(%o3)                      ------ ` ft
                            381
(%i4) %, numer;
(%o4)                428.0839895013123 ` ft
(%i5) (100 ` m + 100 ` ft) `` m;
                            3262
(%o5)                       ---- ` m
                             25
(%i6) %, numer;
(%o6)                      130.48 ` m
@end example

Análisis dimensional para encontrar dimensiones y unidades fundamentales.

@c ===beg===
@c load (ezunits)$
@c foo : 1 ` acre * ft;
@c dimensions (foo);
@c fundamental_units (foo);
@c foo `` m^3;
@c %, numer;
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) foo : 1 ` acre * ft;
(%o2)                      1 ` acre ft
(%i3) dimensions (foo);
                                   3
(%o3)                        length
(%i4) fundamental_units (foo);
                                3
(%o4)                          m
(%i5) foo `` m^3;
                        60228605349    3
(%o5)                   ----------- ` m
                         48828125
(%i6) %, numer;
                                          3
(%o6)                 1233.48183754752 ` m
@end example

Declaración de conversiones.

@c ===beg===
@c load (ezunits)$
@c declare_unit_conversion (MMBtu = 10^6*Btu, kW = 1000*W);
@c declare_unit_conversion (kWh = kW*hour, MWh = 1000*kWh, 
@c                          bell = 1800*s);
@c 1 ` kW*s `` MWh;
@c 1 ` kW/m^2 `` MMBtu/bell/ft^2;
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) declare_unit_conversion (MMBtu = 10^6*Btu, kW = 1000*W);
(%o2)                         done
(%i3) declare_unit_conversion (kWh = kW*hour, MWh = 1000*kWh,
                               bell = 1800*s);
(%o3)                         done
(%i4) 1 ` kW*s `` MWh;
Computing conversions to base units; may take a moment. 
                             1
(%o4)                     ------- ` MWh
                          3600000
(%i5) 1 ` kW/m^2 `` MMBtu/bell/ft^2;
                       1306449      MMBtu
(%o5)                 ---------- ` --------
                      8242187500          2
                                   bell ft
@end example
@end deffn

@deffn {Función} constvalue (@var{x})
@deffnx {Función} declare_constvalue (@var{a}, @var{x})
@deffnx {Función} remove_constvalue (@var{a})

Devuelve la constante declarada para un símbolo.
Los valores constantes se declaran con @code{declare_constvalue}.

Los valores constantes reconocidos por @code{constvalue}
son distintos de los valores declarados por @code{numerval}
y reconocidos por @code{constantp}.

El paquete @code{physical_units} declara los valores constantes
de las constantes físicas.

@code{remove_constvalue} deshace la acción de @code{declare_constvalue}.

Para utilizar estas funciones ejecútese primero @code{load(ezunits)}.

Ejemplos:

Valor de una constante física.

@c ===beg===
@c load (physical_constants)$
@c constvalue (%G);
@c get ('%G, 'description);
@c ===end===
@example
(%i1) load (physical_constants)$
(%i2) constvalue (%G);
                                     3
                                    m
(%o2)                    6.67428 ` -----
                                       2
                                   kg s
(%i3) get ('%G, 'description);
(%o3)           Newtonian constant of gravitation
@end example

Declarando una nueva constante.

@c ===beg===
@c load (ezunits)$
@c declare_constvalue (FOO, 100 ` lbm / acre);
@c FOO * (50 ` acre);
@c constvalue (%);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) declare_constvalue (FOO, 100 ` lbm / acre);
                                 lbm
(%o2)                      100 ` ----
                                 acre
(%i3) FOO * (50 ` acre);
(%o3)                     50 FOO ` acre
(%i4) constvalue (%);
(%o4)                      5000 ` lbm
@end example

@end deffn

@deffn {Función} units (@var{x})
@deffnx {Función} declare_units (@var{a}, @var{u})

Devuelve las unidades de la magnitud dimensional @var{x},
o 1 en caso de que @var{x} sea adimensional.

@var{x} puede ser una expresión literal dimensional @math{a ` b},
un símbolo con unidades declaradas por
medio de @code{declare_units}, o una expresión 
que contenga cualquiera o ambos de los anteriores.

@code{declare_constvalue} declara que @code{units(@var{a})}
debe devolver @var{u}, siendo @var{u} una expresión.

Para utilizar estas funciones ejecútese primero @code{load(ezunits)}.

Ejemplos:

@code{units} aplicado a expresiones dimensionales literales.

@c ===beg===
@c load (ezunits)$
@c foo : 100 ` kg;
@c bar : x ` m/s;
@c units (foo);
@c units (bar);
@c units (foo * bar);
@c units (foo / bar);
@c units (foo^2);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) foo : 100 ` kg;
(%o2)                              100 ` kg
(%i3) bar : x ` m/s;
                                         m
(%o3)                                x ` -
                                         s
(%i4) units (foo);
(%o4)                                 kg
(%i5) units (bar);
                                       m
(%o5)                                  -
                                       s
(%i6) units (foo * bar);
                                     kg m
(%o6)                                ----
                                      s
(%i7) units (foo / bar);
                                     kg s
(%o7)                                ----
                                      m
(%i8) units (foo^2);
                                        2
(%o8)                                 kg
@end example

@code{units} aplicado a símbolos con unidades declaradas.

@c ===beg===
@c load (ezunits)$
@c units (aa);
@c declare_units (aa, J);
@c units (aa);
@c units (aa^2);
@c foo : 100 ` kg;
@c units (aa * foo);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) linenum:0;
(%o0)                                  0
(%i1) units (aa);
(%o1)                                  1
(%i2) declare_units (aa, J);
(%o2)                                  J
(%i3) units (aa);
(%o3)                                  J
(%i4) units (aa^2);
                                       2
(%o4)                                 J
(%i5) foo : 100 ` kg;
(%o5)                              100 ` kg
(%i6) units (aa * foo);
(%o6)                                kg J
@end example

@end deffn

@deffn {Función} qty (@var{x})
@deffnx {Función} declare_qty (@var{a}, @var{x})

@code{qty} devuelve la parte adimensional de la magnitud dimensional @var{x},
o @var{x}, si @var{x} es adimensional.
@var{x} puede ser una expresión literal dimensional @math{a ` b},
un símbolo con unidades declaradas o una expresión 
que contenga cualquiera o ambos de los anteriores.

@code{declare_qty} declara que @code{qty(@var{a})}
debe devolver @var{x}, siendo @var{x} una magnitud dimensional.

Para utilizar estas funciones ejecútese primero @code{load(ezunits)}.

Ejemplos:

@code{qty} aplicado a expresiones dimensionales literales.

@c ===beg===
@c load (ezunits)$
@c foo : 100 ` kg;
@c qty (foo);
@c bar : v ` m/s;
@c foo * bar;
@c qty (foo * bar);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) foo : 100 ` kg;
(%o2)                       100 ` kg
(%i3) qty (foo);
(%o3)                          100
(%i4) bar : v ` m/s;
                                  m
(%o4)                         v ` -
                                  s
(%i5) foo * bar;
                                  kg m
(%o5)                     100 v ` ----
                                   s
(%i6) qty (foo * bar);
(%o6)                         100 v
@end example

@code{qty} aplicado a símbolos con unidades declaradas.

@c ===beg===
@c load (ezunits)$
@c declare_qty (aa, xx);
@c qty (aa);
@c qty (aa^2);
@c foo : 100 ` kg;
@c qty (aa * foo);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) declare_qty (aa, xx);
(%o2)                          xx
(%i3) qty (aa);
(%o3)                          xx
(%i4) qty (aa^2);
                                 2
(%o4)                          xx
(%i5) foo : 100 ` kg;
(%o5)                       100 ` kg
(%i6) qty (aa * foo);
(%o6)                        100 xx
@end example

@end deffn

@c PROBABLY SHOULD RENAME THIS TO DIMENSIONALP !!
@deffn {Función} unitp (@var{x})

Devuelve @code{true} si @var{x} es una expresión dimensional
literal, un símbolo declarado como dimensional o
una expresión en la que su operador principal ha sido declarado
como dimensional. En cualquier otro caso, @code{unitp} devuelve
@code{false}.

Para utilizar esta función ejecútese primero @code{load(ezunits)}.

Ejemplos:

@code{unitp} aplicado a expresiones dimensionales literales.

@c ===beg===
@c load (ezunits)$
@c unitp (100 ` kg);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) unitp (100 ` kg);
(%o2)                         true
@end example

@code{unitp} applied to a symbol declared dimensional.

@c ===beg===
@c load (ezunits)$
@c unitp (foo);
@c declare (foo, dimensional);
@c unitp (foo);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) unitp (foo);
(%o2)                         false
(%i3) declare (foo, dimensional);
(%o3)                         done
(%i4) unitp (foo);
(%o4)                         true
@end example

@code{unitp} aplicado a una expresión en la que el operador
principal se declara dimensional.

@c ===beg===
@c load (ezunits)$
@c unitp (bar (x, y, z));
@c declare (bar, dimensional);
@c unitp (bar (x, y, z));
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) unitp (bar (x, y, z));
(%o2)                         false
(%i3) declare (bar, dimensional);
(%o3)                         done
(%i4) unitp (bar (x, y, z));
(%o4)                         true
@end example

@end deffn

@deffn {Función} declare_unit_conversion (@var{u} = @var{v}, ...)

Añade las ecuaciones @var{u} = @var{v}, ... a la lista de conversiones
de unidades conocidas por el operador de conversión @math{`@w{}`}.
@var{u} y @var{v} son términos multiplicativos en las que las
variables son unidades o expresiones dimensionales literales.

De momento, es imperativo expresar las conversiones de forma
que el miembro izquierdo de cada ecuación sea una unidad simple
(en opsición a una expresión multiplicativa) o una expresión
dimensional literal con la cantidad igual a 1 y con unidad simple.
Está previsto eliminar esta restricción en versiones futuras.

@code{known_unit_conversions} es la lista de conversiones de unidades conocidas.

Para utilizar esta función ejecútese primero @code{load(ezunits)}.

Ejemplos:

Conversión de unidades expresadas por ecuaciones con términos multiplicativos.

@c ===beg===
@c load (ezunits)$
@c declare_unit_conversion (nautical_mile = 1852 * m, 
@c                          fortnight = 14 * day);
@c 100 ` nautical_mile / fortnight `` m/s;
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) declare_unit_conversion (nautical_mile = 1852 * m,
                               fortnight = 14 * day);
(%o2)                         done
(%i3) 100 ` nautical_mile / fortnight `` m/s;
Computing conversions to base units; may take a moment. 
                            463    m
(%o3)                       ---- ` -
                            3024   s
@end example

Conversión de unidades expresadas por ecuaciones con expresiones dimensionales
literales.

@c ===beg===
@c load (ezunits)$
@c declare_unit_conversion (1 ` fluid_ounce = 2 ` tablespoon);
@c declare_unit_conversion (1 ` tablespoon = 3 ` teaspoon);
@c 15 ` fluid_ounce `` teaspoon;
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) declare_unit_conversion (1 ` fluid_ounce = 2 ` tablespoon);
(%o2)                         done
(%i3) declare_unit_conversion (1 ` tablespoon = 3 ` teaspoon);
(%o3)                         done
(%i4) 15 ` fluid_ounce `` teaspoon;
Computing conversions to base units; may take a moment. 
(%o4)                     90 ` teaspoon
@end example


@end deffn


@deffn {Función} declare_dimensions (@var{a_1}, @var{d_1}, ..., @var{a_n}, @var{d_n})
@deffnx {Función} remove_dimensions (@var{a_1}, ..., @var{a_n})

@code{declare_dimensions} declara @var{a_1}, ..., @var{a_n}
con las dimensiones @var{d_1}, ..., @var{d_n}, respectivamente.

Cada @var{a_k} es un símbolo o lista de símbolos.
En caso de ser una lista, cada símbolo en @var{a_k} se
declara de dimensión @var{d_k}.

@code{remove_dimensions} invierte el efecto de @code{declare_dimensions}.

Ejecútese @code{load(ezunits)} para hacer uso de estas funciones.

Ejemplos:

@c ===beg===
@c load (ezunits) $
@c declare_dimensions ([x, y, z], length, [t, u], time);
@c dimensions (y^2/u);
@c fundamental_units (y^2/u);
@c ===end===
@example
(%i1) load (ezunits) $
(%i2) declare_dimensions ([x, y, z], length, [t, u], time);
(%o2)                         done
(%i3) dimensions (y^2/u);
                                   2
                             length
(%o3)                        -------
                              time
(%i4) fundamental_units (y^2/u);
0 errors, 0 warnings
                                2
                               m
(%o4)                          --
                               s
@end example

@end deffn

@deffn {Función} declare_fundamental_dimensions (@var{d_1}, @var{d_2}, @var{d_3}, ...)
@deffnx {Función} remove_fundamental_dimensions (@var{d_1}, @var{d_2}, @var{d_3}, ...)
@deffnx {Variable global} fundamental_dimensions

@code{declare_fundamental_dimensions} declara dimensiones fundamentales.
Los símbolos @var{d_1}, @var{d_2}, @var{d_3}, ... se añaden a la lista
de dimensiones fundamentales si no están ya presentes en la lista.

@code{remove_fundamental_dimensions} invierte el efecto de @code{declare_fundamental_dimensions}.

@code{fundamental_dimensions} es la lista de dimensiones fundamentales.
Por defecto, la lista comprende algunas dimensiones físicas.

Ejecútese @code{load(ezunits)} para hacer uso de estas funciones.

Ejemplos:

@c ===beg===
@c load (ezunits) $
@c fundamental_dimensions;
@c declare_fundamental_dimensions (money, cattle, happiness);
@c fundamental_dimensions;
@c remove_fundamental_dimensions (cattle, happiness);
@c fundamental_dimensions;
@c ===end===
@example
(%i1) load (ezunits) $
(%i2) fundamental_dimensions;
(%o2) [length, mass, time, current, temperature, quantity]
(%i3) declare_fundamental_dimensions (money, cattle, happiness);
(%o3)                         done
(%i4) fundamental_dimensions;
(%o4) [length, mass, time, current, temperature, quantity, 
                                        money, cattle, happiness]
(%i5) remove_fundamental_dimensions (cattle, happiness);
(%o5)                         done
(%i6) fundamental_dimensions;
(%o6) [length, mass, time, current, temperature, quantity, money]
@end example

@end deffn


@deffn {Función} declare_fundamental_units (@var{u_1}, @var{d_1}, ..., @var{u_n}, @var{d_n})
@deffnx {Función} remove_fundamental_units (@var{u_1}, ..., @var{u_n})

@code{declare_fundamental_units} declara @var{u_1}, ..., @var{u_n}
de dimensiones @var{d_1}, ..., @var{d_n}, respectivamente.
Todos los argumentos deben símbolos.

Tras la llamada a @code{declare_fundamental_units},
@code{dimensions(@var{u_k})} devuelve @var{d_k} para cada argumento @var{u_1}, ..., @var{u_n},
y @code{fundamental_units(@var{d_k})} devuelve @var{u_k} para cada @var{d_1}, ..., @var{d_n}.

@code{remove_fundamental_units} invierte el efecto de @code{declare_fundamental_units}.

Ejecútese @code{load(ezunits)} para hacer uso de estas funciones.

Ejemplos:

@c ===beg===
@c load (ezunits) $
@c declare_fundamental_dimensions (money, cattle, happiness);
@c declare_fundamental_units (dollar, money, goat, cattle,
@c                            smile, happiness);
@c dimensions (100 ` dollar/goat/km^2);
@c dimensions (x ` smile/kg);
@c fundamental_units (money*cattle/happiness);
@c ===end===
@example
(%i1) load (ezunits) $
(%i2) declare_fundamental_dimensions (money, cattle, happiness);
(%o2)                         done
(%i3) declare_fundamental_units (dollar, money, goat, cattle,
                                 smile, happiness);
(%o3)                 [dollar, goat, smile]
(%i4) dimensions (100 ` dollar/goat/km^2);
                             money
(%o4)                    --------------
                                      2
                         cattle length
(%i5) dimensions (x ` smile/kg);
                            happiness
(%o5)                       ---------
                              mass
(%i6) fundamental_units (money*cattle/happiness);
0 errors, 0 warnings
                           dollar goat
(%o6)                      -----------
                              smile
@end example

@end deffn


@deffn {Función} dimensions (@var{x})
@deffnx {Función} dimensions_as_list (@var{x})

@code{dimensions} devuelve las dimensiones de la magnitud dimensional @var{x}
en forma de expresión que contiene productos y potencias de dimensiones
fundamentales.

@code{dimensions_as_list} devuelve las dimensiones de la magnitud dimensional @var{x}
en forma de lista, cuyos elementos indican las potencias de las dimensiones
fundamentales correspondientes.

Para utilizar estas funciones ejecútese primero @code{load(ezunits)}.

Ejemplos:

@c ===beg===
@c load (ezunits)$
@c dimensions (1000 ` kg*m^2/s^3);
@c declare_units (foo, acre*ft/hour);
@c dimensions (foo);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) dimensions (1000 ` kg*m^2/s^3);
                                2
                          length  mass
(%o2)                     ------------
                                 3
                             time
(%i3) declare_units (foo, acre*ft/hour);
                             acre ft
(%o3)                        -------
                              hour
(%i4) dimensions (foo);
                                   3
                             length
(%o4)                        -------
                              time
@end example


@c ===beg===
@c load (ezunits)$
@c fundamental_dimensions;
@c dimensions_as_list (1000 ` kg*m^2/s^3);
@c declare_units (foo, acre*ft/hour);
@c dimensions_as_list (foo);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) fundamental_dimensions;
(%o2)  [length, mass, time, charge, temperature, quantity]
(%i3) dimensions_as_list (1000 ` kg*m^2/s^3);
(%o3)                 [2, 1, - 3, 0, 0, 0]
(%i4) declare_units (foo, acre*ft/hour);
                             acre ft
(%o4)                        -------
                              hour
(%i5) dimensions_as_list (foo);
(%o5)                 [3, 0, - 1, 0, 0, 0]
@end example


@end deffn



@deffn {Función} fundamental_units (@var{x})
@deffnx {Función} fundamental_units ()

@code{fundamental_units(@var{x})} devuelve las unidades
asociadas a las dimensiones fundamentales de @var{x},
tal como queda determinada por @code{dimensions(@var{x})}.

@var{x} puede ser una expresión literal dimensional @math{a ` b},
un símbolo con unidades declaradas a través de
@code{declare_units} o una expresión que contenga a ambos.

@code{fundamental_units()} devuelve una lista con las unidades
fundamentales conocidas, tal como fueron declaradas por @code{declare_fundamental_units}.

Para utilizar esta función ejecútese primero @code{load(ezunits)}.

Ejemplos:

@c ===beg===
@c load (ezunits)$
@c fundamental_units ();
@c fundamental_units (100 ` mile/hour);
@c declare_units (aa, g/foot^2);
@c fundamental_units (aa);
@c ===end===
@example
(%i1) load (ezunits)$
(%i2) fundamental_units ();
(%o2)                 [m, kg, s, A, K, mol]
(%i3) fundamental_units (100 ` mile/hour);
                                m
(%o3)                           -
                                s
(%i4) declare_units (aa, g/foot^2);
                                g
(%o4)                         -----
                                  2
                              foot
(%i5) fundamental_units (aa);
                               kg
(%o5)                          --
                                2
                               m
@end example

@end deffn

@deffn {Función} dimensionless (@var{L})

Devuelve una expresión sin dimensiones que se puede formar
a partir de una lista @var{L} de cantidades dimensionales 

Para utilizar esta función ejecútese primero @code{load(ezunits)}.

Ejemplos:

@c ===beg===
@c load (ezunits) $
@c dimensionless ([x ` m, y ` m/s, z ` s]);
@c ===end===
@example
(%i1) load (ezunits) $
(%i2) dimensionless ([x ` m, y ` m/s, z ` s]);
0 errors, 0 warnings
0 errors, 0 warnings
                               y z
(%o2)                         [---]
                                x
@end example

Cantidades adimensionales obtenidas a partir de cantidades físicas.
Nótese que el primer elemento de la lista es proporcional a la
constante de estructura fina.

@c ===beg===
@c load (ezunits) $
@c load (physical_constants) $
@c dimensionless([%h_bar, %m_e, %m_P, %%e, %c, %e_0]);
@c ===end===
@example
(%i1) load (ezunits) $
(%i2) load (physical_constants) $
(%i3) dimensionless([%h_bar, %m_e, %m_P, %%e, %c, %e_0]);
0 errors, 0 warnings
0 errors, 0 warnings
                              2
                           %%e        %m_e
(%o3)                [--------------, ----]
                      %c %e_0 %h_bar  %m_P
@end example

@end deffn


@deffn {Función} natural_unit (@var{expr}, [@var{v_1}, ..., @var{v_n}])

Busca los exponentes @var{e_1}, ..., @var{e_n} tales que
@code{dimension(@var{expr}) = dimension(@var{v_1}^@var{e_1} ... @var{v_n}^@var{e_n})}.

Para utilizar esta función ejecútese primero @code{load(ezunits)}.

@end deffn





