[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

50. ezunits


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

50.1 Introducción a ezunits

ezunits es un paquete para trabajar con magnitudes dimensionales, incluyendo algunas funciones para realizar análisis dimensional. 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 physical_constants, una colección de constantes físicas.

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

Una expresión tal como a ` b representa una magnitud dimensional, siendo a una magnitud adimensional y 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 a ` b pueden extraerse invocando las funciones qty y units, respectivamente.

Una expresión tal como a ` b `` c convierte las unidades b en c. El paquete 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 ezunits podrán declararse a posteriori. Las conversiones conocidas por ezunits están especificadas en la variable global 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 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. 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.

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

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.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

50.2 Introducción a physical_constants

physical_constants contiene constantes físicas recomendadas por el CODATA 2006 (http://physics.nist.gov/constants). La instrucción load(physical_constants) carga este paquete en memoria junto con el propio 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 ezunits. La función 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 constvalue.

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 physical_constant, de forma que propvars(physical_constant) muestra la lista de todas las constantes físicas.

physical_constants contiene las siguientes constantes:

%c

velocidad de la luz en el vacío

%mu_0

constante magnética

%e_0

constante eléctrica

%Z_0

impedancia característica del vacío

%G

constante gravitatoria de Newton

%h

constante de Planck

%h_bar

constante de Planck

%m_P

masa de Planck

%T_P

temperature de Planck

%l_P

longitud de Planck

%t_P

tiempo de Planck

%%e

carga elemental

%Phi_0

flujo magnético cuántico

%G_0

conductancia cuántica

%K_J

constante de Josephson

%R_K

constante de von Klitzing

%mu_B

magnetón de Bohr

%mu_N

magnetón nuclear

%alpha

constante de estructura fina

%R_inf

constante de Rydberg

%a_0

radio de Bohr

%E_h

energía de Hartree

%ratio_h_me

cuanto de circulación

%m_e

masa del electrón

%N_A

número de Avogadro

%m_u

constante de masa atómica atomic mass constant

%F

constante de Faraday

%R

constante molar de los gases

%%k

constante de Boltzmann

%V_m

volumen molar del gas ideal

%n_0

constante de Loschmidt

%ratio_S0_R

constante de Sackur-Tetrode (constante de entropía absoluta)

%sigma

constante de Stefan-Boltzmann

%c_1

primera constante de radiación

%c_1L

primera constante de radiación para radiancia espectral

%c_2

segunda constante de radiación

%b

Constante de la ley del desplazamiento de Wien

%b_prime

Constante de la ley del desplazamiento de Wien

Ejemplos:

Lista de todos los símbolos que tienen la propiedad physical_constant.

(%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]

Propiedades de la constante física %c.

(%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

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

(%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

[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

50.3 Funciones y variables para ezunits

Operador: `

Operador de magnitud dimensional. Una expresión tal como a ` b representa una magnitud dimensional, siendo a una magnitud adimensional y 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 a ` b pueden extraerse invocando las funciones qty y units, respectivamente.

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

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 load(ezunits).

Ejemplos:

Unidades del Sistema Internacional.

(%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

Unidades definidas por el usuario.

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

Unidades ad hoc.

(%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

Operaciones aritméticas y magnitudes dimensionales.

(%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
Operador: ``

Operador de conversión de unidades. Una expresión tal como a ` b `` c convierte las unidades b en c. El paquete 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 ezunits podrán declararse a posteriori. Las conversiones conocidas por ezunits están especificadas en la variable global 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, ezunits no transforma prefijos (milli-, centi-, deci-, etc) a menos que se le indique.

Para utilizar este operador ejecútese primero load(ezunits).

Ejemplos:

Conjunto de conversiones conocidas.

(%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}

Converiones de unidades fundamentales.

(%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

Transformando pies a metros y viceversa.

(%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

Análisis dimensional para encontrar dimensiones y unidades fundamentales.

(%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

Declaración de conversiones.

(%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
Función: constvalue (x)
Función: declare_constvalue (a, x)
Función: remove_constvalue (a)

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

Los valores constantes reconocidos por constvalue son distintos de los valores declarados por numerval y reconocidos por constantp.

El paquete physical_units declara los valores constantes de las constantes físicas.

remove_constvalue deshace la acción de declare_constvalue.

Para utilizar estas funciones ejecútese primero load(ezunits).

Ejemplos:

Valor de una constante física.

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

Declarando una nueva constante.

(%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
Función: units (x)
Función: declare_units (a, u)

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

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

declare_constvalue declara que units(a) debe devolver u, siendo u una expresión.

Para utilizar estas funciones ejecútese primero load(ezunits).

Ejemplos:

units aplicado a expresiones dimensionales literales.

(%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

units aplicado a símbolos con unidades declaradas.

(%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
Función: qty (x)
Función: declare_qty (a, x)

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

declare_qty declara que qty(a) debe devolver x, siendo x una magnitud dimensional.

Para utilizar estas funciones ejecútese primero load(ezunits).

Ejemplos:

qty aplicado a expresiones dimensionales literales.

(%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

qty aplicado a símbolos con unidades declaradas.

(%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
Función: unitp (x)

Devuelve true si 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, unitp devuelve false.

Para utilizar esta función ejecútese primero load(ezunits).

Ejemplos:

unitp aplicado a expresiones dimensionales literales.

(%i1) load (ezunits)$
(%i2) unitp (100 ` kg);
(%o2)                         true

unitp applied to a symbol declared dimensional.

(%i1) load (ezunits)$
(%i2) unitp (foo);
(%o2)                         false
(%i3) declare (foo, dimensional);
(%o3)                         done
(%i4) unitp (foo);
(%o4)                         true

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

(%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
Función: declare_unit_conversion (u = v, ...)

Añade las ecuaciones u = v, ... a la lista de conversiones de unidades conocidas por el operador de conversión ``. u y 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.

known_unit_conversions es la lista de conversiones de unidades conocidas.

Para utilizar esta función ejecútese primero load(ezunits).

Ejemplos:

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

(%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

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

(%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
Función: declare_dimensions (a_1, d_1, ..., a_n, d_n)
Función: remove_dimensions (a_1, ..., a_n)

declare_dimensions declara a_1, ..., a_n con las dimensiones d_1, ..., d_n, respectivamente.

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

remove_dimensions invierte el efecto de declare_dimensions.

Ejecútese load(ezunits) para hacer uso de estas funciones.

Ejemplos:

(%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
Función: declare_fundamental_dimensions (d_1, d_2, d_3, ...)
Función: remove_fundamental_dimensions (d_1, d_2, d_3, ...)
Variable global: fundamental_dimensions

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

remove_fundamental_dimensions invierte el efecto de declare_fundamental_dimensions.

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

Ejecútese load(ezunits) para hacer uso de estas funciones.

Ejemplos:

(%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]
Función: declare_fundamental_units (u_1, d_1, ..., u_n, d_n)
Función: remove_fundamental_units (u_1, ..., u_n)

declare_fundamental_units declara u_1, ..., u_n de dimensiones d_1, ..., d_n, respectivamente. Todos los argumentos deben símbolos.

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

remove_fundamental_units invierte el efecto de declare_fundamental_units.

Ejecútese load(ezunits) para hacer uso de estas funciones.

Ejemplos:

(%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
Función: dimensions (x)
Función: dimensions_as_list (x)

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

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

Para utilizar estas funciones ejecútese primero load(ezunits).

Ejemplos:

(%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
(%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]
Función: fundamental_units (x)
Función: fundamental_units ()

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

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

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

Para utilizar esta función ejecútese primero load(ezunits).

Ejemplos:

(%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
Función: dimensionless (L)

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

Para utilizar esta función ejecútese primero load(ezunits).

Ejemplos:

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

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.

(%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
Función: natural_unit (expr, [v_1, ..., v_n])

Busca los exponentes e_1, ..., e_n tales que dimension(expr) = dimension(v_1^e_1 ... v_n^e_n).

Para utilizar esta función ejecútese primero load(ezunits).


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert on agosto, 12 2012 using texi2html 1.76.