@c /unit.texi/1.2/Sun May 28 17:08:50 2006//
@menu
* Introdução a Units::       
* Definições para Units::       
@end menu

@node Introdução a Units, Definições para Units, unit, unit
@section Introdução a Units

O pacote @emph{unit} torna o utilizador apto a converter entre unidades
arbitrárias e trabalhar com dimensões em equações. O funcionamento desse pacote
é radicalmente diferente do pacote original units do Maxima - apesar de
o original conter uma lista básica de definições, o pacote actual usa um conjunto de regras para permitir
ao utilizador escolher, sobre uma base dimensional, qual a resposta fianl de unidade pode ser
convertida.  Isso irá separar unidades em lugar de misturá-las na tela,
permitindo ao utilizador durante a leitura identificar as unidades associadas com uma resposta em
particular.  Isso permitirá ao utilizador simplificar uma expressão em sua Base fundamental
de Unidades, bem como fornecer ajuste fino sobre a simplificação de unidades derivadas.
Análise dimensional é possível, e uma variedade de ferramentas está disponível para 
gerenciar a conversão e também uma variedade de opções de simplificação. Adicionalmente para personalizar
conversão automática, @emph{units} também fornede um manual tradicional 
de opções de conversão.  

Nota -quando conversões de unidade forem não exactas Maxima irá fazer aproximações resultando 
em frações. Esso é uma concequência das técnicas usadas para simplificar unidades.
A mensagem de alerta desse tipo de substituição está desabilitada por padrão no
caso de inidades (normalmente essas mensagens estão habilitadas) uma vez que essa situação de iemissão de mensagens de alerta ocorre frequêntemente
e os alertas confundem a saída.  (O estado actual de @code{ratprint} é restabelecido
após uma conversão de unidades, de forma que modificações de utilizador para aquela configuração irão ser preservadas 
de outra forma.)  Se o utilizador precisar dessa informação para @code{units}, ele pode escolher
@emph{unitverbose:on} para reativar a impressão de mensagens de alerta do
processo de conversão.

@emph{unit} está inclído no Maxima no directório share/contrib/unit directory. Isso segue
aos pacotes normais do Maxima conforme convenções:

@example
(%i1) load("unit")$
******************************************************************* 
*                       Units version 0.50                        * 
*          Definitions based on the NIST Reference on             * 
*              Constants, Units, and Uncertainty                  * 
*       Conversion factors from various sources including         * 
*                   NIST and the GNU units package                * 
******************************************************************* 
 
Redefining necessary functions... 
WARNING: DEFUN/DEFMACRO: redefining function TOPLEVEL-MACSYMA-EVAL ...
WARNING: DEFUN/DEFMACRO: redefining function MSETCHK ...
WARNING: DEFUN/DEFMACRO: redefining function KILL1 ...
WARNING: DEFUN/DEFMACRO: redefining function NFORMAT ...
Initializing unit arrays... 
Done.
@end example

As mensagens WARNING (DE ALERTA) são esperadas n ão uma causa de preocupação - elas indicam
que o pacote @emph{unit} está redefinindo funções anteriormente definidas no local adequado do Maxima.  
Essa redefinição é necessária com o bojetivo de manusear adequadamente as unidades.  O utilizador
pode estar consciente que se outras modificações tiverem sido feitas para essas funções por outros
pacotes essas novas mudanças irão ser sobrescritas por meio desse processo de disponibilização do pacote @code{unit}.

O ficheiro @emph{unit.mac} também chama um ficheiro lisp, a saber @emph{unit-functions.lisp}, que
contém as funçãoes lisp necessárias ao pacote.

Clifford Yapp é o autor primário.  Ele recebeu grande contribuição de
Barton Willis da University of Nebraska at Kearney (UNK), Robert Dodier, e
da intrépida tribo da lista de mensagens do Maxima.

Existem provavelmente muitos erros.  Diga-me quais.  @code{float} e @code{numer}
não fazem o que é esperado.

PORFAZER : funcionalidade de dimensão, manuseio de temperatura, 
a função @code{showabbr} e Cia. Ltda.  Mostrar exemplos com adição de quantidades contendo
unidades.


@node Definições para Units,  , Introdução a Units, unit
@section Definições para Units

@deffn {Função} setunits (@var{list})
Por padrão, o pacote @emph{unit} não usa qualquer dimensões derivadas, mas irá
converter todas as unidades nas sete fundamentais do sistema MKS.
@example
(%i2) N;
                                     kg m
(%o2)                                ----
                                       2
                                      s
(%i3) dyn;
                                   1      kg m
(%o3)                           (------) (----)
                                 100000     2
                                           s
(%i4) g;
                                    1
(%o4)                             (----) (kg)
                                   1000
(%i5) centigram*inch/minutes^2;
                                  127        kg m
(%o5)                       (-------------) (----)
                             1800000000000     2
                                              s
@end example

Em alguns casos esse é o comportamento desejado.  Se o utilizador desejar usar outras
unidades, isso é conseguido com o comando @code{setunits}:
@example
(%i6) setunits([centigram,inch,minute]);
(%o6)                                done
(%i7) N;
                            1800000000000   %in cg
(%o7)                      (-------------) (------)
                                 127            2
                                            %min
(%i8) dyn;
                               18000000   %in cg
(%o8)                         (--------) (------)
                                 127          2
                                          %min
(%i9) g;
(%o9)                             (100) (cg)
(%i10) centigram*inch/minutes^2;
                                    %in cg
(%o10)                              ------
                                        2
                                    %min
@end example

A escolha de unidades é completamente flexível.  Por exemplo, se quisermos
voltar para quiilogramas, metros, e segundos como padrão para essas
dimensão nós podemos fazer:
@example
(%i11) setunits([kg,m,s]);
(%o11)                               done
(%i12) centigram*inch/minutes^2;
                                  127        kg m
(%o12)                      (-------------) (----)
                             1800000000000     2
                                              s
@end example

Unidade derivadas são também manuseáveis por meio desse comando:
@example
(%i17) setunits(N);
(%o17)                               done
(%i18) N;
(%o18)                                 N
(%i19) dyn; 
                                    1
(%o19)                           (------) (N)
                                  100000
(%i20) kg*m/s^2;
(%o20)                                 N
(%i21) centigram*inch/minutes^2;
                                    127
(%o21)                        (-------------) (N)
                               1800000000000
@end example

Note que o pacote @emph{unit} reconhece a combinação não MKS
de massa, comprimento, e tempo inverso elevado ao quadrado como uma força, e converte isso
para Newtons.  É dessa forma que Maxima trabalha geralmente.  Se, por exemplo, nós
preferirmos dinas em lugar de Newtons, simplesmente fazemos o seguinte:
@example
(%i22) setunits(dyn);
(%o22)                               done
(%i23) kg*m/s^2;
(%o23)                          (100000) (dyn)
(%i24) centigram*inch/minutes^2;
                                  127
(%o24)                         (--------) (dyn)
                                18000000
@end example

Para descontinuar simplificando para qualquer unidade de força, usamos o comando @code{uforget}:
@example
(%i26) uforget(dyn);
(%o26)                               false
(%i27) kg*m/s^2;
                                     kg m
(%o27)                               ----
                                       2
                                      s
(%i28) centigram*inch/minutes^2;
                                  127        kg m
(%o28)                      (-------------) (----)
                             1800000000000     2
                                              s
@end example
Isso pode trabalhar igualmente bem com @code{uforget(N)} ou
@code{uforget(%force)}.

Veja também @code{uforget}. Para usar essa função escreva primeiro @code{load("unit")}.
@end deffn

@deffn {Função} uforget (@var{list})
Por padrão, o pacote @emph{unit} converte todas as unidades para as
sete unidaes fundamentais do sitema MKS de unidades. Ess comportamento pode
ser mudado com o comando @code{setunits}. Após o qual, o
utilizador pode restabelecer o comportamento padrão para uma dimensão em particular
mediante o comando @code{uforget}:
@example
(%i13) setunits([centigram,inch,minute]);
(%o13)                               done
(%i14) centigram*inch/minutes^2;
                                    %in cg
(%o14)                              ------
                                        2
                                    %min
(%i15) uforget([cg,%in,%min]);
(%o15)                      [false, false, false]
(%i16) centigram*inch/minutes^2;
                                  127        kg m
(%o16)                      (-------------) (----)
                             1800000000000     2
                                              s
@end example

@code{uforget} opera sobre dimensões,
não sobre unidades, de forma que qualquer unidade de uma dimensão em particular irá trabalhar.  A
própia dimensão é também um argumento legal.

Veja também @code{setunits}. To use this function write first @code{load("unit")}.
@end deffn

@deffn {Função} convert (@var{expr}, @var{list})
Quando do restabelecimento dos valores padrão o ambiente global é destruído, existe o comando
@code{convert}, que permite conversões imediatas.  @code{convert} pode aceitar  um argumetno
simples ou uma lista de unidades a serem usadas na conversão.  Quando uma operação de conversão for
concluída, o sistema normal de avaliação global é contornado, com o objectivo de evitar que
o resultado desejado seja convertido novamente.  Como consequência, em cálculos aproximados
alertas de "rat" irão ser visíveis se o ambiente global que controla esse comportamento
(@code{ratprint}) for @code{true}.  @code{convert} também é útil para uma verificação pontual e imediata da
precisão de uma conversão global.  Outro recurso é que @code{convert} irá permitir a um
utilizador fazer um Base de Conversões Dimensionais mesmo se o ambiente global for escolhido para
simplificar par uma Dimensão Derivada.

@example
(%i2) kg*m/s^2;
                                     kg m
(%o2)                                ----
                                       2
                                      s
(%i3) convert(kg*m/s^2,[g,km,s]);
                                     g km
(%o3)                                ----
                                       2
                                      s
(%i4) convert(kg*m/s^2,[g,inch,minute]);

`rat' replaced 39.37007874015748 by 5000/127 = 39.37007874015748
                              18000000000   %in g
(%o4)                        (-----------) (-----)
                                  127           2
                                            %min
(%i5) convert(kg*m/s^2,[N]);
(%o5)                                  N
(%i6) convert(kg*m^2/s^2,[N]);
(%o6)                                 m N
(%i7) setunits([N,J]);
(%o7)                                done
(%i8) convert(kg*m^2/s^2,[N]);
(%o8)                                 m N
(%i9) convert(kg*m^2/s^2,[N,inch]);

`rat' replaced 39.37007874015748 by 5000/127 = 39.37007874015748
                                 5000
(%o9)                           (----) (%in N)
                                 127
(%i10) convert(kg*m^2/s^2,[J]);
(%o10)                                 J
(%i11) kg*m^2/s^2;
(%o11)                                 J
(%i12) setunits([g,inch,s]);
(%o12)                               done
(%i13) kg*m/s^2;
(%o13)                                 N
(%i14) uforget(N);
(%o14)                               false
(%i15) kg*m/s^2;
                                5000000   %in g
(%o15)                         (-------) (-----)
                                  127       2
                                           s
(%i16) convert(kg*m/s^2,[g,inch,s]);

`rat' replaced 39.37007874015748 by 5000/127 = 39.37007874015748
                                5000000   %in g
(%o16)                         (-------) (-----)
                                  127       2
                                           s
@end example

Veja também @code{setunits} e @code{uforget}. Para usar essa função primeiramente escreva @code{load("unit")}.
@end deffn


@defvr {Variável de opção} usersetunits
Valor por omissão: none

Se um utilizador desejar ter um comportamento padrão de unidade diferente daquele descrito,
ele pode fazer uso de @emph{maxima-init.mac} e da variável
@emph{usersetunits}.  O pacote @emph{unit} irá verificar o ficheiro @emph{maxima-init.mac} na inicialização para ver se a essa variável 
foi atribuído uma lista.  Se isso aconteceu, o pacote @emph{unit} irá usar @code{setunits} sobre aquela lista e pegar 
as unidades lá colocadas para serem as padrões.  @code{uforget} irá reverter para o comportamento
definido por @code{usersetunits} sobrescrevendo seus próprios padrões.  Por exemplo, Se tivermos um ficheiro
@emph{maxima-init.mac} contendo:
@example
usersetunits : [N,J];
@end example
nós poderemos ver o seguinte comportamento:
@example
(%i1) load("unit")$
******************************************************************* 
*                       Units version 0.50                        * 
*          Definitions based on the NIST Reference on             * 
*              Constants, Units, and Uncertainty                  * 
*       Conversion factors from various sources including         * 
*                   NIST and the GNU units package                * 
******************************************************************* 
 
Redefining necessary functions... 
WARNING: DEFUN/DEFMACRO: redefining function TOPLEVEL-MACSYMA-EVAL ...
WARNING: DEFUN/DEFMACRO: redefining function MSETCHK ...
WARNING: DEFUN/DEFMACRO: redefining function KILL1 ...
WARNING: DEFUN/DEFMACRO: redefining function NFORMAT ...
Initializing unit arrays... 
Done. 
User defaults found... 
User defaults initialized.
(%i2) kg*m/s^2;
(%o2)                                  N
(%i3) kg*m^2/s^2;
(%o3)                                  J
(%i4) kg*m^3/s^2;
(%o4)                                 J m
(%i5) kg*m*km/s^2;
(%o5)                             (1000) (J)
(%i6) setunits([dyn,eV]);
(%o6)                                done
(%i7) kg*m/s^2;
(%o7)                           (100000) (dyn)
(%i8) kg*m^2/s^2;
(%o8)                     (6241509596477042688) (eV)
(%i9) kg*m^3/s^2;
(%o9)                    (6241509596477042688) (eV m)
(%i10) kg*m*km/s^2;
(%o10)                   (6241509596477042688000) (eV)
(%i11) uforget([dyn,eV]);  
(%o11)                           [false, false]
(%i12) kg*m/s^2;
(%o12)                                 N
(%i13) kg*m^2/s^2;
(%o13)                                 J
(%i14) kg*m^3/s^2;
(%o14)                                J m
(%i15) kg*m*km/s^2;
(%o15)                            (1000) (J)
@end example
Sem @code{usersetunits}, as entradas iniciais poderiam ter sido convertidas
para o sistema de unidades MKS, e @code{uforget} poderia ter resultado em um retorno para as regras do MKS.  Em vez disso,
as preferências do utilizador foram respeitadas em ambos os casos.  Note que esse podem ainda
serem sobrescritos se for desejado.  Para eliminar completamente essa simplificação - i.e.
ter as preferências de utilizador escolhidas para os padrões de unidade do Maxima - o comando
@code{dontusedimension} pode ser usado.  @code{uforget} pode restabelecer as preferências de utilizador novamente, mas
somente se @code{usedimension} liberar isso para uso.  Alternativamente,
@code{kill(usersetunits)} irá remover completametne todo o conhecimento dessas escolhas de utilizador
da sessão actual.  Aqui está alguns exemplos de como esssas várias opções trabalham.
@example
(%i2) kg*m/s^2;
(%o2)                                  N
(%i3) kg*m^2/s^2;
(%o3)                                  J
(%i4) setunits([dyn,eV]);
(%o4)                                done
(%i5) kg*m/s^2;
(%o5)                           (100000) (dyn)
(%i6) kg*m^2/s^2;
(%o6)                     (6241509596477042688) (eV)
(%i7) uforget([dyn,eV]);
(%o7)                          [false, false]
(%i8) kg*m/s^2;
(%o8)                                  N
(%i9) kg*m^2/s^2;
(%o9)                                  J
(%i10) dontusedimension(N);
(%o10)                             [%force]
(%i11) dontusedimension(J);
(%o11)                         [%energy, %force]
(%i12) kg*m/s^2;
                                     kg m
(%o12)                               ----
                                       2
                                      s
(%i13) kg*m^2/s^2;
                                         2
                                     kg m
(%o13)                               -----
                                       2
                                      s
(%i14) setunits([dyn,eV]);
(%o14)                               done
(%i15) kg*m/s^2;
                                     kg m
(%o15)                               ----
                                       2
                                      s
(%i16) kg*m^2/s^2;
                                         2
                                     kg m
(%o16)                               -----
                                       2
                                      s
(%i17) uforget([dyn,eV]);
(%o17)                         [false, false]
(%i18) kg*m/s^2;
                                     kg m
(%o18)                               ----
                                       2
                                      s
(%i19) kg*m^2/s^2;
                                         2
                                     kg m
(%o19)                               -----
                                       2
                                      s
(%i20) usedimension(N);
Done.  To have Maxima simplify to this dimension, use setunits([unit]) 
to select a unit. 
(%o20)                               true
(%i21) usedimension(J);
Done.  To have Maxima simplify to this dimension, use setunits([unit]) 
to select a unit. 
(%o21)                               true
(%i22) kg*m/s^2;
                                     kg m
(%o22)                               ----
                                       2
                                      s
(%i23) kg*m^2/s^2;
                                         2
                                     kg m
(%o23)                               -----
                                       2
                                      s
(%i24) setunits([dyn,eV]);
(%o24)                               done
(%i25) kg*m/s^2;
(%o25)                          (100000) (dyn)
(%i26) kg*m^2/s^2;
(%o26)                    (6241509596477042688) (eV)
(%i27) uforget([dyn,eV]);
(%o27)                           [false, false]
(%i28) kg*m/s^2;
(%o28)                                 N
(%i29) kg*m^2/s^2;
(%o29)                                 J
(%i30) kill(usersetunits);
(%o30)                               done
(%i31) uforget([dyn,eV]);
(%o31)                          [false, false]
(%i32) kg*m/s^2;
                                     kg m
(%o32)                               ----
                                       2
                                      s
(%i33) kg*m^2/s^2;
                                         2
                                     kg m
(%o33)                               -----
                                       2
                                      s
@end example
Desafortunadamente essa ampla variedade de opções é um pouco confus no início,
mas uma vez que o utilizador cultiva o uso delas o utilizador perceberá que elas permitem completo
controle sobre seu ambiente de trabalho.

@c One other significant customization option available is the @code{setunitprefix}
@c command.  Normally, abbreviations used in this package are as close to those
@c used in standard texts as possible.  Some people, however, prefer to use those
@c symbols for normal work and have units labeled in some other fasion. 
@c @code{setunitprefix} is provided for this case.  Here is an example of its use:

@end defvr


@deffn {Função} metricexpandall (@var{x})
Reconstrói listas de unidades globais automaticamente criando todas as unidades métricas desejadas.
@var{x} é um argumento numérico que é usado para especificar quantos prefixos
métricos o utilizador deseja que seja definido.  Os argumentos são os seguintes, com cada
maior número definindo todos os menores números de unidade:
@example
           0 - none. Only base units
           1 - kilo, centi, milli
(default)  2 - giga, mega, kilo, hecto, deka, deci, centi, milli,
               micro, nano
           3 - peta, tera, giga, mega, kilo, hecto, deka, deci,
               centi, milli, micro, nano, pico, femto
           4 - all
@end example
Normalmente, Maxima não irá definir a expansão completa desses resultados em uma
grande número de unidades, mas @code{metricexpandall} pode ser usada para
reconstruir a lista em um estilo mais ou menos completo. A variável relevante
no ficheiro @emph{unit.mac} é @var{%unitexpand}.
@c This should be made configurable as a maxima-init.mac controllable option.
@end deffn

@defvr {Variável} %unitexpand
Valor por omissão: @code{2}

Ess é o valor fornecido a @code{metricexpandall} durante a inicialização
de @emph{unit}.

@end defvr


@c @deffn {Função} functionname (@var{arg1}, @var{arg2}, ..., @var{argn})
@c @end deffn

@c @defvr {Variável de opção} variablename
@c Default value: @code{true}
@c @end defvr


