File: gretl_cli_fnref.pt

package info (click to toggle)
gretl 2022c-1
links: PTS, VCS
area: main
in suites: bookworm
size: 59,552 kB
sloc: ansic: 409,074; sh: 4,449; makefile: 3,222; cpp: 2,777; xml: 599; perl: 364
file content (7102 lines) | stat: -rw-r--r-- 261,700 bytes
## Accessors
# $ahat
Resultado:  série

Deve seguir a estimação de um modelo de dados em painel com efeitos fixos.
Retorna uma série com as estimativas dos efeitos individuais fixos
(interceptos por unidade).

# $aic
Resultado:  escalar

Retorna o Critério de Informação de Akaike do último modelo estimado,
quando disponível. Veja guia de utilização do Gretl (Capítulo 28) para
detalhes sobre os cálculos.

# $bic
Resultado:  escalar

Retorna o Critério de Informação Bayesiano de Schwarz para o último
modelo estimado, quando disponível. Veja guia de utilização do Gretl
(Capítulo 28) para detalhes sobre os cálculos.

# $chisq
Resultado:  escalar

Retorna estatística qui-quadrado global do último modelo estimado, quando
disponível.

# $coeff
Resultado:  matriz ou escalar
Argumento:  s (nome do coeficiente, opcional)

Quando utilizado sem argumentos, $coeff retorna um vetor coluna com os
coeficientes estimados do último modelo. Com o argumento opcional de texto
(string) a função retorna, na forma de um escalar, o parâmetro estimado
s. Ver também"$stderr", "$vcv".

Exemplo:

	  open bjg
	  arima 0 1 1 ; 0 1 1 ; lg
	  b = $coeff               # fornece um vetor
	  macoef = $coeff(theta_1) # fornece um escalar

Se o "modelo" em questão for um sistema, o resultado dependerá das
características do sistema: para VARs e VECMs o valor retornado será uma
matriz com uma coluna por equação, caso contrário será um vetor coluna
contendo os coeficientes da primeira equação seguidos pelos coeficientes
da segunda equação e assim sucessivamente.

# $command
Resultado:  texto

Deve ser utilizada após a estimação de um modelo e retorna o seu tipo,
por exemplo ols ou probit.

# $compan
Resultado:  matriz

Deve ser utilizada após a estimação de um VAR ou um VECM e retorna a
matriz companheira.

# $datatype
Resultado:  escalar

Retorna um número representando o tipo dos dados que estão sendo
atualmente utilizados: 0 = sem dados, 1 = dados de corte transversal (não
datados), 2 = dados de séries temporais, 3 = dados em painel.

# $depvar
Resultado:  texto

Deve ser utilizada após a estimação de um modelo com equação única e
retorna o nome da variável dependente.

# $df
Resultado:  escalar

Retorna os graus de liberdade do último modelo estimado. Se o último
modelo for um sistema de equações, o valor retornado será o número de
graus de liberdade por equação. Se os graus de liberdade das equações
forem diferentes então o valor dado será calculado como a diferença entre
o número de observações e a média do número de coeficientes por
equação (essa média será arredondada para o valor inteiro imediatamente
superior).

# $diagpval
Resultado:  escalar

Deve ser utilizada após a estimação de um sistema de equações e retorna
o P-valor associado com a estatística "$diagtest".

# $diagtest
Resultado:  escalar

Deve ser utilizada após a estimação de um sistema de equações. Retorna
a estatística de teste para a hipótese nula de que a matriz de
covariâncias dos resíduos das equações do sistema é diagonal. Este é o
teste de Breusch-Pagan, exceto quando o estimador for o SUR iterado
(irrestrito), nesse caso será um teste de razão de verossimilhança. Veja
guia de utilização do Gretl (Capítulo 34) para detalhes e também
"$diagpval".

# $dotdir
Resultado:  texto

Este acessor retorna o caminho onde Gretl guarda os ficheiros temporários,
por exemplo quando se usa a função "mwrite" com um argumento não-nulo.

# $dw
Resultado:  escalar

Retorna a estatística de Durbin-Watson para a correlação de primeira
ordem do último modelo estimado (quando disponível).

# $dwpval
Resultado:  escalar

Retorna o p-valor para a estatística de Durbin-Watson do último modelo
estimado (quando disponível). É calculada via procedimento de Imhof.

Devido à precisão limitada da aritmética computacional, a integral de
Imhof pode se tornar negativa quando a estatística de Durbin-Watson estiver
próxima de seu limite inferior. Nesse caso a função de acesso retorna NA.
Uma vez que qualquer outra falha será sinalizada, é possivelmente seguro
assumir que um resultado NA indica que o verdadeiro p-valor é "muito
pequeno", embora não seja possível quantificá-lo.

# $ec
Resultado:  matriz

Deve ser utilizada após a estimação de um VECM e retorna uma matriz
contendo os termos de correção de erros. O número de linhas é igual ao
número de observações utilizadas e o número de colunas é igual à ordem
de cointegração do sistema.

# $error
Resultado:  escalar

Retorna o código interno de erro do programa. Esse código será um valor
não-nulo quando a função "catch" tiver sido utilizada. Note que o código
interno de erro irá retornar para zero quando esta função de acesso for
utilizada novamente. Para consultar, posteriormente, a mensagem de erro
associada a um dado $error será necessário armazená-la em uma variável.
Isso pode ser feito da seguinte forma:

	  err = $error
	  if (err)
	      printf "Got error %d (%s)\n", err, errmsg(err);
	  endif

Ver também"catch", "errmsg".

# $ess
Resultado:  escalar

Retorna o erro da soma dos quadrados do último modelo estimado, quando
disponível.

# $evals
Resultado:  matriz

Deve ser utilizada após a estimação de um VECM e retorna um vetor
contendo os autovalores que foram utilizados no cálculo do teste traço
para verificação da cointegração.

# $fcast
Resultado:  matriz

Deve ser utilizada após o comando "fcast" e retorna os valores previstos na
forma de uma matriz. Se foi utilizado um sistema de equações para realizar
as previsões a matriz será composta por uma coluna para cada equação,
caso contrário será um vetor coluna.

# $fcse
Resultado:  matriz

Deve ser utilizada após o comando "fcast" e retorna os erros padrão das
previsões, quando disponíveis, na forma de uma matriz. Se foi utilizado um
sistema de equações para realizar as previsões a matriz será composta
por uma coluna para cada equação, caso contrário será um vetor coluna.

# $fevd
Resultado:  matriz

Deve ser utilizada após a estimação de um VAR e retorna uma matriz
contendo a decomposição da variância dos erros de previsão (FEVD, na
sigla em inglês). Essa matriz possui h linhas, onde h indica a quantidade
de períodos do horizonte de previsão que, por sua vez, pode ser escolhida
via comando set horizon ou de forma automática com base na frequência dos
dados.

Para um VAR com p variáveis, a matriz possui p ^2 colunas: as primeiras p
colunas contêm a FEVD para a primeira variável do VAR, as p colunas
seguintes contêm a FEVD para a segunda variável do VAR e assim
sucessivamente. A fração (em termos decimais) do erro de previsão da
variável i causado por uma inovação na variável j é então encontrado
na coluna (i - 1) p + j.

Para uma variante mais flexível desta funcionalidade, ver a função
"fevd".

# $Fstat
Resultado:  escalar

Retorna estatística F global do último modelo estimado, quando
disponível.

# $gmmcrit
Resultado:  escalar

Deve ser utilizada após um bloco gmm. Retorna o valor da função objetivo
GMM em seu mínimo.

# $h
Resultado:  série

Deve ser utilizada após o comando garch. Retorna a série da variância
condicional estimada.

# $hausman
Resultado:  vetor linha

Deve ser utilizada após a estimação de um modelo via tsls ou panel com a
opção de efeitos aleatórios. Retorna um vetor 1 x 3 contendo o valor da
estatística do teste de Hausman, os graus de liberdade correspondentes e o
p-valor para o teste, respectivamente.

# $hqc
Resultado:  escalar

Retorna o Critério de Informação de Hannan-Quinn para o último modelo
estimado, quando disponível. Veja guia de utilização do Gretl (Capítulo
28) para detalhes sobre os cálculos.

# $huge
Resultado:  escalar

Retorna um número positivo com valor bastante elevado. Por padrão é igual
a 1.0E100, mas pode ser alterado via comando "set".

# $jalpha
Resultado:  matriz

Deve ser utilizada após a estimação de um VECM e retorna a matriz de
cargas. O número de linhas dessa matriz é igual ao número de variáveis
do VECM e o número de colunas é igual a ordem de cointegração.

# $jbeta
Resultado:  matriz

Deve ser utilizada após a estimação de um VECM e retorna a matriz de
cointegração. O número de linhas dessa matriz é igual ao número de
variáveis no VECM (se existirem variáveis exógenas restritas ao espaço
de cointegração adiciona-se mais uma linha) e o número de colunas é
igual a ordem de cointegração.

# $jvbeta
Resultado:  matriz quadrada

Deve ser utilizada após a estimação de um VECM e retorna a matriz de
covariâncias estimada para os elementos dos vetores de cointegração.

No caso de uma estimação sem restrições, o número de linhas dessa
matriz é igual ao número de elementos irrestritos do espaço de
cointegração após a normalização de Phillips. Entretanto, se for
estimado um sistema restrito via comando restrict com a opção --full, uma
matriz singular com (n+m)r linhas será retornada (sendo n o número de
variáveis endógenas, m o número de variáveis exógenas restritas ao
espaço de cointegração e r a ordem de cointegração).

Exemplo: o código

	  open denmark.gdt
	  vecm 2 1 LRM LRY IBO IDE --rc --seasonals -q
	  s0 = $jvbeta

	  restrict --full
	    b[1,1] = 1
	    b[1,2] = -1
	    b[1,3] + b[1,4] = 0
	  end restrict
	  s1 = $jvbeta

	  print s0
	  print s1

produz a seguinte saída.

	  s0 (4 x 4)

          0.019751     0.029816  -0.00044837     -0.12227
          0.029816      0.31005     -0.45823     -0.18526
	   -0.00044837     -0.45823       1.2169    -0.035437
          -0.12227     -0.18526    -0.035437      0.76062

	  s1 (5 x 5)

	  0.0000       0.0000       0.0000       0.0000       0.0000
	  0.0000       0.0000       0.0000       0.0000       0.0000
	  0.0000       0.0000      0.27398     -0.27398    -0.019059
	  0.0000       0.0000     -0.27398      0.27398     0.019059
	  0.0000       0.0000    -0.019059     0.019059    0.0014180

# $lang
Resultado:  texto

Retorna o texto (string) com o código do idioma que está sendo utilizado
no momento, desde que este possa ser determinado. O texto é composto pelo
código ISO 639-1 com duas letras (por exemplo, en para inglês, jp para
japonês, el para grego) seguido de um sublinhado e o código do país de
acordo com o ISO 3166-1. Assim, por exemplo, o português de Portugal é
representado por pt_PT enquanto o português do Brasil é representado por
pt_BR.

Se o idioma não puder ser determinado será retornado o texto "unknown".

# $llt
Resultado:  série

Para determinados modelos estimados via Máxima Verossimilhança a função
retorna os valores do log da verossimilhança para cada observação.
Atualmente essa função está disponível para logit e probit binários,
tobit e heckit.

# $lnl
Resultado:  escalar

Retorna a log-verossimilhança para o último modelo estimado (quando for
aplicável).

# $macheps
Resultado:  escalar

Retorna o valor do "épsilon da máquina" que, por sua vez, fornece um
limite superior para o erro relativo devido ao arredondamento na aritmética
de ponto flutuante com precisão dupla.

# $mapfile
Resultado:  texto

Se tiver sido carregado dados de um ficheiro de formas GeoJSON ou ESRI,
retorna o nome do ficheiro que deve obter o mapa de polígonos, caso
contrário retorna uma cadeia de texto vazia. Isto está preparado para ser
usado com a função "geoplot".

# $mnlprobs
Resultado:  matriz

Deve seguir a estimação de um modelo logit multinomial (apenas) e retorna
uma matriz com as probabilidades estimadas para cada resultado possível em
cada observação dentro da amostra utilizada na estimação do modelo. Cada
linha representa uma observação e cada coluna representa um resultado.

# $model
Resultado:  lote

Deve seguir a estimação de modelos de equação única e retorna um pacote
(bundle) contendo vários itens pertencentes ao modelo. Todas as funções
de acesso de modelos regulares são incluídas e são referenciados por
chaves iguais aos nomes das funções de acesso regulares menos o cifrão
inicial. Assim, por exemplo, os resíduos aparecem sob a chave uhat e o
quadrado da soma dos erros sob ess.

Dependendo do estimador, informações adicionais podem ser
disponibilizadas. As chaves para tais informações são normalmente
auto-explicativas. Para ver o que está disponível basta salvar o pacote e
imprimir seu conteúdo. Isso é mostrado no exemplo a seguir:

	  ols y 0 x
	  bundle b = $model
	  print b

# $mpirank
Resultado:  número inteiro

Se gretl foi compilado com suporte MPI, e o programa foi iniciado em modo
MPI, retorna o "posto" de base 0 o ID do processo actual. Caso contrário
retorna -1.

# $mpisize
Resultado:  número inteiro

Se gretl foi compilado com suporte MPI, e o programa foi iniciado em modo
MPI, retorna o número do processo MPi actualmente em execução. Caso
contrário retorna 0.

# $ncoeff
Resultado:  número inteiro

Retorna o número total de coeficientes estimados no último modelo.

# $nobs
Resultado:  número inteiro

Retorna o número de observações na amostra atualmente selecionada. Veja
também: "$tmax".

# $now
Resultado:  vetor

Produz um vector de dois elementos: o primeiro elemento é o número de
segundos decorridos desde1970-01-01 00:00:00 +0000 (UTC), que é uma medida
utilizada muito frequentemente no mundo da informatica para representar a
hora. O segundo é a data actual no formato "básico" ISO 8601, que é
YYYYMMDD; para processar o segundo elemento pode-se usar a função
"epochday".

# $nvars
Resultado:  número inteiro

Retorna o número de variáveis no conjunto de dados (incluindo a
constante).

# $obsdate
Resultado:  série

Deve ser utilizada quando o conjunto de dados corrente for composto por
séries temporais com frequência decenal, anual, trimestral, mensal,
semanal (datada) ou diária (datada). Pode ser utilizada também com dados
em painel quando a informação temporal estiver ajustada corretamente (veja
o comando "setobs"). A série que será retornada é composta por números
com 8 dígitos seguindo o padrão YYYYMMDD (formato de dados "básico" do
ISO 8601), que correspondem ao dia da observação ou ao primeiro dia da
observação no caso de frequências de séries temporais menores que a
diária.

Esta série pode ser útil na utilização do comando "join".

# $obsmajor
Resultado:  série

É aplicável quando as observações no conjunto de dados corrente têm uma
estrutura maior:menor, como em séries temporais trimestrais
(ano:trimestre), séries temporais mensais (ano:mês), dados de horas
(dia:hora) e dados em painel (indivíduo:período). Retorna uma série
contendo o componente maior, ou de menor frequência, de cada observação
(por exemplo, o ano).

Ver também"$obsminor", "$obsmicro".

# $obsmicro
Resultado:  série

É aplicável quando as observações no conjunto de dados corrente têm uma
estrutura maior:menor:micro, como em séries temporais datadas diárias
(ano:mês:dia). Retorna uma série contendo o componente micro, ou de maior
frequência, de cada observação (por exemplo, o dia).

Ver também"$obsmajor", "$obsminor".

# $obsminor
Resultado:  série

É aplicável quando as observações no conjunto de dados corrente têm uma
estrutura maior:menor, como em séries temporais trimestrais
(ano:trimestre), séries temporais mensais (ano:mês), dados de horas
(dia:hora) e dados em painel (indivíduo:período). Retorna uma série
contendo o componente menor, ou de maior frequência, de cada observação
(por exemplo, o mês).

No caso de dados diários datados, $obsminor retorna o mês de cada
observação.

Ver também"$obsmajor", "$obsmicro".

# $parnames
Resultado:  cadeia de texto

Depois da estimação de um modelo de uma só equação, produz um vector de
texto contendo os nomes dos parâmetros do modelo. Os números do nomes
correspondem ao número dos elementos no vector "$coeff" .

Para modelos especificados com uma lista de regressores o resultado será o
mesmo que

	  varnames($xlist)

(ver "varnames"), mas $parnames é mais geral, pois que funciona também com
modelos sem lista de regressores ("nls", "mle", "gmm").

# $pd
Resultado:  número inteiro

Retorna a frequência ou periodicidade dos dados (por exemplo: 4 para dados
trimestrais). No caso de dados em painel o valor retornado será a
quantidade de períodos de tempo no conjunto de dados.

# $pi
Resultado:  escalar

Retorna o valor de pi com dupla precisão.

# $pkgdir
Resultado:  texto

Uma ferramenta especial para ser usada por autores de pacotes de funções.
Retorna uma cadeia de texto vazia se não estiver em execução, e se
estiver, retorna o caminho completo (de acordo com a plataforma) de onde o
pacote está instalado. Por exemplo, o valor retornado pode ser:

	  /usr/share/gretl/functions/foo

se for essa a directoria onde foo.gfn estiver localizado. Isto permite
escritores de pacotes aceder a recursos como sejam ficheiros de matrizes que
tenham sido incluidos nos seus pacotes.

# $pvalue
Resultado:  escalar ou matriz

Retorna o p-valor da estatística de teste que foi gerada pelo último
comando explícito de teste de hipóteses (por exemplo: chow). Veja guia de
utilização do Gretl (Capítulo 10) para detalhes.

Geralmente retorna um escalar, mas em alguns casos retorna uma matriz. Isso
ocorre, por exemplo, com os p-valores dos testes lambda traço e lambda
máximo associadas ao teste de cointegração de Johansen). Nesse caso os
valores na matriz estarão dispostos da mesma forma que na saída do teste.

Ver também"$test".

# $qlrbreak
Resultado:  escalar

Deve ser utilizada após o comando "qlrtest" (que realiza o teste QLR para
quebra estrutural em um ponto desconhecido. Retorna o número da
observação no qual a estatística de teste é maximizada.

# $result
Resultado:  matriz ou bundle

Fornece a informação armazenada de alguns comandos que não têm acessores
específicos. Tais comandos incluem "corr", "fractint", "freq", "summary",
"xtab", "vif" e "bkw" ; neste caso o resultado é uma matriz, e ainda "pkg",
que opcionalmente guarda como um resultado bundle.

# $rho
Resultado:  escalar
Argumento:  n (escalar, opcional)

Se for utilizada sem argumentos a função retorna o coeficiente
autorregressivo de primeira ordem para os resíduos do último modelo. Após
a estimação de um modelo via comando ar, a sintaxe $rho(n) retorna a
estimativa correspondente de rho(n).

# $rsq
Resultado:  escalar

Retorna o R^2 não ajustado do último modelo estimado, quando disponível.

# $sample
Resultado:  série

Deve ser utilizada após a estimação de um modelo com equação simples e
retorna uma variável dummy com valores iguais a 1 nas observações
utilizadas na estimação, 0 nas observações na amostra corrente e que
não foram utilizadas na estimação (possivelmente devido a valores
ausentes) e NA nas observações fora da amostra selecionada corrente.

Caso se queira calcular estatísticas baseadas na amostra que foi utilizada
para um dado modelo, pode-se fazer, por exemplo:

	  ols y 0 xlist
	  genr sdum = $sample
	  smpl sdum --dummy

# $sargan
Resultado:  vetor linha

Deve ser utilizada após o comando tsls. Retorna um vetor 1 x 3 contendo a
estatística do teste de sobre-identificação de Sargan e os
correspondentes graus de liberdade e p-valor, respectivamente. Se o modelo
for exatamente identificado a estatística não estará disponível e tentar
acessá-la irá provocar um erro.

# $seed
Resultado:  escalar

Retorna o valor com que o gerador de números aleatórios de gretl foi
inicializado ("semeado"). Se tiver sido definido por você, então não há
necessidade de usar este acessor, mas pode ser de interesse se a "semente"
tiver sido inicializada automaticamente (baseado no tempo em que o programa
foi iniciado).

# $sigma
Resultado:  escalar ou matriz

Se o último modelo estimado foi uma equação simples, retorna o erro
padrão da regressão na forma de um escalar (ou, em outras palavras,
retorna o desvio padrão dos resíduos com uma correção apropriada de
graus de liberdade). Se o último modelo foi um sistema de equações,
retorna a matriz de covariâncias dos resíduos das equações do sistema.

# $stderr
Resultado:  matriz ou escalar
Argumento:  s (nome do coeficiente, opcional)

Quando utilizado sem argumentos, $stderr retorna um vetor coluna com os
erros padrão dos coeficientes do último modelo estimado. Com o argumento
opcional de texto (string) a função retorna, na forma de um escalar, o
parâmetro estimado s.

Se o "modelo" um sistema, o resultado dependerá de suas características:
para VARs e VECMs o valor retornado será uma matriz contendo uma coluna
para cada equação, caso contrário, será um vetor coluna contendo os
coeficientes da primeira equação seguidos pelos coeficientes da segunda
equação e assim sucessivamente.

Ver também"$coeff", "$vcv".

# $stopwatch
Resultado:  escalar

Deve ser precedida pelo comando set stopwatch que, por sua vez, ativa a
medição de tempo da CPU. Na primeira utilização da função de acesso
obtém-se a quantidade de segundos que se passaram desde o comando set
stopwatch. A cada acesso o relógio será reiniciado de forma que as
utilizações subsequentes de $stopwatch irão fornecer os segundos da CPU
entre as duas utilizações.

# $sysA
Resultado:  matriz

Deve ser utilizada após a estimação de um sistema de equações
simultâneas. Retorna a matriz com os coeficientes das variáveis endógenas
defasadas, caso existam, na forma estrutural do sistema. Veja o comando
"system".

# $sysB
Resultado:  matriz

Deve ser utilizada após a estimação de um sistema de equações
simultâneas. Retorna a matriz com os coeficientes das variáveis exógenas
na forma estrutural do sistema. Veja o comando "system".

# $sysGamma
Resultado:  matriz

Deve ser utilizada após a estimação de um sistema de equações
simultâneas. Retorna a matriz com os coeficientes das variáveis endógenas
contemporâneas na forma estrutural do sistema. Veja o comando "system".

# $sysinfo
Resultado:  lote

Retorna um pacote (bundle) contendo informações sobre o Gretl e o sistema
operacional onde está sendo executado. O elementos do pacote são
especificados a seguir.

  mpi: inteiro, igual a 1 se o sistema suporta MPI (Message Passing
  Interface), caso contrário 0.

  omp: inteiro, igual a 1 se o Gretl foi compilado com suporte a Open MP,
  caso contrário 0.

  nproc: inteiro, indica o número de processadores disponíveis.

  mpimax: inteiro, indica o número máximo de processos MPI que podem ser
  executados em paralelo. É igual a zero se não houver suporte para MPI,
  caso contrário é igual ao valor de nproc local. Se for especificado um
  arquivo de hosts MPI, mpimax será igual a soma do número de
  processadores ou "slots" ao longo de todas a máquinas referenciadas no
  arquivo.

  wordlen: inteiro, igual a 32 ou 64 para sistemas de 32 bit e 64,
  respectivamente.

  os: texto representando o sistema operacional e é igual a linux, macos,
  windows ou other.

  hostname: informa o nome da máquina (ou "host") onde o Gretl está sendo
  executado no momento. Se não for possível determinar o nome, será
  retornado o localhost.

Note que elementos individuais no pacote podem ser acessados via
utilização da notação "dot" sem a necessidade de copiar o pacote
inteiro. Por exemplo,

	  if $sysinfo.os == "linux"
	      # faça alguma coisa que seja própria do Linux
	  endif

# $system
Resultado:  lote

Deve seguir a estimação de um sistema de equações via comandos "system",
"var" ou "vecm". Retorna um pacote (bundle) contendo os ítems que fazem
parte do sistema. Todas as funções de acesso regulares são incluídas:
estas estão referenciadas de acordo com indicadores que são iguais aos
nomes de acesso regular, sem utilizar o símbolo cifrão. Por exemplo, os
resíduos aparecem sob o indicador uhat e os coeficientes sob coeff. Os os
indicadores para as informações adicionais deverão ser auto-explicativos.
Para verificar quais estão disponíveis pode-se exibir os conteúdos do
pacote. Exemplo:

	  var 4 y1 y2 y2
	  bundle b = $system
	  print b

Um pacote definido dessa forma pode ser utilizado como o argumento final
(que é opcional) nas funções "fevd" e "irf".

# $T
Resultado:  número inteiro

Retorna o número de observações utilizadas na estimação do último
modelo.

# $t1
Resultado:  número inteiro

Retorna o número da primeira observação na amostra selecionada corrente.

# $t2
Resultado:  número inteiro

Retorna o número da última observação na amostra selecionada corrente.

# $test
Resultado:  escalar ou matriz

Retorna o valor da estatística de teste que foi gerada pelo último comando
explícito de teste de hipóteses (por exemplo: chow). Veja guia de
utilização do Gretl (Capítulo 10) para detalhes.

Geralmente retorna um escalar, mas em alguns casos retorna uma matriz. Isso
ocorre, por exemplo, com as estatísticas lambda traço e lambda máximo
associadas ao teste de cointegração de Johansen). Nesse caso os valores na
matriz estarão dispostos da mesma forma que na saída do teste.

Ver também"$pvalue".

# $tmax
Resultado:  número inteiro

Devolve o máximo valor possível para indicar o fim do intervalo de uma
amostra alterada com o comando "smpl". Na maior parte das vezes, isto vai
ser igual ao número de observações do conjunto de dados, mas numa
função em Hansl, o valor $tmax pode ser menor, pois em geral o acesso aos
dados a partir do interior de funções está limitado ao intervalo amostral
definido pela função chamadora.

Notar que, em geral, o $tmax não é igual a "$nobs", que indica número de
observações do intervalo da amostra actual.

# $trsq
Resultado:  escalar

Retorna TR^2 (tamanho da amostra multiplicado pelo R-quadrado) do último
modelo, quando disponível.

# $uhat
Resultado:  série

Retorna os resíduos do último modelo. Isto pode ter diferentes
significados a depender dos estimadores utilizados. Por exemplo, após a
estimação de um ARMA $uhat irá conter os erros de previsão de 1 passo à
frente, após a estimação de um probit irá conter os resíduos
generalizados.

Se o "modelo" em questão for um sistema (um VAR, um VECM ou um sistema de
equações simultâneas), o $uhat sem parâmetros fornece a matriz de
resíduos, uma coluna por equação.

# $unit
Resultado:  série

Vale apenas para dados de painel. Retorna uma série com valor igual a 1 em
todas as observações na primeira unidade ou grupo, 2 em todas as
observações na segunda unidade ou grupo e assim sucessivamente.

# $vcv
Resultado:  matriz ou escalar
Argumentos: s1 (nome do coeficiente, opcional)
            s2 (nome do coeficiente, opcional)

Quando utilizado sem argumentos, $vcv retorna uma matriz contendo a matriz
de covariâncias estimadas para os coeficientes do último modelo. Se o
último modelo foi uma equação simples, então é possível fornecer os
nomes dos dois parâmetros entre parênteses para se obter a covariância
estimada entre s1 e s2. Ver também"$coeff", "$stderr".

Este acessor não está disponível para VARs ou VECMs. Para modelos desse
tipo "$sigma" e "$xtxinv".

# $vecGamma
Resultado:  matriz

Deve ser utilizada após a estimação de um VECM e retorna uma matriz na
qual as matrizes Gama (coeficientes das diferenças defasadas das variáveis
cointegradas) são empilhadas lado a lado. Cada linha representa uma
equação. Para um VECM de ordem p existem p - 1 sub-matrizes.

# $version
Resultado:  escalar

Retorna um valor inteiro que identifica a versão do Gretl. Atualmente a
versão do Gretl é composta por um texto com o seguinte formato: ano, com 4
dígitos, seguido de uma letra, de a até j, representando as atualizações
dentro desse ano (por exemplo, 2015d). O valor retornado por essa função
é igual ao ano multiplicado por 10 e adicionado de um número
representando, em ordem léxica, a letra. Assim, 2015d seria representado
por 20153.

Em versões anteriores ao Gretl 2015d, o identificador possuia a seguinte
forma: x.y.z (três inteiros separados por pontos) e o valor da função era
calculado como 10000*x + 100*y + z . Assim, por exemplo, a versão 1.10.2
era traduzida como 11002. Note que dessa forma a ordem numérica de $version
foi preservada mesmo com a mudança no esquema de versões.

# $vma
Resultado:  matriz

Deve ser utilizada após a estimação de um VAR ou um VECM e retorna uma
matriz contendo a representação VMA até a ordem especificada via comando
set horizon. Veja guia de utilização do Gretl (Capítulo 32) para
detalhes.

# $windows
Resultado:  número inteiro

Retorna o valor 1 se o Gretl estiver sendo utilizado no Windows e 0 caso
contrário. Através dessa função é possível utilizar comandos "shell"
em scripts que possam ser executados em diferentes sistemas operacionais.

Veja também o comando "shell".

# $workdir
Resultado:  texto

Este acessor retorna o caminho por defeito onde Gretl lê e escreve os
ficheiros. Uma descrição mais detalhada pode ser encontrada no Guia de
Referência dos Comandos em "workdir".Note-se que esta variável pode ser
alterada por meio do comando "set".

# $xlist
Resultado:  lista

Se o último modelo estimado foi um equação simples a função retorna uma
lista com os regressores. Se o último modelo foi um sistema de equações
ela retorna uma lista "global" com as variáveis exógenas e predeterminadas
(na mesma ordem que aparecem na função "$sysB"). Se o último modelo foi
um VAR ela retorna uma lista com os regressores exógenos, caso existam.

# $xtxinv
Resultado:  matriz

Após a estimação de um VAR ou VECM (apenas), retorna X'X^-1, onde X é a
matriz comum de regressores utilizados em cada equação. Essa função de
acesso não está disponível para VECMs estimados com restrições impostas
na matriz de cargas(α).

# $yhat
Resultado:  série

Retorna os valores ajustados da última regressão.

# $ylist
Resultado:  lista

Se o último modelo estimado foi um VAR, um VECM ou um sistema de equações
simultâneas a função retorna uma lista com as variáveis endógenas. Se o
último modelo foi uma equação simples a função de acesso retorna uma
lista com apenas um elemento, a variável dependente. No caso especial do
modelo biprobit a lista irá conter dois elementos.

## Functions proper
# abs
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o valor absoluto de x.

# acos
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o arco-cosseno de x, isto é, o valor cujo cosseno é x. Resultado
em radianos e o argumento deve estar entre -1 e 1.

# acosh
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o cosseno hiperbólico inverso de x (solução positiva). x deve ser
maior que 1, caso contrário a função retornará NA. Ver também"cosh".

# aggregate
Resultado:  matriz
Argumentos: x (série ou lista)
            byvar (série ou lista)
            funcname (texto, opcional)

Na forma mais simples de uso, x é igual a null, byvar é uma séries
individual e o terceiro argumento é omitido. Neste caso é retornada uma
matriz com duas colunas contendo na primeira coluna os valores distintos de
byvar, ordenados de forma crescente, e na segunda a quantidade de
observações de byvar para cada um dos valores distintos. Por exemplo,

	  open data4-1
	  eval aggregate(null, bedrms)

mostrará que a serie bedrms tem valores 3 (num total de 5 vezes) e 4 (num
total de 9 vezes).

Se x e byvar são ambas séries individuais, e é indicado um terceiro
argumento, o valor retornado é uma matriz com três colunas contendo,
respectivamente, os valores distintos de byvar, por ordem crescente; a
contagem das observações em que o byvar toma em cada um desses valores; e
os valores da estatística especificada por funcname calculada na série x,
usando apenas aquelas observações nas quais byvar tem valor igual aos
dados na primeira coluna.

Mais geralmente, se byvar for uma lista com n membros então as n colunas a
esquerda contêm as combinações dos valores distintos de cada uma das n
séries e a coluna de contagem contém o número de observações nas quais
cada combinação é feita. Se x for uma lista com m membros então as m
colunas mais a direita contêm os valores da estatística especificada para
cada uma das x variáveis, novamente calculadas na subamostra indicada na(s)
primeira(s) coluna(s).

Os seguintes valores de funcname são suportados de forma "nativa": "sum",
"sumall", "mean", "sd", "var", "sst", "skewness", "kurtosis", "min", "max",
"median", "nobs" e "gini". Cada uma dessas funções utiliza uma série como
argumento e retorna um valor escalar e, nesse sentido, pode-se dizer que
"agregam" a série de alguma forma. É possível utilizar uma função
definida pelo usuário como um agregador. Da mesma forma que as funções
nativas, tal função deve ter como argumento apenas uma única série e
retornar um valor escalar.

Note que apesar de a contagem de casos ser realizada de forma automática
pela função nobs, a função aggregate não é redundante como uma
agregadora, uma vez que fornece o número de observações válidas (não
ausentes) em x em cada combinação byvar.

Para exemplificar isso, suponha que region representa um código de uma
região geográfica usando valores inteiros de 1 até n e income representa
a renda doméstica. Então o cálculo a seguir deverá produzir uma matriz
de ordem n x 3 contendo os códigos das regiões, a contagem de
observações em cada região e a renda média doméstica para cada uma das
regiões:

	  matrix m = aggregate(income, region, mean)

Para um exemplo usando listas, seja gender uma variável dummy macho/fêmea,
seja race uma variável categórica com três valores e considere o seguinte
código:

	  list BY = gender race
	  list X = income age
	  matrix m = aggregate(X, BY, sd)

A utilização de aggregate produzirá uma matriz de ordem 6 x 5. As
primeiras duas colunas contêm as 6 distintas combinações dos valores de
gênero e raça. A coluna do meio contém a contagem para cada uma dessas
combinações. As duas colunas mais à direita contêm os desvios padrão
amostrais de income e age.

Note que se byvar for uma lista, algumas combinações dos valores de byvar
podem não estar presentes nos dados (fornecendo uma contagem igual a zero).
Nesse caso os valores das estatísticas para x são considerados como NaN
(ou seja, não são números). Caso seja desejado ignorar esses casos é
possível utilizar a função "selifr" para selecionar apenas aquelas linhas
que não possuam uma contagem igual a zero. A coluna a ser testada estará
uma posição à direita após o número de variáveis de byvar, assim,
pode-se utilizar o seguinte código:

	  matrix m = aggregate(X, BY, sd)
	  scalar c = nelem(BY)
	  m = selifr(m, m[,c+1])

# argname
Resultado:  texto
Argumento:  s (texto)

Seja s o nome de um parâmetro de uma função definida pelo usuário,
retorna o nome do argumento correspondente ou uma variável de texto
(string) vazia se o argumento for anônimo.

# array
Resultado:  ver abaixo
Argumento:  n (número inteiro)

É a função "construtora" básica de uma nova variável do tipo arranjo
(array). Ao usar esta função é necessário que se especifique um tipo (na
forma plural) para o arranjo: strings, matrices, bundles ou lists. O valor
de retorno é um arranjo do tipo especificado e com n elementos "vazios"
(exemplos: variável de texto/string vazia ou matriz nula). Exemplos de
utilização:

	  strings S = array(5)
	  matrices M = array(3)

Veja também "defarray".

# asin
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o arco-seno de x, isto é, o valor cujo seno é x. Resultado em
radianos e o argumento deve estar entre -1 e 1.

# asinh
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o seno hiperbólico inverso de x. Ver também"sinh".

# assert
Resultado:  escalar
Argumento:  expr (escalar)

Esta função serve para testar ou despistar erros no código hansl. O
argumento deve ser uma expressão escalar. O valor retornado é 1 se expr
retorna um valor não-zero (o valor booleano "verdadeiro", ou "sucesso") ou
0 se a expressão é zero (o valor booleano "falso", ou "insucesso").

Por defeito, não há consequências se assert falhar, para além do valor
retornado ser zero. No entanto o comando "set" pode ser usado para fazer com
que uma falha da verificação seja mais consequente. Existem dois níveis:

	  # mostra uma mensagem de aviso mas continua a execução
	  set assert warn
	  # mostra uma mensagem de erro e interrompe a execução
	  set assert stop

O comportamento padrão pode ser restaurado com o comando

	  set assert off

Como simples exemplo, se num certo ponto no script hansl um escalar x ser
sempre não-negativo, este código controlará esta condição e terminará
se ela não for satisfeita:

	  set assert stop
	  assert(x >= 0)

# atan
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o arco-tangente de x, isto é, o valor cuja tangente é x. Resultado
em radianos. Ver também"cos", "sin", "tan".

# atan2
Resultado:  o mesmo tipo que o argumento
Argumentos: y (escalar, série ou matriz)
            x (escalar, série ou matriz)

Retorna o valor principal do arco-tangente de y/x, usando os sinais dos dois
argumentos para determinar o quadrante do resultado, que é expresso em
radianos, dentro do intervalo [-pi, pi].

Se os dois argumentos forem de tipos diferentes, o resultado é do tipo
"mais alto" dos dois, seguindo a ordem, matriz > série > escalar. Por
exemlo, se y é um escalar e x um vector de n elementos (ou viceversa), o
resultado é também um vector. Note-se que os argumentos matriciais deverem
ser vectores, e que se nenhum deles for escalar, devem ter a mesma
dimensão.

Ver também"tan", "tanh".

# atanh
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a tangente hiperbólica inversa de x. Ver também"tanh".

# atof
Resultado:  escalar
Argumento:  s (texto)

Função semelhante à existente na linguagem de programação C, retorna o
resultado da conversão da variável de texto (string) s (ou sua porção
inicial, após descartar quaisquer espaços em branco no seu início) em
número de ponto flutuante. Diferente do que ocorre na linguagem C, a
função atof (por questões de portabilidade) sempre assume que o caractere
decimal é o ".". Todos os caracteres que se seguem após a parte de s que
pode ser convertida para um número de ponto flutuante são ignorados.

Se nenhum dos caracteres de s (que se seguem após os espaços em branco que
são descartados) puderem ser convertidos a função retornará NA.

	  # Exemplos:
	  x = atof("1.234") # retorna x = 1.234
	  x = atof("1,234") # retorna x = 1
	  x = atof("1.2y")  # retorna x = 1.2
	  x = atof("y")     # retorna x = NA
	  x = atof(",234")  # retorna x = NA

Veja também "sscanf" para maior flexibilidade nas conversões de textos em
números.

# bessel
Resultado:  o mesmo tipo que o argumento
Argumentos: type (caractere)
            v (escalar)
            x (escalar, série ou matriz)

Calcula uma das variantes da função de Bessel de ordem v e argumento x. O
valor retornado será do mesmo tipo de x. A função específica é
selecionada pelo primeiro argumento e deve ser J, Y, I ou K. Uma boa
discussão sobre as funções de Bessel pode ser encontrada na Wikipédia.
Aqui serão feitos comentários breves.

caso J: função de Bessel de primeiro tipo. Se assemelha a uma onda
senoidal amortecida. Definida para v real e x. Se x for negativo então v
deve ser um inteiro.

caso Y: função de Bessel de segundo tipo. Definida para v real e x, mas
com uma singularidade em x = 0.

caso I: função de Bessel modificada de primeiro tipo. Uma função com
crescimento exponencial. Argumentos que podem ser usados são os mesmos do
caso J.

caso K: função de Bessel modificada de segundo tipo. Uma função com
decaimento exponencial. Diverge em x = 0 e não é definida para valores
negativos de x. É simétrica em torno de v = 0.

# BFGSmax
Resultado:  escalar
Argumentos: &b (referência a matriz)
            f (chamada a função)
            g (chamada a função, opcional)

Realiza a maximização numérica via método de Broyden, Fletcher, Goldfarb
e Shanno. O argumento b deve conter os valores iniciais de um conjunto de
parâmetros e o argumento f deve especificar uma chamada à função que
calcule o critério (escalar) a ser maximizado, dados os valores correntes
dos parâmetros e quaisquer outros dados que sejam relevantes. Se o objetivo
for de fato uma minimização, esta função deverá retornar o negativo do
critério. Se for completada com sucesso, BFGSmax retorna o valor maximizado
do critério e b armazena os valores dos parâmetros que maximizam a
função.

O terceiro argumento, opcional, estabelece uma maneira de fornecer derivadas
analíticas (caso contrário o gradiente será computado numericamente). A
função gradiente g deve ter como primeiro argumento uma matriz
pré-definida que tenha o tamanho adequado para armazenar o gradiente, dado
na forma de ponteiro. Ela também precisa ter o vetor de parâmetros como um
argumento (na forma de ponteiro ou não). Outros argumentos são opcionais.

Para maiores detalhes e exemplos veja o capítulo sobre métodos numéricos
em guia de utilização do Gretl (Capítulo 37). Ver também"BFGScmax",
"NRmax", "fdjac", "simann".

# BFGSmin
Resultado:  escalar

É uma forma alternativa da função "BFGSmax". Se invocada com este nome a
função comporta-se como minimizadora.

# BFGScmax
Resultado:  escalar
Argumentos: &b (referência a matriz)
            bounds (matriz)
            f (chamada a função)
            g (chamada a função, opcional)

Realiza a maximização com restrições via L-BFGS-B (BFGS com memória
limitada, veja Byrd, Lu, Nocedal e Zhu, 1995). O argumento b deve conter os
valores iniciais de um conjunto de parâmetros, bounds deve conter as
restrições que aplicadas aos valores dos parâmetros (veja abaixo) e f
deve especificar uma chamada à função que calcule o critério (escalar) a
ser maximizado, dados os valores correntes dos parâmetros e quaisquer
outros dados que sejam relevantes. Se o objetivo for de fato uma
minimização, esta função deverá retornar o negativo do critério. Se
for completada com sucesso, BFGScmax retorna o valor maximizado do
critério, sujeito às restrições em bounds e b contém os valores dos
parâmetros que maximizam a função.

A matriz bounds deve ter 3 colunas e um número de linhas igual ao número
de elementos restritos no vetor de parâmetros. O primeiro elemento de uma
dada linha é o índice (de base 1) do parâmetro restrito, o segundo e o
terceiro são os limites inferiores e superiores, respectivamente. Os
valores -$huge e $huge devem ser usados para indicar que o parâmetro não
possui restrições inferiores ou superiores, respectivamente. Por exemplo,
a expressão a seguir é a forma de se especificar que o segundo elemento do
vetor de parâmetros deve ser não-negativo:

	  matrix bounds = {2, 0, $huge}

O quarto argumento, opcional, estabelece uma maneira de fornecer derivadas
analíticas (caso contrário o gradiente será computado numericamente). A
função gradiente g deve ter como primeiro argumento uma matriz
pré-definida que tenha o tamanho adequado para armazenar o gradiente, dado
na forma de ponteiro. Ela também precisa ter o vetor de parâmetros como um
argumento (na forma de ponteiro ou não). Outros argumentos são opcionais.

Para maiores detalhes e exemplos veja o capítulo sobre métodos numéricos
em guia de utilização do Gretl (Capítulo 37). Ver também"BFGSmax",
"NRmax", "fdjac", "simann".

# BFGScmin
Resultado:  escalar

É uma forma alternativa da função "BFGSmax".Se invocada com este nome a
função comporta-se como minimizadora.

# bincoeff
Resultado:  o mesmo tipo que o argumento
Argumentos: n (escalar, série ou matriz)
            k (escalar, série ou matriz)

Calcula o coeficiente binomial, ou seja o número de maneiras com que k
elementos possam ser escolhidos a partir dos n elementos sem repetições,
independentemente da sua ordenação. Este número é também igual ao
(k+1)-esimo coeficiente da expansão polinomial da (1+x)^n.

Para argumentos inteiros, o resultado é n!/k!(n-k)!, mas a função aceita
também aceita argumentos reais, e a fórmula generaliza-se com Gamma(n+1)/(
Gamma(k+1) × Gamma(n-k+1) )

Quando k > n ou k < 0, a função retorna NA.

Se os dois argumentos forem de tipos diferentes, o resultado é do tipo
"mais alto" dos dois, seguindo a ordem, matriz > série > escalar. Por
exemlo, se n é um escalar e k um vector de r elementos (ou viceversa), o
resultado é também um vector. Note-se que os argumentos matriciais deverem
ser vectores, e que se nenhum deles for escalar, devem ter a mesma
dimensão.

Ver também "gammafun" e "lngamma".

# bkfilt
Resultado:  série
Argumentos: y (série)
            f1 (número inteiro, opcional)
            f2 (número inteiro, opcional)
            k (número inteiro, opcional)

Retorna o resultado da aplicação do filtro passa-banda de Baxter-King para
a série y. Os parâmetros opcionais f1 e f2 representam, respectivamente,
os limites inferior e superior da amplitude de frequência a ser extraída,
enquanto k é a ordem de aproximação a ser utilizada.

Se esses argumentos não forem fornecidos então os valores padrão irão
depender da periodicidade do conjunto de dados. Para dados anuais os
padrões para f1, f2 e k são 2, 8 e 3, respectivamente. Para dados
trimestrais são 6, 32 e 12. Para dados mensais são 18, 96 e 36. Esses
valores são escolhidos para coincidir com a escolha mais comum entre os
praticantes, que é a utilização desse filtro para extrair o componente de
frequência do "ciclo de negócios". Isso, por sua vez, é comumente
definido como sendo entre 18 meses e 8 anos. O filtro, por escolha padrão,
abrange 3 anos de dados.

Se f2 for maior ou igual ao número de observações disponíveis, então a
versão "passa-baixa" do filtro será executada e a série resultante deve
ser considerada como uma estimativa do componente de tendência, ao invés
de ciclo. Ver também"bwfilt", "hpfilt".

# bkw
Resultado:  matriz
Argumentos: V (matriz)
            parnames (cadeia de texto, opcional)
            verbose (booleano, opcional)

Calcula o test BKW para a colinearidade (ver Belsley, Kuh and Welsch (1980))
dada a matriz covariança da estimativa dos parâmetros V. O segundo
argumento opcional, que pode ser um vector de texto ou uma cadeia de texto
que contenha nomes separados por vírgulas, é usado para etiquetar a coluna
que mostra a proporção da variância; o número de nomes deve ser igual à
dimensão de V. Depois de se ter estimado uma modelo em gretl, pode-se obter
os parâmetros adequados por via dos acessores "$vcv" e "$parnames".

Por defeito esta função produz apenas a tabela BKW como matriz, mas se
inserir um valor diferente de 0 como terceiro argumento, junto com a tabela
é mostrado mais alguma análise.

Esta função também existe como comando que retorna o mesmo cálculo,
"bkw", e que usa automaticamente o último modelo sem necessitar argumentos.

# boxcox
Resultado:  o mesmo tipo que o argumento
Argumentos: y (série ou matriz)
            d (escalar)

Retorna a transformação de Box-Cox com parâmetro d para uma variável
positiva y (ou a coluna da matriz y).

O resultado é (y^d - 1)/d para d diferente de zero ou log(y) para d = 0.

# bread
Resultado:  lote
Argumentos: fname (texto)
            import (booleano, opcional)

Lê um pacote (bundle) a partir de um arquivo de texto. A variável de texto
(string) fname deve conter o nome do arquivo no qual o pacote será lido. Se
esse nome tiver a extensão ".gz" será assumido que foi aplicada a
compactação do arquivo via gzip.

O arquivo em questão deve ser um XML apropriadamente definido: ele dever
conter um elemento gretl-bundle, utilizado para armazenar zero ou mais
elementos bundled-item. Por exemplo:

	  <?xml version="1.0" encoding="UTF-8"?>
	  <gretl-bundle name="temp">
          <bundled-item key="s" type="string">moo</bundled-item>
          <bundled-item key="x" type="scalar">3</bundled-item>
	  </gretl-bundle>

Como esperado, tais arquivos são gerados automaticamente pela função
associada "bwrite".

Se o nome do arquivo não contiver a especificação completa de seu
caminho, ele será procurado em vários locais "prováveis", começando no
"workdir" corrente. Entretanto, se for dado um valor não-nulo para o
argumento opcional import, o arquivo será procurado no diretório
"@dotdir". Nesse caso o argumento fname deverá ser um nome simples, sem a
inclusão do caminho.

Se ocorrer algum erro (tal como o arquivo ter sido mal formatado ou ser
inacessível), um erro será retornado via acessor "$error".

Ver também"mread", "bwrite".

# brename
Resultado:  escalar
Argumentos: B (lote)
            antiga (texto)
            nova (texto)

Se o argumento bundle B contém um elemento com a etiqueta antiga, esta é
alterada para nova; caso contrário, é mostrado um erro. Em caso de
sucesso, retorna 0.

Esta não é uma operação muito comum, mas pode ser necessária em
funções que trabalham com bundles, e brename é uma ferramenta eficiente
para essa tarefa. Exemplo:

	  # controi um bundle contendo uma matriz grande
	  bundle b
	  b.X = mnormal(1000, 1000)
	  if 0
	      # muda o nome manualmente
	      Xcopy = b.X
	      delete b.X
	      b.Y = Xcopy
	      delete Xcopy
	  else
	      # melhor: mais eficiente
	      brename(b, "X", "Y")
	  endif

O primeiro método obriga a que a matriz seja copiada duas vezes, fora do
bundle e depois insere com nova etiqueta, enquanto o método eficiente
altera directamente a etiqueta.

# bwfilt
Resultado:  série
Argumentos: y (série)
            n (número inteiro)
            omega (escalar)

Retorna o resultado da aplicação de um filtro passa-baixo de Butterworth
de ordem n e frequência de corte omega na série y. O corte é expresso em
graus e deve ser maior ou igual a 0 e menor que 180. Valores de corte
menores restringem o passa-banda a menores frequências e assim produzem uma
tendência mais suave. Valores maiores de n produzem um corte mais agudo,
mas ao custo de possível instabilidade numérica.

A inspeção preliminar do periodograma da série de interesse é útil
quando se deseja aplicar esta função. Veja guia de utilização do Gretl
(Capítulo 30) para detalhes. Ver também"bkfilt", "hpfilt".

# bwrite
Resultado:  número inteiro
Argumentos: B (lote)
            fname (texto)
            export (booleano, opcional)

Escreve um pacote (bundle) B em um arquivo XML com nome fname. Para uma
descrição sumária de seu formato, veja "bread". Se já existir um arquivo
fname ele será sobrescrito. O valor de retorno da função é 0 em caso de
sucesso. Se ocorrerem erros, tais como a impossibilidade de sobrescrever o
arquivo, a função retorna um valor não-nulo.

O arquivo de saída será salvo no diretório "workdir", a menos que a
variável fname contenha um caminho para o diretório onde será armazenado.
Entretanto, se for dado um valor não-nulo para o argumento export, o
arquivo de saída será armazenado no diretório "@dotdir". Neste caso um
nome simples, sem especificação de caminho, deverá ser utilizado como
segundo argumento.

Por padrão, o arquivo XML é armazenado sem compressão, mas se fname tiver
a extensão .gz é aplicada a compressão gzip.

Ver também"bread", "mwrite".

# carg
Resultado:  matriz
Argumento:  C (matriz complexa)

Retorna uma matriz real m x n contendo o "argumento" complexo de cada
elemento da matriz complexa m x n C. O argumento do número complexo z = x +
yi também pode ser calculado como atan2(y, x).

Ver também"cmod", "atan2".

# cdemean
Resultado:  matriz
Argumentos: X (matriz)
            standardize (booleano, opcional)

Centraliza as colunas da matriz X em torno de suas médias. Se o segundo
argumento (opcional) é diferente de zero, a coluna é normalizada, usando o
desvio padrão ajustada com os graus de liberdade (ou seja n - 1 como
divisor, onde n é o número de linhas de X).

# cdf
Resultado:  o mesmo tipo que o argumento
Argumentos: c (caractere)
            ... (ver abaixo)
            x (escalar, série ou matriz)
Exemplos:   p1 = cdf(N, -2.5)
            p2 = cdf(X, 3, 5.67)
            p3 = cdf(D, 0.25, -1, 1)

Calculadora da função de distribuição acumulada. Retorna P(X <= x), onde
a distribuição de X é especificada pela letra c. Entre os argumentos c e
x, zero ou mais argumentos adicionais são necessários para que se
especifique os parâmetros da distribuição. Isso é feito da seguinte
forma (note que a distribuição normal tem, por conveniência, uma função
própria, "cnorm"):

  Normal padrão (c = z, n ou N): sem argumentos extras

  Normal bivariada (D): coeficiente de correlação

  t de Student (t): graus de liberdade

  Qui-quadrado (c, x ou X): graus de liberdade

  F de Snedecor F (f ou F): graus de liberdade (num.); graus de liberdade
  (den.)

  Gama (g ou G): forma; escala

  Binomial (b ou B): probabilidade; quantidade de tentativas

  Poisson (p ou P): média

  Exponencial (exp): escala

  Weibull (w ou W): forma; escala

  Laplace (l ou L): media; escala

  Erro Generalizado (E): forma

  Qui-quadrado não-central (ncX): graus de liberdade, parâmetro de
  não-centralidade

  F não-central (ncF): graus de liberdade (num.), graus de liberdade
  (den.), parâmetro de não-centralidade

  t não-central (nct): graus de liberdade, parâmetro de não-centralidade

Note que na maioria dos casos existem pseudônimos para ajudar na
memorização dos códigos. O caso da norma bivariada é especial: a sintaxe
é x = cdf(D, rho, z1, z2) onde rho é a correlação entre as variáveis z1
e z2.

Ver também"pdf", "critical", "invcdf", "pvalue".

# cdiv
Resultado:  matriz
Argumentos: X (matriz)
            Y (matriz)

Divisão de números complexos. Os dois argumentos devem possuir o mesmo
número de linhas, n, e devem possuir uma ou duas colunas. A primeira coluna
contém a parte real e a segunda (se estiver presente) contém a parte
imaginária. A função retorna uma matriz de ordem n x 2 ou, caso não
exista a parte imaginária, um vetor com n linhas. Ver também"cmult".

# cdummify
Resultado:  lista
Argumento:  L (lista)

Esta função devolve uma lista em que cada série do argumento L que tenha
o atributo "codificado" é substituída por un conjunto de variáveis
fictícias/dummy que representam cada um dos seus valores codificados, mas
omitindo o valor mais pequeno/menor. Se o argumento L não contém nenhuma
série codificada, o valor retornado vai ser idêntico ao argumento L.

As variáveis fictícias/dummy, se geradas, terão os nomes criados de
acordo com o padrão D nome-da-variável _vi onde vi é o i-ésimo valor
representado da variável codificada. Caso alguns valores sejam negativos,
será inserido "m" antes do valor (absoluto) de vi.

Por exemplo, supondo que L contém, uma série codificada chamada C1 com
valores -9, -7, 0, 1 e 2. Então, as variáveis dummy/fictícias geradas
vão ser DC1_m7 (que codifica quando C1 = -7), DC1_0 (que codifica quando C1
= 0), etc.

Ver também"dummify", "getinfo".

# ceil
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Consiste na função teto. Retorna o menor inteiro que seja maior ou igual a
x. Ver também"floor", "int".

# cholesky
Resultado:  matriz quadrada
Argumento:  A (matriz positiva definida)

Realiza a decomposição de Cholesky da matriz A, assumindo que seja
simétrica e definida positiva. O resultado será uma matriz triangular
inferior L que satisfaz A = LL'. A função irá falhar se A não for
simétrica ou não for definida positiva. Ver também"psdroot".

# chowlin
Resultado:  matriz
Argumentos: Y (matriz)
            xfac (número inteiro)
            X (matriz, opcional)

Expande os dados de entrada, Y, para uma frequência maior utilizando o
método de Chow e Lin (1971). É assumido que as colunas de Y representam
séries. A matriz retornada tem a mesma quantidade de colunas de Y e xfac
vezes o número de linhas.

O segundo argumento representa o fator de expansão. Deve ser igual a 3 para
expandir dados trimestrais em mensais ou igual a 4 para expandir de anual
para trimestral (estes são os únicos fatores atualmente suportados). O
terceiro argumento, que é opcional, pode ser utilizado para fornecer uma
matriz de covariáveis com frequência maior.

Os regressores utilizados por padrão são uma constante e uma tendência
quadrática. Se X for fornecido, suas colunas devem ser utilizadas como
regressores adicionais. A função retornará um erro se o número de linhas
em X não for igual a xfac vezes o número de linhas em Y.

# cmod
Resultado:  matriz
Argumento:  C (matriz complexa)

Retorna uma matriz real m x n contendo o valor absoluto (ou "módulo") de
cada elemento da matriz complexa m x n C. O módulo do número complexo z =
x + yi é igual à raiz quadrada de x^2 + y^2.

Ver também"carg".

# cmult
Resultado:  matriz
Argumentos: X (matriz)
            Y (matriz)

Multiplicação complexa. Os dois argumentos devem ter o mesmo número de
linhas, n, e uma ou duas colunas. A primeira coluna contendo a parte real e
a segunda (se existir) a parte imaginária. O valor retornado é uma matriz
n x 2, ou, se o resultado não contiver parte imaginária, um vetor de
tamanho n. Ver também"cdiv".

# cnorm
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a função de distribuição acumulada para uma normal padrão. Ver
também"dnorm", "qnorm".

# cnumber
Resultado:  escalar
Argumento:  X (matriz)

Retorna o número condicional da matriz X de ordem n x k, conforme definido
em Belsley, Kuh e Welsch (1980). Se as colunas de X forem mutuamente
ortogonais o número condicional de X é a unidade. Um número condicional
grande é um indicador de multicolinearidade, sendo que é considerado
normalmente um valor "grande" algo acima de 50 (ou, algumas vezes, de 30).

Os passos para esses cálculos são: (1) construir uma matriz Z onde suas
colunas são a divisão das colunas de X divididas por suas respectivas
normas euclidianas; (2) construir Z'Z e obter seus autovalores e; (3)
calcular a raiz quadrada da razão entre o maior e o menor autovalor.

Ver também"rcond".

# cnameget
Resultado:  texto ou cadeia de texto
Argumentos: M (matriz)
            col (número inteiro, opcional)

Se o argumento col for dado, retorna o nome da coluna col da matriz M. Se as
colunas de M não possuírem nomes então será retornada um texto (string)
vazio. Se col for maior que o número de colunas da matriz será sinalizado
um erro.

Se não se indicar o segundo argumento, retornará um vetor de texto que
contém os nomes das colunas de M, ou um vetor de texto vazio se M não
tiver nomes de colunas atribuídos.

Exemplo:

	  matrix A = { 11, 23, 13 ; 54, 15, 46 }
	  cnameset(A, "Col_A Col_B Col_C")
	  string name = cnameget(A, 3)
	  print name

Ver também"cnameset".

# cnameset
Resultado:  escalar
Argumentos: M (matriz)
            S (cadeia de texto ou lista)

Adiciona nomes para as colunas da matriz M de ordem T x k . Se S for uma
lista, os nomes serão os das séries listadas. A lista precisa ter k
membros. Se S for um arranjo (array) de textos (string), ele precisa ter k
elementos. Para manter a compatibilidade com versões anteriores do Gretl,
uma única variável de texto também pode ser utilizada como segundo
argumento. Nesse caso ela precisa ter k textos separados por espaços.

Retorna o valor 0 se as colunas forem nomeadas com sucesso. Caso contrário
retorna um valor não-nulo. Veja também "rownames".

Exemplo:

	  matrix M = {1, 2; 2, 1; 4, 1}
	  variável de textos S = array(2)
	  S[1] = "Col1"
	  S[2] = "Col2"
	  colnames(M, S)
	  print M

# cols
Resultado:  número inteiro
Argumento:  X (matriz)

Retorna o número de colunas da matriz X. Ver também"mshape", "rows",
"unvech", "vec", "vech".

# complex
Resultado:  matriz complexa
Argumentos: A (escalar ou matriz)
            B (escalar ou matriz, opcional)

Retorna uma matriz complexa, onde A é utilisada para fornecer a parte real
e B a parte imaginária. Se A é m x n e B é um escalar, o resultado é m x
n com a parte imaginária constante -- e recíprocamente o oposto, mas com a
parte real constante. Se ambos os argumentos são matrizes, elas devem ser
da mesmas dimensões. Por defeito, caso o segundo argumento seja omitido, a
parte imaginária é igual a zero. Ver também"cswitch".

# conj
Resultado:  matriz complexa
Argumento:  C (matriz complexa)

Retorna uma matriz complexa m x n contendo o complexo conjugado de cada
elemento da matriz complexa m x n C. O conjugado de um número complexo z =
x + yi é igual a x - yi.

Ver também"carg", "cmod".

# conv2d
Resultado:  matriz
Argumentos: A (matriz)
            B (matriz)

Calcula a convolução bidimensional das matrizes A e B. Se A é r x c e B
é m x n a matriz resultante terá r+m-1 linhas e c+n-1 colunas.

Ver também"fft", "filter".

# corr
Resultado:  escalar
Argumentos: y1 (série ou vetor)
            y2 (série ou vetor)

Calcula o coeficiente de correlação entre y1 e y2. Os argumentos devem ser
duas séries ou dois vetores com o mesmo tamanho. Ver também"cov", "mcov",
"mcorr", "npcorr".

# corrgm
Resultado:  matriz
Argumentos: x (série, matriz ou lista)
            p (número inteiro)
            y (série ou vetor, opcional)

Se forem fornecidos apenas os dois primeiros argumentos a função calcula o
correlograma de x para as defasagens de 1 até p. Sendo k o número de
elementos em x (igual a 1 se x for uma série, ao número de colunas se x
for uma matriz ou ao número de membros se x for uma lista). O valor
retornado será uma matriz com p linhas e 2k colunas, onde as k primeiras
colunas conterão as respectivas autocorrelações e o restante as
respectivas autocorrelações parciais.

Se um terceiro argumento for fornecido a função irá computar o
correlograma cruzado para cada um dos k elementos em x e y, partindo de +p
até - p. A matriz retornada possui 2p + 1 linhas e k colunas. Se x for uma
série ou lista e y for um vetor, y precisa ter linhas na mesma quantidade
que o total de observações na amostra selecionada.

# cos
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o cosseno de x. Ver também"sin", "tan", "atan".

# cosh
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o cosseno hiperbólico de x.

Ver também"acosh", "sinh", "tanh".

# cov
Resultado:  escalar
Argumentos: y1 (série ou vetor)
            y2 (série ou vetor)

Retorna a covariância y1 e y2. Os argumentos devem ser duas séries ou dois
vetores (estes devem possuir o mesmo comprimento). Ver também"corr",
"mcov", "mcorr".

# critical
Resultado:  o mesmo tipo que o argumento
Argumentos: c (caractere)
            ... (ver abaixo)
            p (escalar, série ou matriz)
Exemplos:   c1 = critical(t, 20, 0.025)
            c2 = critical(F, 4, 48, 0.05)

Calculadora de valores críticos. Retorna x tal que P(X > x) = p, onde a
distribuição X é determinada pela letra c. Entre os argumentos c e p,
zero ou mais argumentos escalares são necessários para especificar os
parâmetros da distribuição, Isso é feito da seguinte forma:

  Normal padrão (c = z, n ou N): sem argumentos extras

  t de Student (t): graus de liberdade

  Chi square (c, x ou X): graus de liberdade

  F de Snedecor (f ou F): g.l. (num.); g.l. (den.)

  Binomial (b ou B): probabilidade; tentativas

  Poisson (p ou P): média

  Laplace (l ou L): média; escala

  Erro Generalizado (E): forma

Ver também"cdf", "invcdf", "pvalue".

# cswitch
Resultado:  matriz
Argumentos: A (matriz)
            modo (escalar)

Reinterpreta uma matriz real como contendo valores complexos ou viceversa. A
acção exacta depende de modo (que pode ter os valores 1,2,3 ou 4) como se
mostra a seguir:

modo 1: A deve ser uma matriz real com um número par de colunas. Produz uma
matriz complexa com a metade das colunas; as colunas ímpares de A fornecem
a parte real e as colunas pares as partes imaginárias.

modo 2: Produz o resultado inverso daquele em modo 1. A deve ser uma matriz
complexa e o resultado é uma matriz real com o dobro das colunas de A.

modo 3: A deve ser uma matriz real com um número par de linhas. Produz uma
matriz complexa com a metade das linhas; as linhas ímpares de A fornecem a
parte real e as linhas pares as partes imaginárias.

modo 4: Produz o resultado inverso daquele em modo modo 3. A deve ser uma
matriz complexa e o resultado é uma matriz real com o dobro das linhas de
A.

Ver também"complex".

# ctrans
Resultado:  matriz complexa
Argumento:  C (matriz complexa)

Retorna a matriz complexa n x m contendo a transposta do conjugado da matriz
complexa m x n C. O operador ' (primo) também produz a transposição
conjugada de matrizes complexas. A função "transp" pode ser usada em
matrizes complexas mas produz a transposiçã0 "directa" (não coniugada).

# cum
Resultado:  o mesmo tipo que o argumento
Argumento:  x (série ou matriz)

Acumula x (isto é, cria uma soma móvel). Quando x for uma série, produz
uma série y onde cada um de seus elementos é igual a soma dos valores de x
até a observação correspondente. O ponto de partida para a acumulação
é a primeira observação não-ausente da amostra selecionada corrente.
Quando x for uma matriz, seus elementos são acumulados por colunas.

Ver também"diff".

# curl
Resultado:  escalar
Argumento:  &b (referência a lote)

Fornece uma maneira relativamente flexível de se obter um buffer de texto
contendo dados de um servidor de internet utilizando a biblioteca libcurl. O
argumento b, do tipo pacote (bundle), deve conter uma variável de texto
(string) chamada URL que fornece o endereço completo do recurso no host
alvo. Outros elementos opcionais são apresentados a seguir.

  "header": a variável de texto especificando um header HTTP que será
  enviado para o host.

  "postdata": a variável de texto contendo os dados que serão enviados
  para o host.

Os campos header e postdata são destinados para o uso com uma requisição
HTTP do tipo POST. Se postdata estiver presente o método POST é
implícito, caso contrário o método GET é implícito. Mas note que para
requisições GET diretas a função "readfile" oferece uma interface mais
simples.

Se outro elemento opcional do pacote, um escalar chamado include estiver
presente e possuir valor não-nulo, a requisição irá incluir o header
recebido do host com o corpo de saída.

Ao completar-se a requisição, o texto recebido do servidor é adicionado
ao pacote e recebe o nome de "output".

Se um erro ocorrer na formulação da requisição (por exemplo, não
existir a URL na entrada) a função irá falhar, caso contrário ela
retornará o valor 0 se a requisição for bem sucedida ou um valor não
nulo, sendo que neste caso a mensagem de erro da biblioteca curl será
adicionado ao pacote e identificado como "errmsg". Note, entretanto, que
"sucesso" neste sentido não significa necessariamente que os dados
desejados foram obtidos. Na verdade significa apenas que alguma resposta foi
recebida do servidor. Assim, é necessário conferir o conteúdo do buffer
de saída (que pode ser de fato uma mensagem tal como "Página não
encontrada").

Um bom exemplo de como utilizar essa função é baixar alguns dados do site
do US Bureau of Labor Statistics, que requere o envio de uma consulta
(query) JSON. Note o uso de "sprintf" para inserir aspas duplas no dado
POST.

	  bundle req
	  req.URL = "http://api.bls.gov/publicAPI/v1/timeseries/data/"
	  req.include = 1
	  req.header = "Content-Type: application/json"
	  string s = sprintf("{\"seriesid\":[\"LEU0254555900\"]}")
	  req.postdata = s
	  err = curl(&req)
	  if err == 0
	      s = req.output
	      string line
	      loop while getline(s, line) --quiet
	          printf "%s\n", line
	      endloop
	  endif

Veja também as funções "jsonget" e "xmlget" para processamento de dados
recebidos no formato JSON e XML, respectivamente.

# dayspan
Resultado:  número inteiro
Argumentos: dia1 (número inteiro)
            dia2 (número inteiro)
            dias por semana (número inteiro)

Retorna o número de dias (relevantes) entre os dias dia1 e dia2, inclusive.
Os dias por semana, que têm que ser 5, 6 ou 7, dão o número de dias na
semana que devem contar (um valor de 6, ignora domingos, e um valor de 5
ignora sábados e domingos).

Para obter dias de época a partir de formas mais familiares de datas, ver
"epochday". Veja também: "smplspan".

# defarray
Resultado:  ver abaixo
Argumento:  ... (ver abaixo)

Permite a definição de uma variável do tipo arranjo (array) de forma
direta, através do fornecimento de um ou mais elementos. Ao utilizar essa
função é necessário que se especifique um tipo (na forma plural) para o
arranjo: strings, matrices, bundles ou lists. Cada um dos argumentos dever
ser um objeto do mesmo tipo que o especificado na definição do arranjo. Em
caso de sucesso na definição, será retornado um arranjo com n elementos,
onde n é igual ao número de argumentos.

	  strings S = defarray("foo", "bar", "baz")
	  matrices M = defarray(I(3), X'X, A*B, P[1:])

Veja também "array".

# defbundle
Resultado:  lote
Argumento:  ... (ver abaixo)

Permite a definição inicial de uma variável pacote (bundle) por extenso,
com a indicação de zero ou mais pares com o formato chave, membro. Se
contarmos os argumentos a partir de 1, cada argumento numerado ímpar tem de
corresponder a uma cadeia de texto (chave) e cada argumento numerado par
deve representar um objeto/objecto de um tipo que possa ser incluído num
pacote.

Alguns exemplos simples:

	  bundle b1 = defbundle("s", "Texto exemplo", "m", I(3))
	  bundle b2 = defbundle("yn", normal(), "x", 5)

O primeiro exemplo é um pacote cujos membros são uma cadeia de texto e uma
matriz. O segundo, um pacote com um membro que é uma série e outro que é
escalar. Notar que não se pode especificar o tipo de cada argumento quando
se utiliza esta função, por isso deve-se aceitar o tipo "natural" do
argumento em questão. Por exemplo, se se pretendia acrescentar uma série
com valor constante 5, a um pacote chamado b1 seria necessário escrever
algo como o seguinte (depois de declarar b1):

	  series b1.s5 = 5

Se não se fornecer nenhum argumento a esta função, isso equivale a criar
um pacote vazio (ou esvaziar o conteúdo um pacote existente), o que também
poderia ser feito via:

	  bundle b = null

# deflist
Resultado:  lista
Argumento:  ... (ver abaixo)

Gera uma lista (de séries já definidas) dados um ou mais argumentos
apropriados. Cada argumento deve ser uma série já definida (indicada pelo
seu nome ou número ID), uma lista definida previamente ou por uma
expressão cujo resultado seja uma lista (incluindo um vetor que possa ser
interpretado como um conjunto de números ID).

Um ponto a ser considerado é que esta função simplesmente concatena seus
argumentos para produzir a lista que ela devolve. Quando se pretende que o
valor a ser retornado não tenha duplicados (que não se refira a nenhuma
série mais que uma vez), fica a cargo do utilizador garantir que esse
requisito seja seguido.

# deseas
Resultado:  série
Argumentos: x (série)
            c (caractere, opcional)

Precisa que o TRAMO/SEATS e/ou X-12-ARIMA estejam instalados. Retorna a
série x dessazonalizada (ou seja, sazonalmente ajustada). A série a ser
dessazonalizada precisa ser mensal ou trimestral. Para utilizar o X-12-ARIMA
deve-se fornecer X como segundo argumento e para usar o TRAMO/SEATS deve-se
fornecer T. Se o segundo argumento for omitido o Gretl irá utilizar o
X-12-ARIMA.

Note que se a série de entrada não possuir um componente sazonal
detectável a execução da função irá falhar. Note também que tanto o
TRAMO/SEATS quanto o X-12-ARIMA oferecem um grande número de opções, mas
a função deseas utilizará apenas os seus valores padrão. Em ambos os
programas os fatores sazonais são calculados com base em um modelo ARIMA
automaticamente selecionado. Uma das diferenças entre os dois que pode
levar a resultados bastante distintos é o ajuste prévio de observações
aberrantes que o TRAMO/SEATS realiza e que não é feito pelo X-12-ARIMA.

# det
Resultado:  escalar
Argumento:  A (matriz quadrada)

Retorna o determinante de A, calculado via decomposição LU. Ver
também"ldet", "rcond", "cnumber".

# diag
Resultado:  matriz
Argumento:  X (matriz)

Retorna a diagonal principal de X em um vetor coluna. Se X for uma matriz de
ordem m x n o número de elementos do vetor resultante será igual a min(m,
n). Ver também"tr".

# diagcat
Resultado:  matriz
Argumentos: A (matriz)
            B (matriz)

Retorna a soma direta de A e B, isto é, uma matriz contendo A no canto
superior esquerdo e B no canto inferior direito. Se A e B forem ambas
quadradas, a matriz resultante será diagonal em blocos.

# diff
Resultado:  o mesmo tipo que o argumento
Argumento:  y (série, matriz ou lista)

Calcula a primeira diferença. Se y for uma série ou uma lista de séries,
os valores iniciais serão iguais a NA. Se y for uma matriz, a
diferenciação é feita por colunas e os valores iniciais serão iguais a
0.

Quando for retornada uma lista, cada uma das variáveis será
automaticamente nomeada conforme o modelo d_varname, onde varname é o nome
da série original. O nome será truncado caso necessário e pode ser
ajustado caso já exista uma variável com o mesmo nome.

Ver também"cum", "ldiff", "sdiff".

# digamma
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a função digama (ou Psi) de x e consiste na derivada logarítmica
da função gama.

# dnorm
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a densidade da distribuição normal padrão em x. Para obter a
densidade para uma distribuição normal não-padrão em x, utilize o
escore-z de x como argumento da função dnorm e multiplique o resultado
pela jacobiana da transformação z, ou seja, 1/sigma, conforme ilustrado a
seguir:

	  mu = 100
	  sigma = 5
	  x = 109
	  fx = (1/sigma) * dnorm((x-mu)/sigma)

Ver também"cnorm", "qnorm".

# dropcoll
Resultado:  lista
Argumentos: X (lista)
            epsilon (escalar, opcional)

Retorna uma lista com os mesmo elementos de X, mas excluindo as séries
colineares. Assim, se todas as séries em X forem linearmente independentes,
a lista resultante será simplesmente uma cópia de X.

O algoritmo utiliza a decomposição QR (transformação de Householder), de
forma que está sujeita a erro de precisão finita. Para avaliar a
sensibilidade do algoritmo, um segundo parâmetro (opcional) epsilon pode
ser especificado para tornar o teste de colinearidade mais ou menos estrito,
conforme desejado. O valor padrão para epsilon é 1.0e-8. Ajustando epsilon
para um maior valor eleva a probabilidade de uma série ser descartada.

Exemplo:

	  nulldata 20
	  set seed 9876
	  series foo = normal()
	  series bar = normal()
	  series foobar = foo + bar
	  list X = foo bar foobar
	  list Y = dropcoll(X)
	  list print X
	  list print Y
	  # defina épsilon como sendo um valor bastante pequeno
	  list Y = dropcoll(X, 1.0e-30)
	  list print Y

produz

	  ? list print X
	  foo bar foobar
	  ? list print Y
	  foo bar
	  ? list Y = dropcoll(X, 1.0e-30)
	  Replaced list Y
	  ? list print Y
	  foo bar foobar

# dsort
Resultado:  o mesmo tipo que o argumento
Argumento:  x (série ou vetor)

Ordena x de forma decrescente, descartando observações com valores
ausentes quando x for uma série. Ver também"sort", "values".

# dummify
Resultado:  lista
Argumentos: x (série)
            omitval (escalar, opcional)

O argumento x deve ser uma série discreta. Essa função cria um conjunto
de variáveis dummy, sendo uma para cada um dos valores distintos na série.
Por padrão o menor valor é tratado como a categoria omitida e não é
explicitamente representado.

O segundo argumento (opcional) representa o valor de x que deve ser tratado
como sendo a categoria omitida. O efeito quando o argumento único for dado
é equivalente a utilizar o seguinte comando: dummify(x, min(x)). Para
produzir um conjunto completo de dummies, ou seja, sem a categoria omitida,
pode-se usar dummify(x, NA).

As variáveis geradas são automaticamente nomeadas de acordo com o seguinte
padrão: Dvarname_i onde varname é o nome da séries original e i é um
índice iniciado em 1. A porção que representa o nome original da série
será truncado, caso seja necessário, e ajustado no caso de não ser único
no conjunto de nomes assim construído.

# easterday
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Com o argumento x representando um ano, retorna a data da Páscoa no
calendário gregoriano no formato mês + dia/100. Note que 10 de abril é,
nesta convenção, 4.1. Assim, 4.2 representa 20 de abril e não 2 de abril
(que seria representado por 4.02).

	  scalar e = easterday(2014)
	  scalar m = floor(e)
	  scalar d = 100*(e-m)

# ecdf
Resultado:  matriz
Argumento:  y (série ou vetor)

Calcula a função distribuição acumulada (FDA) empírica de y. Esta é
retornada em uma matriz com duas colunas: a primeira contém os valores
únicos e ordenados de y e a segunda a frequência relativa cumulativa, isto
é, a quantidade de vezes em que o valor da observação é menor ou igual
ao valor na primeira coluna, dividida pelo número total de observações.

# eigen
Resultado:  matriz
Argumentos: A (matriz quadrada)
            &V (referência a matriz, ou null)
            &W (referência a matriz, ou null)

Calcula os valores próprios e, opcionalmente, os vectores próprios direito
e/ou esquerdo, da matriz n x n A, que pode ser real ou complexa. O valores
próprios são retornados num vector complexo.

Se você deseja obter o vector próprio direito na forma de matriz complexa,
n x n), forneça o nome de uma matriz existente, precedida por & para
indicar o "endereço" da matriz em questão, comom segundo argumento. De
outro modo, este argumento pode ser omitido.

Para obter o vector próprio esquerdo (igualmente, na forma de matriz
complexa), fornecer o endereço da matrix como terceiro argumento. Note que
se pretender os vectores esquerdos mas não os direitos, você deve usar a
palavra chave null como valor para o segundo argumento.

Ver também"eigensym", "eigsolve", "svd".

# eigengen
Resultado:  matriz
Argumentos: A (matriz quadrada)
            &U (referência a matriz, ou null)

Calcula os autovalores e, opcionalmente, os autovetores, da matriz A de
ordem n x n. Se todos os autovalores forem reais uma matriz n x 1 é
retornada. Caso contrário, o resultado é uma matriz n x 2, com a primeira
coluna contendo os componentes reais e a segunda coluna os componentes
imaginários. Não é garantido que os autovalores sejam classificados em
alguma ordem particular.

Existem duas possibilidades para o segundo argumento. Ele deve ser o nome de
uma matriz existente precedida por & (para indicar o "endereço" da matriz
em questão), sendo que nesse caso um resultado auxiliar é armazenado nesta
matriz. A outra possibilidade é a utilização da palavra-chave null, sendo
que nesse caso o resultado auxiliar não é produzido.

Se o segundo argumento for não-nulo, a matriz especificada será
sobrescrita com o resultado auxiliar. Vale salientar que não é necessário
que a matriz existente tenha a dimensão adequada para receber o resultado.
A matriz U é organizada da seguinte forma:

  Se o i-ésimo autovalor for real, a i-ésima coluna de U irá conter o
  autovetor correspondente;

  Se o i-ésimo autovalor for complexo, a i-ésima coluna de U irá conter a
  parte real do autovetor correspondente e a coluna seguinte a parte
  imaginária. O autovetor para o autovalor conjugado é a conjugada do
  autovetor.

Em outras palavras, os autovetores são armazenados na mesma ordem que os
autovalores, mas os autovetores reais ocupam uma coluna, enquanto que os
autovetores complexos ocupam duas (sendo que a parte real é armazenada
primeiro). O número total de colunas ainda é n, pois o autovetor conjugado
é ignorado.

Ver também"eigensym", "eigsolve", "qrdecomp", "svd".

# eigensym
Resultado:  matriz
Argumentos: A (matriz simétrica)
            &U (referência a matriz, ou null)

Funciona da mesma forma que "eigengen", mas o argumento A deve ser
simétrico (sendo que neste caso os cálculos podem ser reduzidos).
Diferentemente de "eigengen", autovalores são retornados em ordem
ascendente.

Note: se o interesse é na decomposição espectral de uma matriz da forma
X'X, onde X é uma matriz grande, é preferível calculá-la via operador
X'X ao invés de utilizar a sintaxe mais geral X'*X. A primeira expressão
utiliza um algoritmo especializado que tem a dupla vantagem de ser mais
eficiente computacionalmente e de garantir que o resultado seja livre, por
construção, dos artefatos de precisão de máquina que podem torná-la
numericamente não-simétrico.

# eigsolve
Resultado:  matriz
Argumentos: A (matriz simétrica)
            B (matriz simétrica)
            &U (referência a matriz, ou null)

Resolve o problema do autovalor generalizado |A - lambdaB| = 0, onde A e B
são simétricas e B é positiva definida. Os autovalores são retornados
diretamente, ordenados de forma ascendente. Se for utilizado o terceiro
argumento (opcional) ele deve ser o nome de uma matriz existente precedida
por &. Neste caso os autovetores generalizados serão escritos nesta matriz.

# epochday
Resultado:  escalar ou série
Argumentos: ano (escalar ou série)
            mês (escalar ou série)
            dia (escalar ou série)

Retorna o número do dia na época corrente especificada pelo ano, mês e
dia. O número do dia é igual a 1 para o dia 1 de janeiro do ano 1 depois
de Cristo, no calendário gregoriano proléptico, e 733786 na data
2010-01-01. Se algum dos argumentos for uma série, os valores retornados
também terão a forma de uma série, caso contrário será retornado um
escalar.

Por padrão os valores do ano, mês e dia assumem-se serem relativos ao
calendário gregoriano, mas se o ano for um valor negativo a interpretação
muda para o calendário juliano.

Para a inversa dessa função, veja "isodate". Veja também a função
"juldate" para o calendário juliano.

# errmsg
Resultado:  texto
Argumento:  errno (número inteiro)

Retorna a mensagem de erro do Gretl associada a errno. Veja também
"$error".

# errorif
Resultado:  escalar
Argumentos: condição (booleano)
            msg (texto)

Aplicável apenas no contexto de uma função cirada pelo utilizador. Se a
condição é diferente de zero, termina a execução da função actual,
mostrando a razão de erro; o argumento msg é então mostrado no écran
como parte da resposta do chamador da função em questão.

O valor de retorno (1) desta função é puramente nominal.

# exists
Resultado:  número inteiro
Argumento:  name (texto)

Retorna um valor não-nulo se name é o identificador de um objeto
existente, seja um escalar, uma série, uma matriz, uma lista, uma variável
de texto, um pacote (bundle) ou um arranjo (array). Caso contrário retorna
0. Veja também "typeof".

# exp
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna e^x. Note que no caso de matrizes a função é aplicada em cada
elemento. Para a função exponencial matricial veja "mexp".

# fcstats
Resultado:  matriz
Argumentos: y (série ou vetor)
            f (série, lista ou matriz)

Produz uma matriz contendo várias estatísticas que podem ser utilizadas
para avaliar a série f, que consiste na previsão da série observada y.

Quando f é uma série ou um vetor/vector, o resultado é um vetor/vector
coluna. Quando f é uma lista com k membros ou uma matriz de ordem T x k, o
resultado tem k colunas, sendo que cada uma contém as estatísticas do
elemento correspondente (série ou coluna) do argumento de entrada (série,
vetor, lista ou matriz) como uma predição de y.

Em todos os casos, a dimensão "vertical" do argumento de entrada (o
comprimento da amostra corrente para uma série ou uma lista, e o número de
linhas para uma matriz) deve coincidir entre os dois argumentos.

As linhas da matriz retornada são constituídas pelas seguintes
estatísticas:

	  1  Erro Médio (ME)
	  2  Raiz do Erro Quadrado Médio (RMSE)
	  3  Erro Absoluto Médio (MAE)
	  4  Erro Percentual Médio (MPE)
	  5  Erro Percentual Absoluto Médio (MAPE)
	  6  U de Theil
	  7  Proporção do viés, UM
	  8  Proporção da regressão, UR
	  9  Proporção do distúrbio, UD

Para mais detalhes sobre o cálculo dessas estatísticas e a interpretação
dos valores de U, veja o guia de utilização do Gretl (Capítulo 35).

# fdjac
Resultado:  matriz
Argumentos: b (vetor coluna)
            fcall (chamada a função)
            h (escalar, opcional)

Calcula uma aproximação numérica para a jacobiana associada ao vetor b de
ordem n e a função de transformação especificada pelo argumento fcall. A
chamada da função deve ter b como primeiro argumento (tanto na forma
direta quanto na forma de ponteiro), seguido por quaisquer argumentos
adicionais que podem ser necessários e o valor retornado deverá ser uma
matriz de ordem m x 1. Se executada com sucesso, fdjac retorna uma matriz de
ordem m x n contendo a jacobiana. Exemplo:

Pode-se utilizar o terceiro argumento (opcional) para determinar o tamanho
da medida h que se usa no mecanismo de aproximação (ver mais abaixo).
Quando se omite este argumento, o tamanho da medida determina-se
automaticamente.

Aqui está um exemplo do seu uso:

	  matrix J = fdjac(theta, myfunc(&theta, X))

A função pode utilizar três diferentes métodos: diferença anterior,
diferença bilateral ou extrapolação de Richardson com 4 nós.
Respectivamente:

J_0 = (f(x+h) - f(x))/h

J_1 = (f(x+h) - f(x-h))/2h

J_2 = [8(f(x+h) - f(x-h)) - (f(x+2h) - f(x-2h))] /12h

As três alternativas acima trazem, geralmente, um dilema entre acurácia e
velocidade. É possível escolher os métodos através do comando "set",
ajustando a variável fdjac_quality em 0, 1 ou 2.

Para mais detalhes e exemplos veja o capítulo sobre métodos numéricos no
guia de utilização do Gretl (Capítulo 37).

Ver também"BFGSmax", "numhess", "set".

# feval
Resultado:  ver abaixo
Argumentos: nome-de-função (texto)
            ... (ver abaixo)

Ferramenta sobretudo destinada a autores de funções. O primeiro argumento
é o nome de uma função, e os restantes argumentos devem ser passados para
a função em questão. Na práctica a função identificada como
nome-de-função é tratada ela mesmo como sendo uma variável. O valor
retornado é o que a função retorna de acordo com os argumentos
especificados.

O exemplo abaixo mostra alguns usos possíveis:

	  function scalar utility (scalar c, scalar sigma)
	  return (c^(1-sigma)-1)/(1-sigma)
	  end function

	  strings S = defarray("log", "utility")

	  # chama uma função interna com um argumento
	  x = feval(S[1], 2.5)
	  # chama uma função definida pelo utilizador
	  x = feval(S[2], 5, 0.5)
	  # uma função com dois argumentos
	  func = "zeros"
	  m = feval(func, 5-2, sqrt(4))
	  print m
	  # uma função com três argumentos
	  x = feval("monthlen", 12, 1980, 5)

Existe uma analogia entre feval e "genseries": ambas as funções recebem a
variaável como elemento sintático que no momento da composição é fixo.

# fevd
Resultado:  matriz
Argumentos: target (número inteiro)
            shock (número inteiro)
            sys (lote, opcional)

Essa função é uma alternativa mais flexível à função de acesso
"$fevd" para a obtenção da matriz de decomposição da variância do erro
de previsão (FEVD) que pode ser obtida após a estimação de um VAR ou
VECM. Quando utilizada sem o argumento final, sys, está disponível apenas
imediatamente após a estimação de um VAR ou VECM. Alternativamente, as
informações de uma VAR ou VECM podem ser armazenadas em um pacote via
função "$system" que, por sua vez, pode ser utilizado como o último
argumento da função fevd.

Os argumentos target e shock são índices das variáveis endógenas no
sistema, com 0 indicando "todas". Os seguintes exemplos ilustram sua
utilização. No primeiro deles a matriz fe1 armazena as proporções da
variância do erro de previsão para y1 causadas por y1, y2 e y3 (as linhas
somam 1). No segundo, fe2 armazena as contribuições de y2 para a
variância do erro de previsão de todas as três variáveis (logo as linhas
não somam 1). No terceiro caso o valor retornado é um vetor coluna
contendo a "própria parcela" da variância do erro de previsão de y1.

	  var 4 y1 y2 y3
	  bundle vb = $system
	  matrix fe1 = fevd(1, 0, vb)
	  matrix fe2 = fevd(0, 2, vb)
	  matrix fe3 = fevd(1, 1, vb)

O número de períodos (linhas) ao longo dos quais a decomposição é
traçada é determinado automaticamente com base na frequência dos dados,
mas isso pode ser ajustado via comando "set", como por exemplo set horizon
10.

Ver também"irf".

# fft
Resultado:  matriz
Argumento:  X (matriz)

Calcula a transformada de Fourier real discreta. Se a matriz de entrada X
tiver n colunas, a saída terá 2n colunas, onde as partes reais são
armazenadas nas colunas ímpares e as complexas nas pares.

Quando seja necessário calcular a transformada de Fourier em vários
vetores com o mesmo número de elementos, é mais eficiente, do ponto de
vista numérico, agrupar esses vetores em uma única matriz ao invés de
aplicar a função fft em cada vetor de forma separada. Ver também"ffti".

# fft2
Resultado:  matriz
Argumento:  X (matriz)

Transfromada discreta de Fourier. A matriz de entrada X pode ser real ou
complexa. O resultado é uma matiz complexa de com a mesma dimensão de X.

Quando seja necessário calcular a transformada de Fourier em vários
vetores com o mesmo número de elementos, é mais eficiente, do ponto de
vista numérico, agrupar esses vetores em uma única matriz ao invés de
aplicar a função fft2 em cada vetor de forma separada. Ver também"ffti".

# ffti
Resultado:  matriz
Argumento:  X (matriz)

Calcula a inversa da transformada de Fourier real discreta. Assume-se que X
contém n colunas complexas, com a parte real nas colunas ímpares e a parte
real nas pares. Assim, o número total de colunas deverá ser 2n. Uma matriz
com n colunas é retornada. returned.

Quando seja necessário calcular a inversa da transformada de Fourier em
vários vetores com o mesmo número de elementos, é mais eficiente, do
ponto de vista numérico, agrupar esses vetores em uma única matriz ao
invés de aplicar a função fft em cada vetor de forma separada. Ver
também"fft".

# filter
Resultado:  ver abaixo
Argumentos: x (série ou matriz)
            a (escalar ou vetor, opcional)
            b (escalar ou vetor, opcional)
            y0 (escalar, opcional)

Calcula uma filtragem semelhante ao ARMA do argumento x. A transformação
pode ser escrita como

y_t = a_0 x_t + a_1 x_t-1 + ... a_q x_t-q + b_1 y_t-1 + ... b_py_t-p

Se o argumento x for uma série, o resultado será também uma série. Caso
contrário, se x for uma matriz com T linhas e k colunas, o resultado será
uma matriz com o mesmo tamanho e com a filtragem sendo realizada coluna por
coluna.

Os argumentos a e b são opcionais. Eles podem ser escalares, vetores ou a
palavra-chave null.

Se a for um escalar, isto é usado como a_0 e implica em q=0. Se ele for um
vetor com q+1 elementos, eles contêm os coeficientes de a_0 a a_q. Se a for
null ou for omitido, isso é equivalente a definir a_0 =1 e q=0.

Se b for um escalar, isto é usado como b_1 e implica em p=1. Se ele for um
vetor com p elementos, eles contêm os coeficientes de b_1 a b_p. Se b for
null ou for omitido, isso é equivalente a definir B(L)=1.

O argumento escalar opcional y0 for tomado para representa todos os valores
de y anteriores ao início da amostra (usado apenas quando p>0). Se for
omitido, subentende-se que é igual a 0. Assume-se que valores
pré-amostrais de x são sempre 0.

Ver também"bkfilt", "bwfilt", "fracdiff", "hpfilt", "movavg", "varsimul".

Exemplo:

	  nulldata 5
	  y = filter(index, 0.5, -0.9, 1)
	  print index y --byobs
	  x = seq(1,5)' ~ (1 | zeros(4,1))
	  w = filter(x, 0.5, -0.9, 1)
	  print x w

produz

          index            y

          1            1     -0.40000
          2            2      1.36000
          3            3      0.27600
          4            4      1.75160
          5            5      0.92356

          x (5 x 2)

          1   1
          2   0
          3   0
          4   0
          5   0

          w (5 x 2)

          -0.40000     -0.40000
          1.3600      0.36000
          0.27600     -0.32400
          1.7516      0.29160
          0.92356     -0.26244

# firstobs
Resultado:  número inteiro
Argumento:  y (série)

Retorna o número da primeira observação não ausente da série y. Note
que se alguma forma de subamostragem estiver sendo utilizada o valor
retornado poderá ser menor que o valor retornado pela função "$t1". Ver
também"lastobs".

# fixname
Resultado:  texto
Argumentos: rawname (texto)
            underscore (booleano, opcional)

Tem como intuito principal a utilização em conjunto com o comando "join".
Retorna o resultado da conversão de rawname em um identificador válido do
Gretl, que deve ser iniciado por uma letra, conter apenas letras ASCII,
dígitos e traço inferior ("underscore"), e não deve ter mais que 31
caracteres. As regras utilizadas na conversão são:

1. Remover quaisquer caracteres que não sejam letras no início do nome.

2. Até o limite de 31 caracteres não ter sido ultrapassado ou a entrada
tiver sido exaurida: transcreve os caracteres "legais ", omite os caracteres
"ilegais", com exceção dos espaços, e substitui os espaços por traços
inferiores. Se o caractere anterior for um traço inferior o espaço será
omitido.

Se você estiver seguro de que a entrada não é muito extensa (e, dessa
forma, não está sujeita a truncagem), você pode querer que um ou mais dos
caracteres ilegais sejam substituídos por um traço inferior ao invés de
simplesmente deletá-los. Isto pode produzir um identificador mais legível.
Para que isso ocorra, forneça um valor diferente de 0 para o segundo
argumento (que é opcional). Vale salientar que esse procedimento não é
aconselhável quando o comando "join" for utilizado, uma vez que os nomes
automaticamente "corrigidos " não utilizarão o traço inferior.

# flatten
Resultado:  ver abaixo
Argumentos: A (cadeia de matrizes ou texto)
            alt (booleano, opcional)

Compacta um conjunto de matrizes numa única matriz ou conjunto de cadeias
de texto numa única cadeia de texto.

No caso matricial, as matrizes contidas em A são, por defeito, concatenadas
horizontalmente, mas se um valor diferente de zero for passado como
argumento alt a concatenação é vertical. Em ambos os casos será mostrado
um erro se as matrizes não forem compatíveis com a operação. Ver
"msplitby" para a operação inversa.

No caso de cadeia de texto, o resultado são as cadeias de texto em A, e
arranjadas uma por linha, por defeito. Se e um valor diferente de zero for
passado como argumento alt as cadeias de texto são separadas por espaços
aon invés de linhas.

# floor
Resultado:  o mesmo tipo que o argumento
Argumento:  y (escalar, série ou matriz)

Consiste na função piso. Retorna o maior inteiro menor que ou igual x.
Note que "int" e floor possuem efeitos distintos em argumentos negativos:
int(-3.5) gera -3, enquanto floor(-3.5) gera -4.

# fracdiff
Resultado:  série
Argumentos: y (série)
            d (escalar)

Retorna a diferença fracionária de ordem d para a series y.

Note que teoricamente a diferenciação fracionária é um filtro
infinitamente longo. Na prática, valores antes da amostra de y_t são
assumidos com sendo iguais a zero.

É possível utilizar valores de d negativos. Nesse caso é realizada a
integração fracionária.

# fzero
Resultado:  escalar
Argumentos: fcall (chamada a função)
            init (escalar ou vetor, opcional)
            toler (escalar, opcional)

Tenta encontrar a raiz unitária de uma função coninua (tipicamente
não-linear) f, que é uma variável escalar x tal que f(x) = 0. O argumento
fcall deve chamar a função em causa; fcall pode incluir um número
arbitrário de argumentos, mas o primeiro tem que ser um escalar actuando
com x. Em caso de sucesso, a função retorna o valor da raiz.

O método utilizado é o de Ridders (1979). Isto necessita de um intervalo
inicial {x_0, x_1} tal que ambos os valores pertençam ao domínio da
função e as respectivas imagens sejam de sinais opostos. Será mais
provável obter melhores resultados, se o utilizador fornecer como segundo
argumento, um vector cujos componentes sejam os valores extremos do
intervalo. Se não for assim, pode-se fornecer um único valor escalar e
fzero tentará encontrar um intervalo adequado. Se o segundo argumento fôr
omitido, x_0 é inicializado com um valor positivo pequeno e nós procuramos
um valor adequado para x_1.

O argumento opcional toler pode ser utilizado para ajustar a diferença
máxima aceitável de f(x) de zero, sendo o valor por defeito 1.0e-14.

Por defeito esta função opera silenciosamente, mas o progresso do processo
iteractivo pode ser exposto usando o comando "set max_verbose on" antes de
chamar fzero.

Seguem-se alguns simples exemplos:

	  # Aproximação de Pi pesquisando um zero da 
	  # função sin() no intervalo 2.8 a 3.2
	  x = fzero(sin(x), {2.8, 3.2})
	  printf "\nx = %.12f vs pi = %.12f\n\n", x, $pi

	  # Aproximação da 'constante Omega' partindo de x=0.5
	  function scalar f(scalar x)
	  return log(x) + x
	  end function
	  x = fzero(f(x), 0.5)
	  printf "x = %.12f f(x) = %.15f\n", x, f(x)

# gammafun
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a função gama de x.

# genseries
Resultado:  escalar
Argumentos: varname (texto)
            rhs (série)

Permite que sejam geradas séries cujos nomes não são conhecidos a priori
e/ou que sejam criadas séries e adicionadas a uma lista utilizando apenas
uma única operação.

O primeiro argumento fornece o nome da série a ser criada (ou modificada) e
pode ser um texto literal, uma variável de texto (string), ou uma
expressão cujo resultado seja uma variável de texto. O segundo argumento,
rhs (abreviação em inglês de "lado direito"), define a fonte da série:
isto pode ser o nome de uma série existente ou uma expressão cujo
resultado seja uma série, da forma que aparece do lado direito do sinal de
igualdade quando se definem séries da forma usual.

O valor de retorno dessa função é o número ID das séries no conjunto de
dados, um valor que pode ser utilizado para incluir as séries em uma lista
(ou -1 caso a execução da função falhe).

Por exemplo, suponha que se queira adicionar n séries aleatórias com
distribuição normal ao conjunto de dados e colocá-las em uma lista. O
código a seguir fará isso:

	  list Normals = null
	  loop i=1..n --quiet
	      Normals += genseries(sprintf("norm%d", i), normal())
	  endloop

Ao término da execução a lista Normals irá conter as séries norm1,
norm2 e assim sucessivamente.

# geoplot
Resultado:  nada
Argumentos: mapfile (texto)
            payload (série, opcional)
            options (lote, opcional)

Chama a produção de um mapa, quando existem dados geográficos
apropriados. Na maior parte dos casos o argumento mapfile deve ser dado como
"$mapfile", um acessor que obtém o nome relevante do ficheiro GeoJSON ou do
ficheiro de formas ESRI. O argumento opcional payload é usado para fornecer
o nome de uma série com a qual se coloriza as regiões do mapa. E o
argumento final options como bundle permite você definir inúmeras
opções.

Veja a documentação do geoplot, geoplot.pdf, para mais detalhes e
exemplos. Aqui se explica todas as configurações por via do argumento
options.

# getenv
Resultado:  texto
Argumento:  s (texto)

Se uma variável de ambiente de nome s estiver definida a função retorna
uma variável com o texto dessa variável, caso contrário, retorna um texto
vazio. Veja também "ngetenv".

# getinfo
Resultado:  lote
Argumento:  y (série)

Retorna, na forma de um pacote (bundle) informações sobre a série
especificada, o que pode ser feito por meio de seu nome ou de seu número
ID. O pacote retornado contém os atributos que podem ser definidos via
comando "setinfo". Ele também contém informações relevantes adicionais
das séries que tenham sido criadas por meio de transformações nos dados
primários (defasagens, logs, etc.): isso inclui o nome do comando do Gretl
para a transformação sob código "transform" e o nome da série primária
associada sob o código "parent". Para séries defasadas, o número
específico de defasagens pode ser encontrado sob o código "lag".

Exemplo de utilização:

	  open data9-7
	  lags QNC
	  bundle b = getinfo(QNC_2)
	  print b

Ao executar o código acima tem-se:

	  has_string_table = 0
	  lag = 2
	  parent = QNC
	  name = QNC_2
	  graph_name =
	  coded = 0
	  discrete = 0
	  transform = lags
	  description = = QNC(t - 2)

Para verificar se a série 5 no conjunto de dados é um termo defasado
pode-se proceder da seguinte forma:

	  if getinfo(5).lag != 0
	     printf "a série 5 é uma defasagem de %s\n", getinfo(5).parent
	  endif

Deve-se ter em mente que a notação ponto (.) para acessar os membros do
pacote pode ser utilizada mesmo este seja "anônimo" (ou seja, armazenado
sem seu próprio nome).

# getkeys
Resultado:  cadeia de texto
Argumento:  b (lote)

Retorna um vetor de textos contendo os códigos que identificam os
conteúdos de b. Se o pacote (bundle) estiver vazio é retornado um vetor
também vazio.

# getline
Resultado:  escalar
Argumentos: source (texto)
            target (texto)

Essa função lê sucessivamente as linhas de source, que deve ser uma
variável de texto (string). A cada chamada uma linha do texto é escrita em
target (que também deve ser uma variável de texto) com o caractere de nova
linha removido. O valor retornado é 1, se existir algo a ser lido
(incluindo-se linhas em branco), ou 0, se todas as linhas de source tiverem
sido lidas.

A seguir é apresentado um exemplo onde o conteúdo de um arquivo de texto
é dividido em linhas:

	  string s = readfile("data.txt")
	  string line
	  scalar i = 1
	  loop while getline(s, line)
	      printf "line %d = '%s'\n", i++, line
	  endloop

Neste exemplo pode-se ter a certeza de que o texto foi exaurido quando o
loop terminar. Se não for desejado exaurir todas as linhas do texto pode-se
chamar a função getline, sendo que sucessivas chamadas substituirão o
conteúdo de target pela nova linha lida. Para reiniciar a leitura a partir
da primeira linha de source basta utilizar null no argumento target (ou
apenas deixá-lo em branco). Exemplos:

	  getline(s, line) # recupera uma única linha
	  getline(s, null) # reinicia a leitura

Note que apesar de a posição de leitura avançar em cada chamada de
getline, o argumento source não é modificado por essa função, apenas
target é alterado.

# ghk
Resultado:  matriz
Argumentos: C (matriz)
            A (matriz)
            B (matriz)
            U (matriz)
            &dP (referência a matriz, ou null)

Calcula a aproximação GHK (Geweke, Hajivassiliou, Keane) para a função
de distribuição normal multivariada. Veja, por exemplo, Geweke (1991). O
valor retornado é um vetor de probabilidades de ordem n x 1.

O argumento C (m x m) deve fornecer o fator de Cholesky (triangular
inferior) da matriz de covariância de m variáveis normais. Ambos os
argumentos A e B devem ser de ordem n x m, fornecendo, respectivamente, os
limites inferior e superior aplicados às variáveis em cada uma das n
observações. Quando as variáveis não possuírem limites é necessário
que tal característica seja indicada através da constante "$huge" ou de
sua negativa.

A matriz U deve ter ordem m x r, sendo r o número de elementos
pseudo-aleatórios extraídos da distribuição uniforme. Funções
convenientes para a criação de U são "muniform" e "halton".

A seguir encontra-se um caso relativamente simples onde as probabilidades
multivariadas podem ser calculada de forma analítica. As séries P e Q
devem ser numericamente muito similares entre si, sendo P a probabilidade
"verdadeira" e Q sua aproximação GHK:

	  nulldata 20
	  series inf1 = -2*uniform()
	  series sup1 = 2*uniform()
	  series inf2 = -2*uniform()
	  series sup2 = 2*uniform()

	  scalar rho = 0.25
	  matrix V = {1, rho; rho, 1}

	  series P = cdf(D, rho, inf1, inf2) - cdf(D, rho, sup1, inf2) \
	  - cdf(D, rho, inf1, sup2) + cdf(D, rho, sup1, sup2)

	  C = cholesky(V)
	  U = halton(2, 100)

	  series Q = ghk(C, {inf1, inf2}, {sup1, sup2}, U)

O argumento opcional dP pode ser usado para recuperar a matriz n x k de
derivadas das probabilidades, onde k é igual a 2m + m (m + 1)/2. As
primeiras m colunas contêm as derivadas em relação aos limites
inferiores, as próximas m as derivadas em relação aos limites superiores
e as colunas restantes as derivadas em relação aos elementos únicos da
matriz C na ordem "vech".

# gini
Resultado:  escalar
Argumento:  y (série ou vetor)

Retorna o índice de desigualdade de Gini para a série ou o vetor (não
negativos). Um valor de Gini igual a zero indica igualdade perfeita. O valor
máximo de Gini para uma série com n elementos é (n - 1)/n, ocorrendo
quando apenas um membro possui um valor positivo. Um Gini igual a 1,0 é,
dessa forma, o limite aproximado por uma grande série com desigualdade
máxima y.

# ginv
Resultado:  matriz
Argumento:  A (matriz)

Retorna A^+, a Moore-Penrose ou inversa generalizada de A, calculada via
decomposição em valores singulares.

Essa matriz possui as seguintes propriedades: A A^+ A = A and A^+ A A^+ =
A^+. Além disso, os produtos A A^+ e A^+ A são simétricos por
construção.

Ver também"inv", "svd".

# GSSmax
Resultado:  escalar
Argumentos: &b (referência a matriz)
            f (chamada a função)
            toler (escalar, opcional)

Maximização de unidimensional via método Golden Section Search (GSS). A
matriz b deve ser um vetor de ordem 3. Na entrada o primeiro elemento é
ignorado enquanto que o segundo e o terceiro elementos determinam os limites
inferior e superior da busca. O argumento fncall deve especificar a chamada
a uma função que retorna o valor da variável a ser maximizada. O elemento
1 de b, que irá armazenar o valor corrente do parâmetro ajustável quando
a função for chamada, deve ser determinado como seu primeiro argumento.
Quaisquer argumentos requeridos podem então ser incluídos em seguida. A
função em questão de ser unimodal (ou seja, não deve possuir máximos
locais, apenas o máximo global) ao longo da amostra estipulada, caso
contrário não se pode garantir que o GSS irá encontrar o máximo.

Ao ser executada com sucesso GSSmax retorna o valor ótimo da variável a
ser maximizada, enquanto b armazena o valor do parâmetro ótimo juntamente
dos limites de seu intervalo.

O terceiro argumento, que é opcional, pode ser utilizado para ajustar a
convergência, isto é, a largura máxima aceitável do intervalo final do
parâmetro. Se esse argumento não for fornecido, será utilizado o valor
0,0001.

Se o objetivo é de fato a minimização, a chamada à função deve
retornar o critério com o sinal negativo. Alternativamente, ao invés de se
utilizar GSSmax pode-se utilizar a função GSSmin.

Exemplo de utilização:

      function scalar trigfunc (scalar theta)
          return 4 * sin(theta) * (1 + cos(theta))
      end function

      matrix m = {0, 0, $pi/2}
      eval GSSmax(&m, trigfunc(m[1]))
      printf "\n%10.7f", m

# GSSmin
Resultado:  escalar

É uma forma alternativa da função "GSSmax". Se invocada com este nome a
função comporta-se como minimizadora.

# halton
Resultado:  matriz
Argumentos: m (número inteiro)
            r (número inteiro)
            offset (número inteiro, opcional)

Retorna uma matriz m x r contendo m sequências de Halton de comprimento r.
O m é limitado a um máximo de 40. As sequências são construídas
utilizando os primeiros m primos. Por padrão os primeiros 10 elementos de
cada sequência são descartados, mas isso pode ser ajustado via argumento
opcional offset, que deve ser um número inteiro não negativo. Maiores
detalhes podem ser encontrados em Halton e Smith (1964).

# hdprod
Resultado:  matriz
Argumentos: X (matriz)
            Y (matriz)

Calcula o produto direto horizontal. Os dois argumentos devem ter o mesmo
número de linhas, r. O valor retornado é uma matriz com r linhas, onde a
i-ésima linha corresponde ao produto de Kronecker das linhas
correspondentes de X e Y.

Esta operação é chamada de "produto horizontal direto" em conformidade
com sua implementação na linguagem de programação GAUSS. Sua equivalente
na álgebra linear padrão seria chamada de produto linha a linha de
Khatri-Rao.

Exemplo: o código

	  A = {1,2,3; 4,5,6}
	  B = {0,1; -1,1}
	  C = hdprod(A, B)

produz a seguinte matriz:

          0    1    0    2    0    3
         -4    4   -5    5   -6    6

# hfdiff
Resultado:  lista
Argumentos: hfvars (lista)
            multiplier (escalar)

Dada uma "MIDAS list", produz uma lista com o mesmo tamanho contendo as
primeiras diferenças de alta frequência. O segundo argumento é opcional e
tem como valor padrão 1: ele pode ser utilizado para multiplicar as
diferenças por alguma constante.

# hfldiff
Resultado:  lista
Argumentos: hfvars (lista)
            multiplier (escalar)

Dada uma "MIDAS list", produz uma lista com o mesmo tamanho contendo as
diferenças logarítmicas de alta frequência. O segundo argumento é
opcional e tem como valor padrão 1: ele pode ser utilizado para multiplicar
as diferenças por alguma constante. Um exemplo da utilização desse
argumento é utilizar o valor 100 para obter as variações percentuais
(aproximadas).

# hflags
Resultado:  lista
Argumentos: minlag (número inteiro)
            maxlag (número inteiro)
            hfvars (lista)

Dada uma "MIDAS list", hfvars, produz uma lista contendo as defasagens de
auta frequência de minlag a maxlag. Deve-se utilizar valores positivos para
defasagens ( t - 1) e negativos para adiantamentos (t + 1). Por exemplo, se
minlag for -3 e maxlag for 5 então a lista retornada irá conter 9 séries:
3 adiantamentos, o valor atual e 5 defasagens.

Note que a defasagem de alta frequência 0 corresponde ao primeiro período
de alta frequência dentro de um período de baixa frequência, por exemplo,
o primeiro mês de um trimestre ou o primeiro dia de um mês.

# hflist
Resultado:  lista
Argumentos: x (vetor)
            m (número inteiro)
            prefix (texto)

Produz a partir de um vetor x uma lista MIDAS ("MIDAS list") de m séries,
onde m é a razão entre a frequência das observações para a variável em
x em relação a frequência base do conjunto de dados corrente. O valor de
m deve ser ao menos 3 e o comprimento de x deve ser m vezes o comprimento da
amostra selecionada corrente.

Os nomes das séries na lista retornada são definidos a partir de um dado
prefixo, dado pelo argumento prefix (este deve ser um texto ASCII com 24 ou
menos caracteres e que seja um identificador válido para o Gretl) mais 1 ou
mais prefixos representando o subperíodo da observação. Um erro será
apresentado se algum desses nomes seja idêntico a nomes de objetos já
existentes.

# hpfilt
Resultado:  série
Argumentos: y (série)
            lambda (escalar, opcional)
            one-sided (booleano, opcional)

Retorna o componente cíclico do filtro de Hodrick-Prescott aplicado à
série y. Se o parâmetro de suavização lambda não for fornecido o Gretl
usará valores padrão com base na periodicidade dos dados. O parâmetro
será igual a 100 vezes o quadrado da periodicidade (100 para dados anuais,
1600 para dados trimestrais, 14400 para dados mensais, etc.).

Por padrão o filtro é a versão bilateral, "two-sided", mas se o terceiro
argumento (opcional) for um valor diferente de zero é computada a versão
unilateral, "one-sided", (de forma não prospectiva) é computada na forma
proposta por Stock and Watson (1999).

O uso mais comum do filtro HP é a retirada de tendência de séries, mas se
o interesse for pela tendência em si, basta utilizar a seguinte expressão:

	  series hptrend = y - hfilt(y)

Ver também"bkfilt", "bwfilt".

# hyp2f1
Resultado:  escalar ou matriz
Argumentos: a (escalar)
            b (escalar)
            c (escalar)
            x (escalar ou matriz)

Retorna a função hipergeométrica de Gauss para o argumento real x.

Se x é um escalar, a função retorna um escalar; se não, o resultado
será uma matriz com a mesma dimensão que o argumento x.

# I
Resultado:  matriz
Argumento:  n (número inteiro)

Retorna uma matriz identidade com n linhas e colunas.

# Im
Resultado:  matriz
Argumento:  C (matriz complexa)

Retorna uma matriz real com a mesma dimensão que C, contendo a parte
imaginária da matriz de entrada. Ver também "Re".

# imaxc
Resultado:  vetor linha
Argumento:  X (matriz)

Retorna um vetor com os números das linhas onde as colunas de X atingem
seus valores máximos.

Ver também"imaxr", "iminc", "maxc".

# imaxr
Resultado:  vetor coluna
Argumento:  X (matriz)

Retorna um vetor com os números das colunas onde as linhas de X atingem
seus valores máximos.

Ver também"imaxc", "iminr", "maxr".

# imhof
Resultado:  escalar
Argumentos: M (matriz)
            x (escalar)

Calcula Prob(u'Au < x) para uma forma quadrática em variáveis normais
padrão, u, utilizando o procedimento desenvolvido por Imhof (1961).

Se o primeiro argumento, M, for uma matriz quadrada ela será utilizada para
especificar A, caso contrário, se for um vetor coluna, será utilizada como
sendo os autovalores pré-calculados de A, caso contrário um erro será
apresentado.

Ver também"pvalue".

# iminc
Resultado:  vetor linha
Argumento:  X (matriz)

Retorna um vetor com os números das linhas onde as colunas de X atingem
seus valores mínimos.

Ver também"iminr", "imaxc", "minc".

# iminr
Resultado:  vetor coluna
Argumento:  X (matriz)

Retorna um vetor com os números das colunas onde as linhas de X atingem
seus valores mínimos.

Ver também"iminc", "imaxr", "minr".

# inbundle
Resultado:  número inteiro
Argumentos: b (lote)
            key (texto)

Verifica se um pacote (bundle) b contém um item com o nome key. O valor
retornado é um código (na forma de um número inteiro) para o tipo de
item: 0 caso não seja encontrado, 1 para escalar, 2 para série,3 para
matriz, 4 para variável de texto, 5 para pacote (bundle) e 6 para arranjo
(array). A função "typestr" pode ser utilizada para se obter o nome do
tipo do item na forma de variável de texto com base em seu código.

# infnorm
Resultado:  escalar
Argumento:  X (matriz)

Retorna a norma infinito de X, isto é, o máximo ao longo das linhas de X
da soma dos valores absolutos dos elementos da linha.

Ver também"onenorm".

# inlist
Resultado:  número inteiro
Argumentos: L (lista)
            y (série)

Retorna a posição de y na lista L, ou 0 se y não estiver presente em L.

O segundo argumento pode ser dado tanto como o nome da série quanto como o
número ID da série. Se é sabido que uma série com dado nome (como por
exemplo foo) existe, então é possível chamar essa função da seguinte
forma:

	  pos = inlist(L, foo)

O que a expressão acima está solicitando é: "Informe a posição da
série foo na lista L (sendo 0 se ela não estiver incluída na lista L)".
Entretanto, se não houver certeza se a série com dado nome existe, deve-se
inserir o nome entre aspas. Isso é feito da seguinte forma:

	  pos = inlist(L, "foo")

Neste caso o que está sendo solicitado é: "Se existir uma série chamada
foo na lista L, me informe sua posição ou 0 caso ela não exista."

# instring
Resultado:  número inteiro
Argumentos: s1 (texto)
            s2 (texto)

Função booleana relacionada à "strstr". Retorna 1 se s1 contiver s2, 0
caso contrário. Assim, a expressão condicional

      if instring("cattle", "cat")

é logicamente equivalente a, mas mais eficiente que,

      if strlen(strstr("cattle", "cat")) > 0

# instrings
Resultado:  matriz
Argumentos: S (cadeia de texto)
            test (texto)

Verifica quais os elementos do arranjo de texto em S são iguais a test.
Retorna um vector de comprimento igual ao número de igualdades, contendo as
posições correspondentes dentro do arranjo; ou uma matriz vazia em caso de
não haver correspondências.

Exemplo:

	  strings S = defarray("A", "B", "C", "B")
	  eval instrings(S, "B")
	  2
	  4

# int
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a parte inteira x, truncando a parte fracional. Note que int e
"floor" possuem efeitos distintos em argumentos negativos: int(-3.5) gera
-3, enquanto floor(-3.5) gera -4. Ver também"ceil".

# inv
Resultado:  matriz
Argumento:  A (matriz quadrada)

Retorna a inversa de A. Se A for singular ou não quadrada, uma mensagem de
erro é produzida e nada é retornado. Note que o Gretl confere
automaticamente a estrutura de A e utiliza o procedimento numérico mais
eficiente para realizar a inversão.

Os tipos de matriz que o Gretl confere são: identidade, diagonal,
simétrica e positiva definida, simétrica mas não positiva definida e
triangular.

Observação: faz sentido utilizar essa função apenas se o intuito for
utilizar a inversa de A mais de uma vez. Se o objetivo for apenas calcular
uma expressão da forma A^-1B, será preferível utilizar os operadores de
"divisão" \ e /. Veja guia de utilização do Gretl (Capítulo 17) para
detalhes.

Ver também"ginv", "invpd".

# invcdf
Resultado:  o mesmo tipo que o argumento
Argumentos: d (texto)
            ... (ver abaixo)
            p (escalar, série ou matriz)

Calculadora da função de distribuição acumulada inversa. Retorna x tal
que P(X <= x) = p, onde a distribuição de X é especificada pela letra d.
Entre os argumentos d e p, zero ou mais argumentos adicionais são
necessários para que se especifique os parâmetros da distribuição. Isso
é feito da seguinte forma:

  Normal padrão (c = z, n ou N): sem argumentos extras

  Gama (g ou G): forma; escala

  t de Student (t): graus de liberdade

  Qui-quadrado (c, x ou X): graus de liberdade

  F de Snedecor F (f ou F): graus de liberdade (num.); graus de liberdade
  (den.)

  Binomial (b ou B): probabilidade; tentativas

  Poisson (p ou P): média

  Laplace (l ou L): média; escala

  GED padronizada (E): forma

  Qui-quadrado não-central (ncX): graus de liberdade, parâmetro de
  não-centralidade

  F não-central (ncF): graus de liberdade (num.), graus de liberdade
  (den.), parâmetro de não-centralidade

  t não-central (nct): graus de liberdade, parâmetro de não-centralidade

Ver também"cdf", "critical", "pvalue".

# invmills
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a razão inversa de Mills em x, isto é a razão entre a densidade
normal padrão e o complemento para para a função de distribuição normal
padrão, ambas avaliadas em x.

Essa função utiliza um algoritmo dedicado que fornece maior precisão
quando comparado ao cálculo via "dnorm" e "cnorm", mas a diferença entre
os dois métodos é considerável apenas para valores muito negativos de x.

Ver também"cdf", "cnorm", "dnorm".

# invpd
Resultado:  matriz quadrada
Argumento:  A (matriz positiva definida)

Retorna a inversa da matriz simétrica positiva definida A. Essa função é
ligeiramente mais rápida que "inv" para matrizes grandes, uma vez que não
é verificado se a matriz é simétrica. Por essa razão, essa função deve
ser utilizada com cuidado.

Observação: se o intuito for inverter uma matriz na forma X'X, onde X é
uma matriz grande, é preferível computá-la via operador X'X ao invés de
utilizar a sintaxe mais geral X'*X. A primeira expressão utiliza um
algoritmo especializado que tem a dupla vantagem de ser mais eficiente
computacionalmente e de garantir que o resultado seja livre, por
construção, dos artefatos de precisão de máquina que podem torná-la
numericamente não-simétrico.

# irf
Resultado:  matriz
Argumentos: target (número inteiro)
            shock (número inteiro)
            alpha (escalar entre 0 e 1, opcional)
            sys (lote, opcional)

Sem utilizar o argumento sys, opcional, essa função está disponível
apenas quando o último modelo estimado foi um VAR ou um VECM.
Alternativamente, as informações de uma VAR ou VECM podem ser armazenadas
em um pacote via função "$system" que, por sua vez, pode ser utilizado
como o último argumento.

Ela retorna uma matriz contendo as respostas estimadas da variável target a
um impulso (choque) de 1 desvio padrão na variável shock. Essas variáveis
são identificadas de acordo com suas posições na especificação do
modelo: por exemplo, se para target e shock são dados os valores 1 e 3,
respectivamente, a matriz que será retornada fornece as respostas da
primeira variável no sistema a um choque na terceira variável.

Se o terceiro argumento alpha, que é opcional, for dado, a matriz retornada
terá três colunas: a estimativa pontual das respostas, seguida dos limites
inferior e superior de um intervalo de confiança obtido via bootstrap de 1
- α. Onde alpha = 0.1 corresponde a 90 por cento de confiança. Se alpha
for omitido ou igualado a zero, apenas a estimativa pontual será fornecida.

O número de períodos (linhas) da resposta é determinado automaticamente
com base na frequência dos dados, mas isso pode ser ajustado via comando
"set", como por exemplo set horizon 10.

Ver também"fevd".

# irr
Resultado:  escalar
Argumento:  x (série ou vetor)

Retorna a Taxa Interna de Retorno para x, considerado como sendo uma
sequência de pagamentos (negativo) e recebimentos (positivo). Ver
também"npv".

# iscomplex
Resultado:  escalar
Argumento:  nome (texto)

Retorna 1 se nome é o nome de uma matriz complexa, 0 se é o nome de uma
matriz real, ou NA se nenhum dos dois.

# isconst
Resultado:  número inteiro
Argumentos: y (série ou vetor)
            panel-code (número inteiro, opcional)

Sem o segundo argumento (opcional), retorna 1 caso y tenha um valor
constante ao longo da amostra selecionada (ou ao longo de toda sua extensão
no caso de y ser um vetor), caso contrário retorna 0.

O segundo argumento somente é aceito se o conjunto de dados corrente for um
painel e y for uma série. Neste caso um valor de panel-code igual a 0 faz a
função verificar se a série não varia em relação ao tempo. Um valor
igual a 1 faz a função verificar se a série não varia entre as unidades
de corte transversal (ou seja, se o valor de y é o mesmo para todos os
grupos).

Se y for uma série, valores ausentes são ignorados durante a verificação
da constância da série.

# isdiscrete
Resultado:  número inteiro
Argumento:  name (texto)

Se name for um identificador para uma série correntemente definida, a
função retorna 1 se a série for marcada como sendo discreta, caso
contrário retorna 0. Se name não identifica uma série a função retorna
NA.

# isdummy
Resultado:  número inteiro
Argumento:  x (série ou vetor)

Se todos os valores contidos em x são iguais a 0 ou 1 (ou ausentes), a
função retorna o número de ocorrências do valor 1, caso contrário
retorna 0.

# isnan
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar ou matriz)

Dado um escalar como argumento, retorna 1 se x não for um número, "Not a
Number" (NaN), caso contrário 0. Dada uma matriz como argumento, retorna
uma matriz com a mesma dimensão com elementos iguais a 1 nas posições
onde o elemento correspondente da matriz de entrada for NaN e 0 nas demais
posições.

# isoconv
Resultado:  escalar
Argumentos: date (série)
            &year (referência a série)
            &month (referência a série)
            &day (referência a série, opcional)

Dada uma série date contendo datas no formato ISO 8601 "básico"
(YYYYMMDD), essa função escreve os componentes ano, mês e (opcionalmente)
dia em séries nomeadas pelos argumentos year, month e dayecond. Um exemplo,
assumindo que a série dates contém os valores adequados de 8 dígitos,
seria:

	  series y, m, d
	  isoconv(dates, &y, &m, &d)

Essa função retorna 0 em caso de sucesso e um valor não-nulo em caso de
erro.

# isocountry
Resultado:  o mesmo tipo que o argumento
Argumentos: país (texto ou cadeia de texto)
            tipo (número inteiro, opcional)

Esta função produz a correspondência da designação dos países segundo
os quatro modos previstos na norma ISO 3166, que são

1. Nome do país (em Inglês)

2. Código Alfa-2 (duas letras maiúsculas)

3. Código Alfa-3 (três letras maiúsculas)

4. Código numérico (com três digitos)

Partindo de uma das quatro formas, a função retorna o código do país
conforme a opção tipo, que deve estar entre 1 e 4; se o argumento for
omitido, a conversão é como se segue: quando o país é o nome de um
país, o valor de retorno é o código Alfa-2; noutro casos, é retornado o
nome do país. Adiante mostra-se várias chamadas válidas:

	  ? eval isocountry("Bolivia")
	  BO
	  ? eval isocountry("Bolivia", 3)
	  BOL
	  ? eval isocountry("GB")
	  United Kingdom of Great Britain and Northern Ireland
	  ? eval isocountry("GB", 3)
	  GBR
	  ? strings S = defarray("ES", "DE", "SD")
	  ? strings C = isocountry(S)
	  ? print C
	  Array of strings, length 3
	  [1] "Spain"
	  [2] "Germany"
	  [3] "Sudan"
	  ? matrix m = {4, 840}
	  ? C = isocountry(m)
	  ? print C
	  Array of strings, length 2
	  [1] "Afghanistan"
	  [2] "United States of America"

O argumento país na forma 4 (código numérico), pode estar contido numa
cadeia de texto ou num arranjo de texto (por exemplo, "032" para a
Argentina), ou como uma variável numérica. Neste caso, país pode ser uma
série ou um vector, mas a função dará erro se algum dos valores estiver
for do intervalo entre 0 e 999.

Em qualquer dos casos (mesmo quando o modo 4 é selecionado) é retornado
uma cadeia de texto ou um arranjo de texto; se são necessários valores
numéricos, estes podem ser obidos usando a função "atof". Se o país não
for encontrado na tabela ISO 3166, o valor retornado é uma cadeia de texto
vazia e é mostrado um aviso.

# isodate
Resultado:  ver abaixo
Argumentos: ed (escalar ou série)
            as-string (booleano, opcional)

O argumento ed é interpretado como um dia na época corrente (que por sua
vez é igual a 1 para o primeiro dia de janeiro do ano 1 depois de Cristo,
no calendário gregoriano proléptico). O valor padrão de retorno -- de
mesmo tipo que o de ed -- é um número com 8 dígitos, ou uma série
composta por tais números, seguindo o padrão YYYYMMDD (formato ISO 8601
"básico"), fornecendo a data correspondente no calendário gregoriano ao
dia na época.

Se ed for (apenas) um escalar e o segundo argumento opcional as-string for
não-nulo, o valor de retorno não é numérico mas sim uma variável de
texto (string) no padrão YYYY-MM-DD (padrão ISO 8601 "estendido").

Para a função inversa veja "epochday". Veja também a função "juldate".

# isoweek
Resultado:  ver abaixo
Argumentos: ano (escalar ou série)
            mês (escalar ou série)
            dia (escalar ou série)

Retorna o número da semana segundo o padrão ISO 8601, correspondente à
data especificada nos três argumentos, ou NA se a data não é válida.
Note-se que todos os três argumentos têm que ser do mesmo tipo, sejam
escalares (inteiros) ou séries.

As semanas ISO são numeradas de 01 a 53; a maior parte dos anos têm 52,
mas em média, em 400 anos, 71 têm 53 semanas. De acordo com a definição
ISO 8601, a semana 01 é aquela que contém a primeira quinta-feira do ano,
seguindo o calendário Gregoriano. Para mais detalhes, ver
https://en.wikipedia.org/wiki/ISO_week_date.

# iwishart
Resultado:  matriz
Argumentos: S (matriz simétrica)
            v (número inteiro)

Dado S (uma matriz de ordem p x p positiva definida), retorna um valor
extraído da distribuição Inversa de Wishart com v graus de liberdade. A
matriz retornada é também uma p x p. O algoritmo de Odell e Feiveson
(1966) é utilizado.

# jsonget
Resultado:  texto
Argumentos: buf (texto)
            path (texto)
            nread (referência a escalar, opcional)

O argumento buf deve ser um buffer JSON, que ser obtido de alguma página na
internet via função "curl", e o argumento path deve ser uma
especificação JsonPath.

Esta função retorna uma variável de texto (string) representando os dados
encontrados no buffer no path especificado. Dados do tipo double (ponto
flutuante), int (inteiro) e string (variável de texto) são suportados. No
caso de doubles ou ints, sua representação em forma de texto é retornada
(utilizando o locale "C" para os doubles). Se o objeto ao qual o path se
refere for um arranjo (array), cada um dos membros será escrito em uma
linha diferente na variável de texto retornada.

Por padrão, um erro será sinalizado se o path não possuir uma
correspondência no buffer JSON, porém esse comportamento pode ser
modificado se o terceiro argumento, opcional, for dado: nesse caso o
argumento recupera o número de correspondências e uma variável de texto
vazia é retornada caso nenhuma tenha sido encontrada. Por exemplo:

	  ngot = 0
	  ret = jsonget(jbuf, "$.some.thing", &ngot)

Apesar disso, um erro ainda será sinalizado no caso de uma consulta (query)
mal formulada.

Para maiores detalhes sobre a sintaxe do JsonPath pode-se consultar o
website http://goessner.net/articles/JsonPath/. Entretanto, deve-se notar
que o back-end para o jsonget é fornecido pelo json-glib que, por sua, vez
não suporta todos os elementos do JsonPath. Além disso, a funcionalidade
exata do json-glib pode diferir dependendo da versão instalada no sistema.
Para maiores detalhes ver: http://developer.gnome.org/json-glib/

Dito isto, os seguintes operadores deverão estar disponíveis para jsonget:

  root node, via caractere $

  operador descendente recursivo: ..

  operador curinga/wildcard: *

  operador subscrito: []

  operador de notação de conjunto, por exemplo [i,j]

  operador de repartição: [start:end:step]

# jsongetb
Resultado:  lote
Argumentos: buf (texto)
            path (texto, opcional)

O argumento buf deve ser um buffer JSON que, por sua vez, pode ser obtido de
um website apropriado via função "curl". A especificação e a
utilização do argumento opcional path, são descritos abaixo.

O valor retornado pela função é um pacote (bundle) em que a estrutura
basicamente emula a da entrada: objetos JSON se tornam pacotes (bundles) do
Gretl e arrays JASON se tornam arranjos (arrays) do Gretl, com cada um
armazenando tanto textos (strings) quanto pacotes (bundles). Nós de "valor"
JSON se tornam ou membros de pacotes ou elementos de arranjos. No último
caso, valores numéricos são convertidos em texto via função sprintf.
Note que uma vez que arranjos do Gretl não podem ser aninhados, a entrada
aceita por essa função é um pouco mais restritiva que a especificação
JSON, que permite aninhamento de arrays.

O argumento opcional path pode ser utilizado para limitar os elementos JSON
incluídos no bundle retornado. Note que isto não é um "JsonPath" conforme
descrito na ajuda da função "jsonget". É uma simples construção sujeita
às seguintes especificações:

  path é um array de elemento separados por barras, onde as barras ("/")
  indicam a movimentação em um nível mais "profundo" na árvore JSON
  representada por buf. Uma barra no início é permitida, mas não é
  necessária. Implicitamente o path sempre tem início na raiz. Não devem
  ser incluídos espaços em branco

  Cada elemento separado por barras deve assumir uma das seguintes formas:
  (a) um nome único, de forma que apenas um elemento JSON cujo nome
  coincide com um dado nível estrutural será incluído; ou (b) "*"
  (asterisco), de forma que todos os elementos de um dado nível são
  incluídos; ou (c) um array de nomes separados por vírgulas, delimitados
  por colchetes ("{" e "}"), de forma que apenas os elementos JSON cujos
  nomes coincidam com algum dos nomes dados serão incluídos.

Veja também a função orientada à textos "jsonget". A depender de seu
objetivo uma dessas funções pode ser mais útil que a outra.

# juldate
Resultado:  ver abaixo
Argumentos: ed (escalar ou série)
            as-string (booleano, opcional)

O argumento ed é interpretado como um dia de época que é igual a 1 no
primeiro dia de janeiro do ano 1 depois de Cristo no calendário gregoriano
proléptico. O valor de retorno padrão -- do mesmo tipo de ed -- é um
número de 8 dígitos, ou uma série de tais números, seguindo o padrão
YYYYMMDD (formato ISO 8601 "básico"), fornecendo a data correspondente ao
dia de época no calendário juliano.

Se ed for (apenas) um escalar e o segundo parâmetro as-string (que é
opcional) for não-nulo, o valor retornado não será numérico e sim um
texto (string) seguindo o padrão YYYY-MM-DD (formato ISO 8601 "estendido").

Veja também "isodate".

# kdensity
Resultado:  matriz
Argumentos: x (série ou vetor)
            scale (escalar, opcional)
            control (booleano, opcional)

Calcula a estimativa de densidade pelo método do núcleo (kernel) para a
série ou vetor x. A matriz retornada tem duas colunas, com a primeira
contendo um conjunto abscissas uniformemente espaçadas e a segunda a
densidade estimada em cada um desses pontos.

O parâmetro opcional scale pode ser utilizado para ajustar o grau de
suavização em relação ao valor padrão 1.0 (maiores valores geram
resultados mais suavizados). O parâmetro control age como um booleano: 0
(que é o padrão) implica na utilização do núcleo gaussiano, enquanto
que um valor não-nulo implica na utilização do núcleo de Epanechnikov.

Um gráfico dos resultados pode ser obtido via comando "gnuplot", como por
exemplo:

	  matrix d = kdensity(x)
	  gnuplot 2 1 --matrix=d --with-lines --fit=none

# kdsmooth
Resultado:  escalar
Argumentos: &Mod (referência a lote)
            MSE (booleano, opcional)

Realiza a suavização dos distúrbios para um pacote (bundle) de Kalman
previamente definido via função "ksetup" e retorna 0 caso a execução
tenha sucesso ou 1 se se forem encontrados problemas numéricos.

Se a operação for completada com sucesso os distúrbios suavizados
estarão disponíveis como Mod.smdist.

O argumento opcional MSE determina os conteúdos de Mod.smdisterr. Se for
omitido ou for igual a 0, essa matriz irá conter os erros padrão
não-condicionais dos distúrbios suavizados que, por sua vez, normalmente,
são utilizados para calcular os chamados resíduos auxiliares. Caso
contrário, Mod.smdisterr irá conter a raiz do erro quadrado médio
estimado dos resíduos auxiliares em relação aos seus valores verdadeiros.

Para maiores detalhes veja guia de utilização do Gretl (Capítulo 36).

Ver também"ksetup", "kfilter", "ksmooth", "ksimul".

# kfilter
Resultado:  escalar
Argumento:  &Mod (referência a lote)

Realiza a filtragem em um pacote (bundle) de Kalman previamente definido via
"ksetup" e retorna 0 caso a execução tenha sucesso ou 1 se forem
encontrados problemas numéricos.

Se a operação for completada com sucesso os erros de previsão de 1 passo
à frente estarão disponíveis como Mod.prederr e a sequência de suas
variâncias como Mod.pevar. Além disso, Mod.llt dará acesso a um vetor de
ordem T contendo o log da verossimilhança por observação.

Para maiores detalhes veja guia de utilização do Gretl (Capítulo 36).

Ver também"kdsmooth", "ksetup", "ksmooth", "ksimul".

# kmeier
Resultado:  matriz
Argumentos: d (série ou vetor)
            cens (série ou vetor, opcional)

Dada uma amostra de dados de duração, d, possivelmente acompanhada por um
registro de status de censura, cens, calcula o estimador não-paramétrico
de Kaplan-Meier da função de sobrevivência (Kaplan e Meier, 1958). A
matriz retornada possui três colunas contendo, respectivamente, os valores
únicos de d de forma ordenada, a função de sobrevivência estimada
correspondente ao valor de duração na coluna 1 e o (elevado) erro padrão
do estimador, calculado via método de Greenwood (1926).

Se a série cens for dada, um valor 0 serve para indicar uma observação
não-censurada, enquanto que um valor 1 indica uma observação censurada à
direita (isto é, o período de observação do indivíduo em questão
terminou antes que a duração ou o período tenham sido registrados como
finalizados). Se cens não for dado é assumido que todas as observações
são não-censuradas. Observação: a interpretação de cens pode ser
estendida em algum momento de forma a cobrir outros tipos de censura.

Ver também"naalen".

# kpsscrit
Resultado:  matriz
Argumentos: T (escalar)
            trend (booleano)

Retorna um vetor linha contendo os valores críticos aos níveis de 10, 5 e
1 porcento do teste KPSS para a estacionariedade de uma série temporal. O
argumento T deve fornecer o número de observações e o argumento trend
deve ser igual a 1 se o teste inclui uma constante, ou 0, caso contrário.

Os valores críticos são baseados nas superfícies de resposta estimados
conforme sugerido por Sephton (Economics Letters,1995). Veja também o
comando "kpss".

# ksetup
Resultado:  lote
Argumentos: Y (série, matriz ou lista)
            H (escalar ou matriz)
            F (escalar ou matriz)
            Q (escalar ou matriz)
            C (matriz, opcional)

Especifica um pacote (bundle) de Kalman, isto é, um objeto que contém
todas as informações necessárias para se definir um modelo linear de
espaço de estados na forma

  y(t) = H'a(t)

e com a equação de transição de estados

  a(t+1) = F a(t) + u(t)

onde Var(u) = Q.

Objetos criados através dessa função podem ser posteriormente utilizados
via funções dedicadas "kfilter" para filtragem, "ksmooth" e "kdsmooth"
para suavização e "ksimul" para realizar simulações.

A amplitude de classes de modelos que o Gretl pode manusear é, de fato, bem
mais abrangente que o implicado pela representação acima: é possível a
estimação de modelos com parâmetros variando no tempo, com prioris
difusas, com variáveis exógenas na equação de medida e modelos com
resíduos interrelacionados. Para maiores detalhes veja guia de utilização
do Gretl (Capítulo 36).

Ver também"kdsmooth", "kfilter", "ksmooth", "ksimul".

# ksimul
Resultado:  escalar
Argumento:  &Mod (referência a lote)

Utiliza um pacote (bundle) de Kalman previamente definido através da
função "ksetup" para simular dados.

Para maiores detalhes veja guia de utilização do Gretl (Capítulo 36).

Ver também"ksetup", "kfilter", "ksmooth".

# ksmooth
Resultado:  matriz
Argumento:  &Mod (referência a lote)

Realiza uma suavização de ponto fixo em um pacote (bundle) de Kalman
previamente definido via função "ksetup" e retorna 0 caso a operação
tenha sido realizada com sucesso ou 1 se surgirem problemas numéricos.

Em caso de sucesso, os estados suavizados estarão disponíveis como
Mod.state e a sequência de suas matrizes de covariância como Mod.stvar.
Para maiores detalhes veja guia de utilização do Gretl (Capítulo 36).

Ver também"ksetup", "kdsmooth", "kfilter", "ksimul".

# kurtosis
Resultado:  escalar
Argumento:  x (série)

Retorna o excesso de curtose da série x, descartando quaisquer
observações ausentes.

# lags
Resultado:  lista ou matriz
Argumentos: p (escalar ou vetor)
            y (série, lista ou matriz)
            bylag (booleano, opcional)

Se o primeiro argumento for um escalar, gera as defasagens de 1 até p da
série y, se y for uma lista, retorna as defasagens de todas as séries na
lista e se for uma matriz, retorna as defasagens de todas as colunas na
matriz. Se p = 0 e y for uma série ou lista, são geradas defasagens até o
máximo da periodicidade dos dados. Caso contrário, o valor de p deve ser
positivo.

Se o primeiro argumento for um vetor, as defasagens serão aquelas
especificadas no vetor. Um uso típico neste caso seria fornecer p como, por
exemplo, seq(3,7), omitindo assim a primeira e a segunda defasagens.
Entretanto ambém é possível fornecer um vetor não contínuo como em
{3,5,7}, contanto que as defasagens estejam sempre ordenadas de forma
crescente.

Quando o valor retornado for uma lista, as variáveis geradas são nomeadas
automaticamente de acordo com o esquema varname_i, onde varname é o nome da
série original e i é a defasagem específica. A parte original do nome é
truncada, caso necessário, e pode ser ajustada no caso de
não-singularidade no conjunto de nomes assim construído.

Quando y for uma lista, ou uma matriz com mais de uma coluna, e a ordem de
defasagem for maior que 1, a ordenação padrão dos termos no valor
retornado pela função é feita por variável: todas as defasagens da
primeira série ou coluna seguida por todas as defasagens da segunda e assim
sucessivamente. O terceiro argumento (opcional) pode ser utilizado para
alterar esse comportamento: se bylag for não-nulo então os termos são
ordenados por defasagem: defasagem 1 de todas as séries ou colunas, seguida
pela defasagem 2 de todas as séries e colunas e assim sucessivamente.

Veja também "mlag" para o uso com matrizes.

# lastobs
Resultado:  número inteiro
Argumento:  y (série)

Retorna o número da última observação não ausente da série y. Note que
se alguma forma de subamostragem estiver sendo utilizada o valor retornado
poderá ser maior que o valor retornado pela função "$t2". Ver
também"firstobs".

# ldet
Resultado:  escalar
Argumento:  A (matriz quadrada)

Retorna o log natural do determinante de A, calculado via decomposição LU.
Ver também"det", "rcond", "cnumber".

# ldiff
Resultado:  o mesmo tipo que o argumento
Argumento:  y (série ou lista)

Calcula as diferenças logarítmicas. Os valores iniciais são considerados
como NA.

Quando uma lista for retornada, as variáveis individuais são
automaticamente nomeadas de acordo com o esquema ld_varname, onde varname é
o nome da série original. Se necessário, o nome será truncado e poderá
ser ajustado caso o nome resultante já esteja sendo utilizado pelo Gretl.

Ver também"diff", "sdiff".

# lincomb
Resultado:  série
Argumentos: L (lista)
            b (vetor)

Calcula uma nova série como uma combinação linear das séries na lista L.
Os coeficientes são dados pelo vetor b cujo tamanho deve ser igual ao
número de séries em series in L.

Ver também"wmean".

# linearize
Resultado:  série
Argumento:  x (série)

É necessário possuir o TRAMO instalado. Retorna uma versão "linearizada"
da série de entrada. Isto é, uma série onde quaisquer valores ausentes
são substituídos por valores interpolados e onde as observações
aberrantes são ajustadas. O mecanismo completamente automático do TRAMO é
usado para isso. Consulte a documentação do TRAMO para detalhes.

Note que se a série de entrada não possuir valores ausentes e e
observações aberrantes (conforme identificadas pelo TRAMO), a função
retornará uma cópia da série original.

# ljungbox
Resultado:  escalar
Argumentos: y (série)
            p (número inteiro)

Calcula a estatística Q de Ljung-Box para a série y, utilizando a ordem de
defasagem p, ao longo da amostra selecionada. A defasagem deve ser maior ou
igual a 1 e menor que o número de observações disponíveis.

Essa estatística pode ser testada contra a distribuição qui-quadrado com
p graus de liberdade para verificar a hipótese nula de que a série y não
é serialmente correlacionada. Ver também"pvalue".

# lngamma
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o log da função gama de x.

# loess
Resultado:  série
Argumentos: y (série)
            x (série)
            d (número inteiro, opcional)
            q (escalar, opcional)
            robust (booleano, opcional)

Realiza a regressão polinomial localmente ponderada (LOESS) e retorna uma
série contendo os valores previstos de y para cada valor não-ausente de x.
O método utilizado é o descrito por Cleveland (1979).

Os argumentos opcionais d e q especificam, respectivamente, a ordem do
polinômio em x e a proporção dos pontos de dados a ser utilizada na
estimação local. Por padrão os valores são d = 1 e q = 0,5. Os outros
valores aceitáveis para d são 0 e 2. Definir d = 0 reduz a regressão
local para a forma de uma média móvel. O valor de q deve ser maior que 0 e
não pode exceder 1. Valores maiores produzem saídas mais suaves.

Se um valor não-nulo for dado ao argumento robust as regressões locais
serão iteradas duas vezes, com os pesos sendo modificados com base nos
resíduos da iteração prévia de forma a reduzir a influência das
observações aberrantes (" outliers").

Veja também "nadarwat" e, para maiores detalhes sobre métodos
não-paramétricos, veja guia de utilização do Gretl (Capítulo 40).

# log
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série, matriz ou lista)

Retorna o logaritmo natural de x. Gera NA para valores não-positivos. Note
que ln é um pseudônimo aceitável para log.

Quando uma lista for retornada, as variáveis individuais serão
automaticamente nomeadas de acordo com o modelo l_varname, onde varname é o
nome da série original. O nome será truncado se necessário e pode ser
ajustado no caso de já estar sendo usado pelo Gretl.

# log10
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o logaritmo na base 10 de x. A função irá gerar NA para valores
não-positivos.

# log2
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o logaritmo na base 2 de x. A função irá gerar NA para valores
não-positivos.

# logistic
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a função logística do argumento x, isto é, e^x/(1 + e^x). Se x
for ma matriz, a função será aplicada em cada elemento.

# lower
Resultado:  matriz quadrada
Argumento:  A (matriz)

Retorna uma matriz triangular inferior de ordem n x n. Os elementos da
diagonal e abaixo desta são iguais aos elementos correspondentes de A e os
demais iguais a zero.

Ver também"upper".

# lrcovar
Resultado:  matriz
Argumentos: A (matriz)
            demean (booleano, opcional)

Retorna a matriz de variância-covariância de longo prazo das colunas de A.
Em primeiro lugar é retirada a média dos dados, a menos que o segundo
argumento (que é opcional) seja igual a zero. O tipo de kernel/núcleo e o
parâmetro de truncagem de defasagem (tamanho da janela) pode ser escolhido
antes que a função seja chamada com as opções relacionadas ao HAC, que
são oferecidas pelo comando "set", tais como hac_kernel, hac_lag,
hac_prewhiten. Veja também a seção sobre dados de séries de tempo e
matrizes de covariância no guia de utilização do Gretl (Capítulo 22).

Ver também"lrvar".

# lrvar
Resultado:  escalar
Argumentos: y (série ou vetor)
            k (número inteiro)

Retorna a variância de longo prazo de y, calculada utilizando um núcleo de
Bartlett com tamanho de janela igual a k. Se o segundo argumento for
omitido, ou for um valor menor que zero, o tamanho da janela toma como
padrão a parte inteira da raiz cúbica do tamanho da amostra.

Ver a função "lrcovar" para o caso multivariado.

Per l'equivalente multivariato, si veda "lrcovar".

# Lsolve
Resultado:  matriz
Argumentos: L (matriz)
            b (matriz)

Resolve a equação Ax = b para cada x, onde L é o factor de Cholesky
(triangular baixa) da matriz definida positiva A, satisfazendo LL' = A. A
matriz L pode ser obtida usando a função "cholesky" com a matriz A como
argumento.

Os dois seguintes cálculos deve dar resultados iguais (excepto devido à
precisão da máquina). mas a primeira variante baseada em Lsolve permite
reutilizar um factor de Cholesky já calculado e assim optimizar o tempo de
cálculo para uma dada matriz A e vários valores de b. A melhoria de
velocidade será tanto maior quanto maior a dimensão das colunas de A.

	  # variante 1
	  matrix L = cholesky(A)
	  matrix x = Lsolve(L, b)
	  # variante 2
	  matrix x = A \ b

# max
Resultado:  escalar ou série
Argumento:  y (série ou lista)

Se o argumento y for uma série, retorna, na forma de um escalar, o valor
máximo das observações não ausentes na série. Se o argumento for uma
lista, retorna uma série onde cada elemento é o valor máximo em cada
observação entre as séries listadas.

Ver também"min", "xmax", "xmin".

# maxc
Resultado:  vetor linha
Argumento:  X (matriz)

Retorna um vetor com os valores máximos das colunas de X.

Ver também"imaxc", "maxr", "minc".

# maxr
Resultado:  vetor coluna
Argumento:  X (matriz)

Retorna um vetor com os valores máximos das linhas X.

Ver também"imaxr", "maxc", "minr".

# mcorr
Resultado:  matriz
Argumento:  X (matriz)

Calcula a matriz de correlações tratando cada coluna de X como sendo uma a
variável. Ver também"corr", "cov", "mcov".

# mcov
Resultado:  matriz
Argumento:  X (matriz)

Calcula a matriz de covariâncias tratando cada coluna de X como sendo uma
variável. Ver também"corr", "cov", "mcorr".

# mcovg
Resultado:  matriz
Argumentos: X (matriz)
            u (vetor, opcional)
            w (vetor, opcional)
            p (número inteiro)

Retorna uma matriz covariograma para uma matriz X de ordem T x k
(normalmente contendo regressores), um vetor u (opcional) com T elementos
(normalmente contendo resíduos), um vetor de pesos w (opcional) com p+1
elementos e uma ordem de defasagem p, que deve ser maior ou igual a 0.

A matriz retornada é o somatório com j indo de -p até p de w(|j|) *
X(t)X(t-j)' * u(t)u(t-j), onde X(t)' é a t-ésima linha de X.

Se u for null os termos u são omitidos, e se w for null todos os pesos são
considerados como sendo iguais a 1,0.

Por exemplo, o seguinte código

	  set seed 123
	  X    = mnormal(6,2)
	  Lag  = mlag(X,1)
	  Lead = mlag(X,-1)
	  print X Lag Lead
	  eval X'X
	  eval mcovg(X, , , 0)
	  eval X'(X + Lag + Lead)
	  eval mcovg(X, , , 1)

produz estes resultados:

	  ? print X Lag Lead
	  X (6 x 2)

	    -0.76587      -1.0600
	    -0.43188      0.30687
	    -0.82656      0.40681
	     0.39246      0.75479
	     0.36875       2.5498
	     0.28855     -0.55251

	  Lag (6 x 2)

	      0.0000       0.0000
	    -0.76587      -1.0600
	    -0.43188      0.30687
	    -0.82656      0.40681
	     0.39246      0.75479
	     0.36875       2.5498

	  Lead (6 x 2)

	    -0.43188      0.30687
	    -0.82656      0.40681
	     0.39246      0.75479
	     0.36875       2.5498
	     0.28855     -0.55251
	      0.0000       0.0000

	  ? eval X'X
	      1.8295       1.4201
	      1.4201       8.7596

	  ? eval mcovg(X,,, 0)
	      1.8295       1.4201
	      1.4201       8.7596

	  ? eval X'(X + Lag + Lead)
	      3.0585       2.5603
	      2.5603       10.004

	  ? eval mcovg(X,,, 1)
	      3.0585       2.5603
	      2.5603       10.004

# mean
Resultado:  escalar ou série
Argumento:  x (série ou lista)

Se x for uma série a função retorna a média amostral (na forma de um
escalar), descartando quaisquer observações ausentes.

Se x for uma lista a função retorna uma série y tal que y_t é a média
dos valores das variáveis da lista na observação t, ou NA se existir
algum valor ausente em t.

# meanc
Resultado:  vetor linha
Argumento:  X (matriz)

Retorna um vetor com as médias das colunas de X. Ver também"meanr",
"sumc", "sdc".

# meanr
Resultado:  vetor coluna
Argumento:  X (matriz)

Retorna um vetor com as médias das linhas de X. Ver também"meanc", "sumr".

# median
Resultado:  escalar ou série
Argumento:  x (série ou lista)

Se x for uma série, a função retorna sua mediana amostral (na forma de um
escalar), ignorando quaisquer observações ausentes.

Se x for uma lista, a função retorna uma séries y tal que y_t é a
mediana dos valores das variáveis da lista na observação t, ou NA se
existir algum valor ausente em t.

# mexp
Resultado:  matriz quadrada
Argumento:  A (matriz quadrada)

Calcula a matriz exponencial de A utilizando o algoritmo 11.3.1 de Golub e
Van Loan (1996).

# mgradient
Resultado:  matriz
Argumentos: p (número inteiro)
            theta (vetor)
            type (número inteiro ou texto)

Derivadas analíticas para os pesos MIDAS. Seja k o número de elementos no
vetor de hiper-parâmetros, theta. Esta função retorna uma matriz de ordem
p x k contendo o gradiente do vetor de pesos (conforme calculado por
"mweights") em relação aos elemento de theta. O primeiro argumento
representa a ordem de defasagem desejada e o último argumento especifica o
tipo de parametrização. Veja mweights para uma explicação sobre os
valores aceitáveis de type.

Ver também"mweights", "mlincomb".

# min
Resultado:  escalar ou série
Argumento:  y (série ou lista)

Se o argumento y for uma série, retorna, na forma de um escalar, o valor
mínimo das observações não ausentes na série. Se o argumento for uma
lista, retorna uma série onde cada elemento é o valor mínimo em cada
observação entre as séries listadas.

Ver também"max", "xmax", "xmin".

# minc
Resultado:  vetor linha
Argumento:  X (matriz)

Retorna um vetor com os valores mínimos das colunas de X.

Ver também"iminc", "maxc", "minr".

# minr
Resultado:  vetor coluna
Argumento:  X (matriz)

Retorna um vetor com os valores mínimos das linhas de X.

Ver também"iminr", "maxr", "minc".

# missing
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou lista)

Retorna uma variável binária igual a 1 se x for NA e 0, caso contrário.
Se x for uma série, a comparação é feita em cada um de seus elementos.
Se x for uma lista de séries, a função retorna uma série igual a 1 nas
observações nas quais ao menos uma das séries apresente um NA e 0, caso
contrário.

Ver também"misszero", "ok", "zeromiss".

# misszero
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar ou série)

Converte NAs em zeros. Se x for uma série a conversão será feita elemento
por elemento. Ver também"missing", "ok", "zeromiss".

# mlag
Resultado:  matriz
Argumentos: X (matriz)
            p (escalar ou vetor)
            m (escalar, opcional)

Desloca para cima ou para baixo as linhas de X . Se p for um número
positivo, retorna uma matriz na qual as colunas de X são deslocadas p
linhas para baixo e as primeiras p linhas são preenchidas com o valor m. Se
p for um número negativo, X é deslocado para cima e as últimas linhas
são preenchidas com o valor m . Se m não for fornecido, será considerado
como sendo igual a zero.

Se p for um vetor, a operação acima é realizada para cada elemento em p,
combinando as matrizes resultantes horizontalmente.

Veja também "lags".

# mlincomb
Resultado:  série
Argumentos: hfvars (lista)
            theta (vetor)
            type (número inteiro ou texto)

É uma função MIDAS de conveniência, combinando "lincomb" com "mweights".
Dada uma lista hfvars, a função calcula uma série que é uma soma
ponderada dos elementos da lista, com os pesos baseados no vetor de
hiper-parâmetros theta e o tipo de parametrização. Veja mweights para
maiores detalhes. Note que "hflags" é, geralmente, a melhor forma de criar
uma lista que pode ser adequadamente utilizada como primeiro argumento desta
função.

De forma mais explícita, a chamada

	  series s = mlincomb(hfvars, theta, 2)

é equivalente a

	  matrix w = mweights(nelem(hfvars), theta, 2)
	  series s = lincomb(hfvars, w)

A vantagem é que a utilização de mlincomb é mais concisa e eficiente em
termos de processamento.

# mlog
Resultado:  matriz quadrada
Argumento:  A (matriz quadrada)

Calcula o logarimo matricial de A. O algoritmo utilizado baseia-se na
decomposição espectral, que necessita que A seja diagonizável. Ver
taambé "mexp".

# mnormal
Resultado:  matriz
Argumentos: r (número inteiro)
            c (número inteiro)

Retorna uma matriz com r linhas e c colunas, preenchida com variáveis
pseudo aleatórias com distribuição normal padrão. Ver também"normal",
"muniform".

# mols
Resultado:  matriz
Argumentos: Y (matriz)
            X (matriz)
            &U (referência a matriz, ou null)
            &V (referência a matriz, ou null)

Retorna uma matriz de ordem k x n com os parâmetros obtidos da regressão
MQO da matriz Y de ordem T x n contra a matriz X de ordem T x k.

Se o terceiro argumento for diferente de null, a matriz U de ordem T x n
irá conter os resíduos. Se o último argumento for dado e for diferente de
null a matriz V de ordem k x k irá conter (a) a matriz de covariância das
estimativas dos parâmetros, se Y tiver apenas uma coluna, ou (b) X'X^-1 se
Y tiver múltiplas colunas.

Por padrão, estimativas são obtidas via decomposição de Cholesky. Caso
as colunas de X apresentem elevada colinearidade é utilizada a
decomposição QR. A utilização de SVD pode ser forçada via comando set
svd on.

Ver também"mpols", "mrls".

# monthlen
Resultado:  o mesmo tipo que o argumento
Argumentos: mês (número inteiro)
            ano (número inteiro)
            dias na semana (número inteiro)

Retorna o número de dias (relevantes) no mês e ano especificados (no
calendário gregoriano proléptico). O argumento dias na semana, que pode
ser igual a 5, 6 ou 7, indica o número de dias da semana que devem ser
considerados (se for escolhido 6 os domingos são omitidos e se for
escolhido 5 os sábados e os domingos serão omitidos).

# movavg
Resultado:  série
Argumentos: x (série)
            p (escalar)
            control (número inteiro, opcional)
            y0 (escalar, opcional)

Dependendo do valor do parâmetro p, retorna a média móvel simples ou
exponencialmente ponderada da série x.

Se p > 1, é calculada a média móvel (MM/MA) simples de ordem p, isto é,
a média aritmética de x do período t até t-p+1. Se for escolhido um
valor diferente de zero para o argumento opcional control é calculada a
média móvel centrada, caso contrário é calculada a média móvel
simples. Nesse caso, o argumento opcional y0 é ignorado.

Se p for uma fração positiva, é calculada a média móvel exponencial:

y(t) = p*x(t) + (1-p)*y(t-1)

Por padrão, a série de saída, y, é inicializada utilizando o primeiro
valor de x, mas o argumento control pode ser utilizado para especificar o
número inicial de observações cuja média deve ser utilizada para
produzir y(0). Um valor zero para control indica que todas as observações
devem ser utilizadas. Alternativamente, um valor de inicialização pode ser
especificado utilizando o argumento opcional y0. Nesse caso o argumento
control é ignorado.

# mpiallred
Resultado:  número inteiro
Argumentos: &object (referência ao objeto)
            op (texto)

Apenas disponível se gretl foi compilado com suporte MPI, e o programa foi
iniciado em modo MPI (ver em gretl + MPI). Deve ser chamada por todos os
processos. Esta função funciona como "mpireduce" excepto que todos os
processos, e não apenas o processo raiz, recebem uma cópia do objecto
"reduzido" em lugar do original. É assim, equivalente a mpireduce seguida
de uma chamada a "mpibcast", mas mais eficiente.

# mpibarrier
Resultado:  número inteiro

Apenas disponível se gretl foi compilado com suporte MPI, e o programa foi
iniciado em modo MPI (ver em gretl + MPI). Não usa argumentos. Força a
sincronização dos processos MPI: nenhum processo pode ultrapassar a
barreira até que todos a tenham atingido.

	  # nenhum passa deste ponto, até que todos o tenham atingido
	  mpibarrier()

# mpibcast
Resultado:  número inteiro
Argumentos: &objecto (referência ao objeto)
            raiz (número inteiro, opcional)

Apenas disponível se gretl foi compilado com suporte MPI, e o programa foi
iniciado em modo MPI (ver em gretl + MPI). Deve ser chamada por todos os
processos. Transmite o argumento objecto, que deve ser dado na forma de
ponteiro, a todos os processos. O objecto em questão deve ser uma matriz,
um bundle, escalar, vector, texto ou lista, e ter seido declarado em todos
os processos antes da trasnmissão. Nenhum processo poderá prosseguir para
além da chamada a mpibcast até que todos os processos a tenham executado
com sucesso.

Por defeito a "raiz", é a origem da transmissão, é o processo com o
índice 0, mas isto pode ser modificado por via do segundo argumento
(opcional), o qual deve ser um inteiro entre 0 e o número de processos MPI
menos 1.

De seguida mostra-se um simples exemplo. Se a função completar com
sucesso, todos os processos terão uma cópia da matriz X definida no
processo de índice 0.

	  matrix X
	  if $mpirank == 0
	  X = mnormal(T, k)
	  endif
	  mpibcast(&X)

# mpirecv
Resultado:  objeto
Argumento:  origem (número inteiro)

Apenas disponível se gretl foi compilado com suporte MPI, e o programa foi
iniciado em modo MPI (ver em gretl + MPI). Para uma explicação, ver
"mpisend", que emparelha com mpirecv e que tem ques estar sempre acoplada. O
argumento origem especifica o índice do processo de onde deve ser recebido
o objecto, dentro do intervalo inteiro entre 0 e o número de processos MPI
menos 1.

# mpireduce
Resultado:  número inteiro
Argumentos: &objecto (referência ao objeto)
            op (texto)
            raiz (número inteiro, opcional)

Apenas disponível se gretl foi compilado com suporte MPI, e o programa foi
iniciado em modo MPI (ver em gretl + MPI). Deve ser chamada por todos os
processos. Esta função recolhe objectos funzione (apenas escalares ou
matrizes) e matrici) com nome específico, dado na forma de ponteiro, de
todos os processo e "reduz"-los a um único objecto no nó raiz.

O argomunto op específica a operação ou método de redução. Os métodos
suportados para escalares são sum, prod (produto), max e min. Para matrizes
os métodoa são sum, prod (produto de Hadamard), hcat (concatenação
horizontal) e vcat (concatenação vertical).

Por defeito, a "raiz", a destinatária da redução é o processo MPI com
índice 0, mas isto pode ser modificado por via do segundo argumento
(opcional), o qual deve ser um inteiro entre 0 e o número de processos MPI
menos 1.

De seguida mostra-se um exemplo. Se a função completar com sucesso, o
processo raiz terá uma matriz X que é a soma das matrizes X de todos os
processos.

	  matrix X
	  X = mnormal(T, k)
	  mpireduce(&X, sum)

# mpiscatter
Resultado:  número inteiro
Argumentos: &M (referência a matriz)
            op (texto)
            raiz (número inteiro, opcional)

Apenas disponível se gretl foi compilado com suporte MPI, e o programa foi
iniciado em modo MPI (ver em gretl + MPI). Deve ser chamada por todos os
processos. Esta função distribui partes de uma matriz no processo raiz por
todos os processos. A matriz deve ter sido declarada em todos os processos,
antes da chamada de mpiscatter, e deve ser dada na forma de ponteiro.

O argumento op deve ser byrows ou bycols. Seja q o quociente entre o número
de linhas da matriz a dividir pelo número de processos. No caso byrows a
raiz envia as primeiras q linhas para o processo 0, as seguintes q para o
processo 1, e assim sucessivamente. Existe um resto na divisão, as linhas
remanescentes são atribuídas ao último segmento. O caso bycols é
semelhante, mas a matriz é dividida por colunas.

Segue-se uma exemplo. Se existem 4 processos, todos (incluíndo o processo
raiz) receberá uma parte 2500 x 10 do original X como existia no processo
raiz. Se você pretender preservar a matriz inteira no processo raiz, terá
que fazer uma cópia dela antes de chamar. mpiscatter.

	  matrix X
	  if $mpirank == 0
	  X = mnormal(10000, 10)
	  endif
	  mpiscatter(&X, byrows)

# mpisend
Resultado:  número inteiro
Argumentos: objecto (objeto)
            destino (número inteiro)

Apenas disponível se gretl foi compilado com suporte MPI, e o programa foi
iniciado em modo MPI (ver em gretl + MPI). Envia o objecto designado (que
deve ser uma matriz, bundle, vector, escalar, texto ou lista) do processo
corrente para aquele identificado pelo inteiro destino (de 0 a número de
processos MPI menos 1).

A chamada desta função deve estar sempre emparelhada com uma chamada a
"mpirecv" no processo destino, como no exemplo seguinte que envia uma matriz
do índice 2 para o índice 3.

	  if $mpirank == 2
	  matrix C = cholesky(A)
	  mpisend(C, 3)
	  elif $mpirank == 3
	  matrix C = mpirecv(2)
	  endif

# mpols
Resultado:  matriz
Argumentos: Y (matriz)
            X (matriz)
            &U (referência a matriz, ou null)

Funciona de forma semelhante à função "mols". A diferença é que os
cálculos são realizados com precisão múltipla utilizando a biblioteca
GMP.

Por padrão, a biblioteca GMP utiliza 256 bits para cada número de ponto
flutuante. Isso pode ser ajustado via variável de ambiente GRETL_MP_BITS,
por exemplo, GRETL_MP_BITS=1024.

# mrandgen
Resultado:  matriz
Argumentos: d (texto)
            p1 (escalar)
            p2 (escalar, condicional)
            p3 (escalar, condicional)
            rows (número inteiro)
            cols (número inteiro)
Exemplos:   matrix mx = mrandgen(u, 0, 100, 50, 1)
            matrix mt14 = mrandgen(t, 14, 20, 20)

Funciona da mesma forma que "randgen" exceto pelo fato de retornar uma
matriz ao invés de uma série. Os argumentos iniciais para essa função
(os números que a distribuição selecionada depende) são descritos por
randgen, mas eles devem ser seguidos por dois inteiros para especificar o
número de linhas e colunas da matriz aleatória desejada.

O primeiro exemplo acima gera um vetor coluna com 50 elementos seguindo uma
distribuição uniforme, enquanto que o segundo exemplo especifica uma
matriz aleatória de ordem 20 x 20 com valores extraídos da distribuição
t com 14 graus de liberdade.

Ver também"mnormal", "muniform".

# mread
Resultado:  matriz
Argumentos: fname (texto)
            import (booleano, opcional)

Lê uma matriz armazenada no arquivo chamado fname . Isto destina-se
principalmente para ler arquivos com um format específico como descrito
adiante, mas também pode ser usado em arquivos genéricos de texto
delimitados. Neste último caso, ver a seção intitulada "Arquivos de texto
delimitados" abaixo.

Se o arquivo possuir a extensão ".gz " é assumido que ele foi comprimido
no formato gzip, se tiver a extensão ".bin" é assumido que o arquivo está
em formato binário (veja "mwrite" para detalhes). Caso contrário, se o
arquivo tiver a extensão ".mat" assume-se que é um arquivo de texto
simples, seguindo as seguintes especificações:

  O arquivo pode começar com qualquer qualquer quantidade de comentários,
  definidos por linhas iniciadas com o caractere #. Essas linhas serão
  ignoradas.

  A primeira que não for de comentário deve conter dois inteiros,
  separados por um espaço ou uma tabulação, indicando o número de linhas
  e colunas, respectivamente.

  As colunas devem estar separadas por espaços ou por tabulações.

  O separador decimal deve ser o ponto (".").

Se no primeiro argumento não estiver especificado o caminho completo até o
arquivo ele será em vários locais que sejam considerados como sendo
"prováveis". O primeiro deles será o diretório de trabalho em uso
"workdir". Entretanto, se o segundo argumento da função, import, for um
valor não-nulo o arquivo será procurado no diretório "@dotdir". Isto
ocorre para que essa função seja utilizada em conjunto com as que exportam
matrizes presentes no contexto do comando "foreign". Nesse caso o argumento
fname deve ser um nome simples, sem que se especique o caminho para o
arquivo.

Arquivos de texto delimitados

Se o arquivo possuir a extensão ".csv" as regras que regulam o formato do
arquivo são diferentes, e mais relaxadas. Neste caso os dados concretos,
não devem ser antecedidos por uma linha com o número de linhas e colunas.
Gretl tentará determinar o qual o delimitador (vírgula, ponto e vírgula
ou espaço) e fazer o seu melhor para importar a matriz, permitindo o uso da
vírgula como separador decimal se necessário. Note que o delimitador não
deve ser uma tabulação, sob pena de criar confusão com os arquivos de
formato matriz "nativos" do gretl.

Ver também"bread", "mwrite".

# mreverse
Resultado:  matriz
Argumentos: X (matriz)
            bycol (booleano, opcional)

Retorna uma matriz contendo as linhas de X em ordem reversa. Para obter uma
matriz contendo as colunas em ordem reversa pode-se utilizar um valor
não-nulo como segundo argumento.

# mrls
Resultado:  matriz
Argumentos: Y (matriz)
            X (matriz)
            R (matriz)
            q (vetor coluna)
            &U (referência a matriz, ou null)
            &V (referência a matriz, ou null)

Mínimos quadrados restritos: retorna uma matriz k x n de parâmetros
estimados obtidos através da regressão via mínimos quadrados da matriz Y,
de ordem T x n, contra a matriz X, de ordem T x k, sujeitos à restrição
linear RB = q, onde B representa o vetor de coeficientes empilhados. R deve
possuir kn colunas. Cada linha dessa matriz representa uma restrição
linear. O número de linhas em q deve coincidir com o número de linhas em
R.

Se o quinto argumento não for null, a matriz U de ordem T x n irá
armazenar os resíduos. Se o argumento final for dado e não for null então
a matriz V de ordem k x k irá armazenar a contraparte restrita da matriz X'
X^-1. A matriz de variância das estimativas para a equação i pode ser
construída multiplicando-se a sub-matriz apropriada de V por uma estimativa
do erro para esta equação.

# mshape
Resultado:  matriz
Argumentos: X (matriz)
            r (número inteiro)
            c (número inteiro)

Rearranja os elementos de X em uma matriz com r linhas e c colunas. Os
elementos de X são copiados e escritos na matriz de destino. A cópia tem
início na coluna 1, linha 1, depois linha 2 e assim sucessivamente. Se X
tiver menos que k = rc elementos, estes são repetidos de forma cíclica.
Caso contrário, se X tiver mais elementos, apenas os primeiros k elementos
serão utilizados.

Ver também"cols", "rows", "unvech", "vec", "vech".

# msortby
Resultado:  matriz
Argumentos: X (matriz)
            j (número inteiro)

Retorna uma matriz onde as linhas de X são reordenadas de forma crescente
de acordo com os elementos da coluna j. Essa ordenação é estável: linhas
que compartilham o mesmo valor na coluna j não serão invertidas.

# msplitby
Resultado:  cadeia de matrizes
Argumentos: X (matriz)
            v (vetor)

Retorna um arranjo de matrizes, o resultado de dividir verticalmente X
segundo o controlo do vector v. Este vector deve ser de comprimento igual ao
número de linhas do argumento X, e deverá conter valores inteiros com um
mínimo de 1 e um máximo igual ao número de matrizes no arranjo desejado.
Cada elemento de v indica o índice vectorial da matriz que corresponde à
linha de X que deverá ser atríbuída.

No seguinte exemplo, divide-se uma matriz 3 x 3 em três matrizes: as
primeiras duas linhas são atribuídas à primeira matriz; as segunda matriz
fica vazia; e a terceira matriz recebe a linha 3 de X.

	  matrix X = {1,2,3; 4,5,6; 7,8,9}
	  matrices M = msplitby(X, {1,1,3})
	  print M

A saída mostra:

	  Vetor ("array") de matrizes, comprimento 3
	  [1] 2 x 3
	  [2] null
	  [3] 1 x 3

Ver "flatten" para a operação inversa.

# muniform
Resultado:  matriz
Argumentos: r (número inteiro)
            c (número inteiro)

Retorna uma matriz com r linhas e c colunas, preenchida com números
pseudo-aleatórios seguindo uma distribuição uniforme (0,1). Observação:
o método preferencial para gerar escalares pseudo-aleatórios com
distribuição uniforme é através da utilização da função "randgen1".

Ver também"mnormal", "uniform".

# mweights
Resultado:  matriz
Argumentos: p (número inteiro)
            theta (vetor)
            type (número inteiro ou texto)

Retorna um vetor de ordem p de pesos MIDAS a serem aplicados nas p
defasagens de uma série de alta frequência, com base no vetor de
hiper-parâmetros theta.

O argumento type identifica o tipo de parametrização, a qual determina o
número de elementos necessários, k, em theta: 1 = exponencial normalizado
de Almon (k ao menos 1, tipicamente 2); 2 = beta normalizado com última
defasagem nula (k = 2); 3 = beta normalizado com última defasagem não-nula
(k = 3); e 4 = polinômio de Almon (k ao menos 1). Note que no caso do beta
normalizado os primeiros dois elementos de theta devem ser positivos.

O type pode ser fornecido como sem um código inteiro, como mostrado acima,
ou por um dos seguintes textos (respectivamente): nealmon, beta0, betan,
almonp. Se for utilizado texto, ele deve ser escrito com aspas duplas. Por
exemplo, as duas expressões abaixo são equivalentes:

	  W = mweights(8, theta, 2)
	  W = mweights(8, theta, "beta0")

Ver também"mgradient", "mlincomb".

# mwrite
Resultado:  número inteiro
Argumentos: X (matriz)
            fname (texto)
            export (booleano, opcional)

Salva a matriz X em um arquivo especificado por fname. Por padrão este
arquivo será um arquivo de texto simples. A primeira linha terá dois
números inteiros, separados por um caractere de tabulação (tab),
representando o número de linhas e colunas. Nas linhas seguintes estarão
os elementos da matriz, em notação científica, separados por tabulações
(uma linha da matriz em cada linha do arquivo). Veja a seguir os formatos
alternativos.

Se já existir um arquivo com o nome fname ele será sobrescrito. O valor a
ser retornado pela função é 0 em caso de sucesso. Se ocorrer um erro na
escrita, que pode ocorrer, por exemplo, se o arquivo estiver bloqueado, o
valor de retorno será diferente de 0.

O arquivo de saída será salvo no "workdir" selecionado, a menos que no
argumento filename seja escrito o caminho completo. Entretanto, se o
argumento export for diferente de 0, o arquivo será salvo no diretório do
usuário, ou seja, no diretório "@dotdir", onde é acessado por padrão
pelas funções que manipulam matrizes no contexto do comando "foreign".
Nesse caso, um nome simples, sem a inclusão do caminho para o arquivo, deve
ser usado como segundo argumento.

Matrizes armazenadas via função mwrite na sua forma padrão podem ser
facilmente lidas por outros programas. Para maiores detalhes veja guia de
utilização do Gretl (Capítulo 17).

Duas variantes, mutuamente exclusivas, estão disponíveis para esta
função:

  Se o nome dado para o arquivo, fname, terminar com ".gz" então ele será
  armazenado com compressão gzip.

  Se fname terminar com ".bin " então o arquivo será armazenado no formato
  binário. Neste caso os primeiros 19 bytes contêm os caracteres
  gretl_binary_matrix, os 8 bytes seguintes contêm dois inteiros de 32 bit,
  fornecendo o número de linhas e colunas da matriz, e o restante do
  arquivo contém os elementos da matriz como "doubles", com extremidade do
  tipo little-endian, orientado a coluna (column-major). Se o Gretl for
  executado em um sistema com extremidade do tipo big-endian, os valores
  binários são convertidos para little-endian na escrita e convertidos
  para big-endian na leitura.

Note que se o armazenamento da matriz em um arquivo for para seu uso em
outros programas não é aconselhável utilizar as variantes gzip ou
binária. Mas se o intuito for a posterior leitura pelo próprio Gretl,
esses formatos alternativos economizam espaço em disco e, no caso do
armazenamento no formato binário, torna a leitura de grandes matrizes bem
mais rápida. O formato gzip não é recomendado para matrizes muito
grandes, uma vez que a descompressão desses arquivos é bastante lenta.

Ver também"mread".

# mxtab
Resultado:  matriz
Argumentos: x (série ou vetor)
            y (série ou vetor)

Retorna uma matriz contendo a tabulação cruzada dos valores contidos em x
(por linha) e y (por coluna). Os dois argumentos devem ser do mesmo tipo
(ambos séries ou ambos vetores) e, devido à forma que essa função é
comumente utilizada, assume-se que contêm apenas valores inteiros.

Ver também"values".

# naalen
Resultado:  matriz
Argumentos: d (série ou vetor)
            cens (série ou vetor, opcional)

Dada uma amostra de dados de duração, d, possivelmente acompanhada por um
registro de status de censura, cens, calcula o estimador não-paramétrico
de Nelson-Aalen da função de risco (Nelson, 1972; Aalen, 1978). A matriz
retornada possui três colunas contendo, respectivamente, os valores únicos
de d de forma ordenada, a função de risco acumulada estimada
correspondendo ao valor de duração na coluna 1 e o erro padrão do
estimador.

Se a série cens for dada, um valor 0 serve para indicar uma observação
não-censurada, enquanto que um valor 1 indica uma observação censurada à
direita (isto é, o período de observação do indivíduo em questão
terminou antes que a duração ou o período tenham sido registrados como
finalizados). Se cens não for dado é assumido que todas as observações
são não-censuradas. Observação: a interpretação de cens pode ser
estendida em algum momento de forma a cobrir outros tipos de censura.

Ver também"kmeier".

# nadarwat
Resultado:  série
Argumentos: y (série)
            x (série)
            h (escalar)

Estimador não paramétrico de Nadaraya-Watson da média condicional de y
dado x. Retorna uma série contendo a estimativa não-paramétrica de E(y_
i|x_i) para cada valor não ausente da série x.

A função núcleo (ou função kernel) K é dada por K = exp(-x^2 / 2h)
para |x| < T e, caso contrário, zero.

O argumento h, conhecido como largura de banda (bandwidth), é um número
real positivo escolhido pelo usuário. Normalmente este é um número
pequeno: maiores valores de h tornam m(x) mais suave. Uma escolha comumente
utilizada é definir h como sendo proporcional a n^-0.2. Mais detalhes podem
ser encontrados no guia de utilização do Gretl (Capítulo 40).

O escalar T é utilizado para prevenir problemas numéricos quando a
função núcleo é avaliada em um ponto muito distante de zero e é chamado
de parâmetro de truncagem.

O parâmetro de truncagem pode ser alterado através do ajuste de
nadarwat_trim, como um múltiplo de h . O valor padrão é 4.

O usuário pode fornecer valores negativos para a largura de banda: esta é
interpretada como sintaxe convencional para obter o estimador leave-one-out.
Este é uma variante do estimador que não usa a i-ésima observação para
avaliar m(x_i). Isso faz com que o estimador de Nadaraya-Watson seja mais
numericamente robusto e sua utilização é normalmente aconselhada quando o
estimador é calculado com o propósito de realizar inferências. Vale
salientar que a largura de banda utilizada é, na verdade, o valor absoluto
de h.

# nelem
Resultado:  número inteiro
Argumento:  L (lista, matriz, lote ou cadeia)

Retorna o número de elementos no argumento que, por sua vez, pode ser uma
lista, uma matriz, um pacote (bundle) ou um arranjo (array). A função não
pode ser utilizada em séries.

# ngetenv
Resultado:  escalar
Argumento:  s (texto)

Se uma variável de ambiente de nome s estiver definida e possuir um valor
numérico a função retorna este valor, caso contrário, retorna NA. Veja
também "getenv".

# nlines
Resultado:  escalar
Argumento:  buf (texto)

Retorna a quantidade de linhas completas (isto é, linhas que terminam com
um caractere de nova linha) em buf.

Exemplo:

        string web_page = readfile("http://gretl.sourceforge.net/")
        scalar number = nlines(web_page)
        print number

# NMmax
Resultado:  escalar
Argumentos: &b (referência a matriz)
            f (chamada a função)
            maxfeval (número inteiro, opcional)

Realiza a maximização numérica via método simplex sem derivadas de
Nelder-Mead. O argumento b deve conter os valores iniciais de um conjunto de
parâmetros e o argumento f deve especificar uma chamada à função que
calcule o critério (escalar) a ser maximizado, dados os valores correntes
dos parâmetros e quaisquer outros dados que sejam relevantes. Se for
completada com sucesso, NMmax retorna o valor maximizado do critério e b
armazena os valores dos parâmetros que maximizam a função.

O terceiro argumento, opcional, pode ser utilizado para determinar o número
máximo de avaliações da função. Se for omitido ou for igual a zero o
máximo de avaliações será, por padrão, igual a 2000. O valor do
argumento maxfeval pode ser especificado como um número negativo. Neste
caso é tomado o valor absoluto e a função NMmax sinaliza um erro se o
melhor valor encontrado para a função objetivo, respeitando o número
máximo de avaliações de funções, não for um ótimo local. Caso
contrário a falta de convergência neste sentido não é tratada como um
erro.

Se de fato o objetivo for a minimização, a função pode retornar o valor
negativo do critério. Alternativamente pode-se utilizar a função NMmax
através de sua forma alternativa NMmin.

Para maiores detalhes e exemplos guia de utilização do Gretl (Capítulo
37). Ver também"simann".

# NMmin
Resultado:  escalar

É uma forma alternativa da função "NMmax". Se invocada com este nome a
função comporta-se como minimizadora.

# nobs
Resultado:  número inteiro
Argumento:  y (série)

Retorna o número de observações não ausentes para a variável y na
amostra corrente selecionada.

# normal
Resultado:  série
Argumentos: mu (escalar)
            sigma (escalar)

Cria uma série de números gaussianos pseudo-aleatórios com média mu e
desvio padrão sigma. Se não forem fornecidos argumentos, será produzida
uma série padrão normalizada N(0,1). Os valores são calculados utilizando
o método Ziggurat (Marsaglia e Tsang, 2000).

Ver também"randgen", "mnormal", "muniform".

# normtest
Resultado:  matriz
Argumentos: y (série ou vetor)
            method (texto, opcional)

Realiza um teste de normalidade em y. Por padrão é utilizado o teste de
Doornik-Hansen, mas é possível escolher outros métodos via argumento
opcional method. Os testes disponíveis são: swilk para o teste de
Shapiro-Wilk, jbera para o teste de Jarque-Bera, ou lillie para o de teste
Lilliefors.

O segundo argumento pode ser fornecido com ou sem aspas. Porém, quando o
argumento estiver na forma de uma variável de texto (string), o valor dessa
variável é substituído. Os seguintes exemplos mostram três formas
aceitáveis de se realizar o teste de Shapiro-Wilk:

	  matrix nt = normtest(y, swilk)
	  matrix nt = normtest(y, "swilk")
	  string testtype = "swilk"
	  matrix nt = normtest(y, testtype)

A matriz retornada tem ordem 1 x 2 e armazena a estatística de teste e seu
p-valor. Veja também o comando "normtest".

# npcorr
Resultado:  matriz
Argumentos: x (série ou vetor)
            y (série ou vetor)
            method (texto, opcional)

Calcula uma medida de correlação entre x e y utilizando um método
não-paramétrico. Se for dado, o terceiro argumento deve ser kendall (para
a versão b do tau de Kendall, sendo este o método padrão) ou spearman
(para o rô de Spearman).

O valor de retorno é um vetor de ordem 3 contendo a medida de correlação,
a estatística de teste e o p-valor para a hipótese nula de
não-autocorrelação. Note que se o tamanho da amostra for muito pequeno a
estatística de teste e/ou p-valor podem NaN (ou seja, não é um número ou
é ausente).

Veja também "corr" para a correlação de Pearson.

# npv
Resultado:  escalar
Argumentos: x (série ou vetor)
            r (escalar)

Retorna o Valor Presente Líquido (VPL ou NPV) de x , considerado como sendo
uma sequência de pagamentos (negativos) e recebimentos (positivos),
avaliada à taxa de desconto anual r, que deve ser expressa como uma
fração decimal e não como uma porcentagem (ou seja, 0.05 ao invés de
5%). O primeiro valor é considerado como sendo o "agora" e não é
descontado. Para emular a função npv na qual o primeiro valor é
descontado, basta inserir um zero no início da sequência.

A função pode ser utilizada com dados anuais, trimestrais, mensais e sem
data (neste último caso, os dados são tratados como sendo anuais).

Ver também"irr".

# NRmax
Resultado:  escalar
Argumentos: &b (referência a matriz)
            f (chamada a função)
            g (chamada a função, opcional)
            h (chamada a função, opcional)

Realiza a maximização numérica via método de Newton-Raphson. O argumento
b deve conter os valores iniciais de um conjunto de parâmetros e o
argumento f deve especificar uma chamada à função que calcule o critério
(escalar) a ser maximizado, dados os valores correntes dos parâmetros e
quaisquer outros dados que sejam relevantes. Se o objetivo for de fato uma
minimização, esta função deverá retornar o negativo do critério. Se
for completada com sucesso, NRmax retorna o valor maximizado do critério e
b armazena os valores dos parâmetros que maximizam a função.

O terceiro e o quarto argumento, opcionais, estabelecem uma maneira de
fornecer derivadas analíticas e uma hessiana (negativa) analítica,
respectivamente. As funções representadas por g e h devem ter como seus
primeiros argumentos uma matriz pré-definida que tenha o tamanho adequado
para armazenar o gradiente ou hessiana, respectivamente, dado na forma de
ponteiro. Elas também precisam ter o vetor de parâmetros como um argumento
(na forma de ponteiro ou não). Outros argumentos são opcionais. Se alguns
dos parâmetros opcionais forem omitidos, é utilizada uma aproximação
numérica.

Para maiores detalhes e exemplos veja guia de utilização do Gretl
(Capítulo 37). Ver também"BFGSmax", "fdjac".

# NRmin
Resultado:  escalar

É uma forma alternativa da função "NRmax". Se invocada com este nome a
função comporta-se como minimizadora.

# nullspace
Resultado:  matriz
Argumento:  A (matriz)

Calcula o espaço nulo direito de A, via decomposição em valores
singulares: o resultado é uma matriz B tal que o produto AB é uma matriz
nula, exceto quando A tem posto completo, nesse caso uma matriz vazia é
retornada. Caso contrário, se A é uma matriz m x n, B terá dimensão n
por (n - r), onde r é o posto de A.

Se A não tiver posto completo a concatenação vertical de A com a
transposta de B produz uma matriz de posto completo.

Exemplo:

      A = mshape(seq(1,6),2,3)
      B = nullspace(A)
      C = A | B'

      print A B C

      eval A*B
      eval rank(C)

O exemplo acima produz:

      ? print A B C
      A (2 x 3)

      1   3   5
      2   4   6

      B (3 x 1)

      -0.5
         1
      -0.5

      C (3 x 3)

         1      3      5
         2      4      6
      -0.5      1   -0.5

      ? eval A*B
      -4.4409e-16
      -4.4409e-16

      ? eval rank(C)
      3

Ver também"rank", "svd".

# numhess
Resultado:  matriz
Argumentos: b (vetor coluna)
            fcall (chamada a função)
            d (escalar, opcional)

Calcula uma aproximação numérica para a hessiana associada ao vetor b de
ordem n e à função objetivo especificada pelo argumento fcall. A chamada
à função deve ter b como primeiro argumento (de forma direta ou na forma
de ponteiro), seguido de quaisquer argumentos adicionais que possam ser
necessários. A função retorna um escalar como resultado. Se executada com
sucesso, numhess retorna uma matriz de ordem n x n contendo a hessiana que,
por sua vez, é simétrica por construção.

O método utilizado é a extrapolação de Richardson, com quatro passos. O
terceiro argumento, opcional, pode ser utilizado para ajustar a fração d
do valor do parâmetro utilizado no ajuste do tamanho do passo inicial. Se
este argumento for omitido, será utilizado d = 0,01 como padrão.

Exemplo::

	  matrix H = numhess(theta, myfunc(&theta, X))

Ver também"BFGSmax", "fdjac".

# obs
Resultado:  série

Retorna uma série de números inteiros consecutivos começando em 1 no
início do conjunto de dados. Note que esse resultado não é afetado por
subamostragem. Essa função é especialmente útil com conjunto de dados de
séries temporais. Você também pode escrever t ao invés de obs para obter
a série.

Ver também"obsnum".

# obslabel
Resultado:  texto
Argumento:  t (número inteiro)

Retorna o rótulo da observação t, onde t é número que representa esta
observação. A função inversa é dada por "obsnum".

# obsnum
Resultado:  número inteiro
Argumento:  s (texto)

obsnum Retorna o número que corresponde a observação especificada pela
variável s. Note que o resultado desta função não é afetado por
subamostragens. Ela é especialmente útil em dados de séries temporais.
Por exemplo, o código seguinte

	  open denmark
	  k = obsnum(1980:1)

fornece k = 25, indicando que o primeiro trimestre de 1980 é a vigésima
quinta observação nos dados denmark.

Ver também"obs", "obslabel".

# ok
Resultado:  ver abaixo
Argumento:  x (escalar, série, matriz ou lista)

Se x for um escalar, retorna 1 se x não for NA, caso contrário 0. Se x for
uma série, retorna uma série com valor 1 nas observações sem valores
ausentes e 0 onde houver valores ausentes. Se x for uma lista, a saída da
função é uma série com 0 nas observações onde ao menos uma das séries
na lista tenha valor ausente, caso contrário retorna 1.

Se x for uma matriz o comportamento da função é um pouco diferente, uma
vez que matrizes não podem conter NA's. Assim, nesse caso, a função
retorna uma matriz com as mesmas dimensões que x, com 1's nas posições
com elementos finitos de x and 0's nas posições onde os elementos são
não-finitos (podendo ser números infinitos ou NaN, conforme padrão IEEE
754).

Ver também"missing", "misszero", "zeromiss". Mas note que essas funções
não são aplicáveis no caso de matrizes.

# onenorm
Resultado:  escalar
Argumento:  X (matriz)

Retorna a norma-1 da matriz X, isto é, a máxima soma dos valores absolutos
dos elementos de cada coluna de X.

Ver também"infnorm", "rcond".

# ones
Resultado:  matriz
Argumentos: r (número inteiro)
            c (número inteiro)

Retorna uma matriz com r linhas e c colunas preenchida com valores iguais a
1.

Ver também"seq", "zeros".

# orthdev
Resultado:  série
Argumento:  y (série)

Aplicável apenas quando o conjunto de dados atualmente aberto é composto
por dados em painel. Calcula os desvios ortogonais anteriores (ou seja, o
desvio entre t e t+1) da variável y .

Esta transformação é realizada algumas vezes ao invés da diferenciação
para remover efeitos individuais do dado em painel. Para fins de
compatibilidade com a primeira diferença, os desvios são armazenados um
paso à frente em relação à sua verdadeira localização temporal (isto
é, o valor na observação t é o desvio que, estritamente falando,
pertence ao tempo t -1). Assim, perde-se a primeira observação em cada
série de tempo, e não a última.

Ver também"diff".

# pdf
Resultado:  o mesmo tipo que o argumento
Argumentos: d (texto)
            ... (ver abaixo)
            x (escalar, série ou matriz)
Exemplos:   f1 = pdf(N, -2.5)
            f2 = pdf(X, 3, y)
            f3 = pdf(W, forma, escala, y)

Calculadora de função densidade de probabilidade. Retorna a densidade em x
da distribuição identificada pelo código d. Veja "cdf" para detalhes
acerca dos argumentos (escalares) requeridos. As distribuições suportadas
pela função pdf são: normal, t de Student, qui-quadrado, F, Gama,
Exponencial, Weibull, Laplace, Erro Generalizado, Binomial e Poisson. Note
que para a Binomial e a Poisson o que de fato é calculado é a massa de
probabilidade no ponto especificado. Para t de Student, qui-quadrado e F
também estão disponíveis as suas variantes não-centrais.

Para a distribuição normal veja também "dnorm".

# pergm
Resultado:  matriz
Argumentos: x (série ou vetor)
            bandwidth (escalar, opcional)

Se apenas o primeiro argumento for dado, calcula o periodograma da amostra
para dada variável ou vetor. Se o segundo argumento for dado, calcula uma
estimativa do espectro de x utilizando janela de defasagem de Bartlett para
a largura de banda dada, até o número de observações (T/2).

Retorna uma matriz com duas colunas e T/2 linhas: a primeira coluna contendo
a frequência, omega, de 2pi/T até pi e a segunda contendo a densidade
espectral correspondente.

# pexpand
Resultado:  série
Argumento:  v (vetor)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Realiza a operação inversa de "pshrink". Isto é, dado um vetor de
comprimento igual ao número de indivíduos na amostra (de painel) corrente,
retorna uma série na qual cada valor é repetido T vezes, onde T representa
o comprimento temporal do painel. A série resultante é dessa forma não
variante em relação ao tempo.

# pmax
Resultado:  série
Argumentos: y (série)
            mask (série, opcional)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Retorna uma série contendo o máximo da variável y para cada
unidade de corte transversal (isso é repetido parar cada período de
tempo).

Se o segundo argumento (opcional) for fornecido, as observações onde o
valor de mask for igual a zero são ignoradas.

Ver também"pmin", "pmean", "pnobs", "psd", "pxsum", "pshrink", "psum".

# pmean
Resultado:  série
Argumentos: y (série)
            mask (série, opcional)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Retorna uma série contendo a média temporal da variável y para
cada unidade de corte transversal. Os valores são repetidos para cada
período e as observações ausentes são ignoradas no cálculo das médias.

Se o segundo argumento (opcional) for fornecido, as observações onde o
valor de mask for igual a zero são ignoradas.

Ver também"pmax", "pmin", "pnobs", "psd", "pxsum", "pshrink", "psum".

# pmin
Resultado:  série
Argumentos: y (série)
            mask (série, opcional)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Retorna uma série contendo o mínimo da variável y para cada
unidade de corte transversal (isso é repetido para cada período de tempo).

Se o segundo argumento (opcional) for fornecido, as observações onde o
valor de mask for igual a zero são ignoradas.

Ver também"pmax", "pmean", "pnobs", "psd", "pshrink", "psum".

# pnobs
Resultado:  série
Argumentos: y (série)
            mask (série, opcional)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Retorna uma série contendo o número de observações válidas em y
para cada unidade de corte transversal (isso é repetido para cada período
de tempo).

Se o segundo argumento (opcional) for fornecido, as observações onde o
valor de mask for igual a zero são ignoradas.

Ver também"pmax", "pmin", "pmean", "psd", "pshrink", "psum".

# polroots
Resultado:  matriz
Argumento:  a (vetor)

Encontra as raízes de um polinômio. Se o polinômio for de ordem p, o
vetor a deverá conter p + 1 coeficientes em ordem crescente, i.e. iniciando
com a constante e terminando com o coeficiente de x^p.

Se todas as raízes forem reais elas serão retornadas em um vetor coluna de
comprimento p, caso contrário uma matriz de ordem p x 2 será retornada,
com as partes reais na primeira coluna e as partes imaginárias na segunda.

# polyfit
Resultado:  série
Argumentos: y (série)
            q (número inteiro)

Ajusta uma tendência polinomial de ordem q à série y usando o método dos
polinômios ortogonais. A série retornada contém os valores ajustados.

# princomp
Resultado:  matriz
Argumentos: X (matriz)
            p (número inteiro)
            covmat (booleano, opcional)

Seja a matriz X de ordem T x k, contendo T observações de k variáveis. O
argumento p deve ser um inteiro positivo menor ou igual a k. Esta função
retorna a matriz de ordem T x p, P, contendo os primeiros p principais
componentes de X.

O terceiro argumento, opcional, age como uma chave booleana: se for um valor
não-nulo os componentes principais são calculados com base na matriz de
covariâncias das colunas de X (o padrão desta função é a utilização
da matriz de correlação).

Os elementos de P são calculados como sendo a soma de i até k de Z_ti
multiplicado por v_ji, onde Z_ti é o valor padronizado da variável i na
observação t e v_ji é o j-ésimo autovetor da matriz de correlação (ou
covariância) dos X_is, com os autovetores ordenados de forma decrescente de
acordo com o valores dos autovalores correspondentes.

Ver também"eigensym".

# prodc
Resultado:  vetor linha
Argumento:  X (matriz)

Retorna o produto dos elementos das colunas de X. Ver também"prodr",
"meanc", "sdc", "sumc".

# prodr
Resultado:  vetor coluna
Argumento:  X (matriz)

Retorna o produto dos elementos das linhas de X. Ver também"prodc",
"meanr", "sumr".

# psd
Resultado:  série
Argumentos: y (série)
            mask (série, opcional)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Retorna uma série contendo desvio padrão amostral da variável y
para cada unidade de corte transversal (sendo os valores repetidos para cada
período de tempo). O denominador utilizado o tamanho da amostra em cada
unidade menos 1, a menos que o número de observações válidas para dada
unidade ser 1 (nesse caso será retornado 0) ou 0 (nesse caso será
retornado NA).

Se o segundo argumento (opcional) for fornecido, as observações onde o
valor de mask for igual a zero são ignoradas.

Observação: essa função torna possível testar se dada variável (como
por exemplo, X) não varia ao longo do tempo utilizando a condição
max(psd(X)) == 0.

Ver também"pmax", "pmin", "pmean", "pnobs", "pshrink", "psum".

# psdroot
Resultado:  matriz quadrada
Argumento:  A (matriz simétrica)

Calcula a variante generalizada da decomposição de Cholesky da matriz A,
que deve ser positiva semi-definida (mas que pode ser singular). Se a matriz
de entrada não for quadrada é sinalizado um erro, apesar disso, a simetria
é assumida pela função, mas não verificada. Apenas o triângulo inferior
de A é lido. O resultado é uma matriz triangular inferior L que satisfaz A
= LL'. Elementos indeterminados na solução são zerados.

Para o caso onde A é positivo definido, veja "cholesky".

# pshrink
Resultado:  matriz
Argumento:  y (série)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Retorna um vetor coluna contendo a primeira observação válida da
série y para cada unidade de corte transversal no painel, ao longo
extensão da amostra corrente. Se uma unidade não possuir observações
válidas da série de entrada ela será ignorada.

Essa função fornece uma maneira de compactar as séries retornadas por
funções como "pmax" e "pmean", nas quais um valor pertencente a cada
unidade de corte transversal é repetido para cada período de tempo.

Veja "pexpand" para a operação inversa.

# psum
Resultado:  série
Argumentos: y (série)
            mask (série, opcional)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Retorna uma série contendo a soma ao longo do tempo da variável y
para cada unidade de corte transversal. Os valores são repetidos para cada
período e as observações ausentes são ignoradas no cálculo das somas.

Se o segundo argumento (opcional) for fornecido, as observações onde o
valor de mask for igual a zero são ignoradas.

Ver também"pmax", "pmean", "pmin", "pnobs", "psd", "pxsum", "pshrink".

# pvalue
Resultado:  o mesmo tipo que o argumento
Argumentos: c (caractere)
            ... (ver abaixo)
            x (escalar, série ou matriz)
Exemplos:   p1 = pvalue(z, 2.2)
            p2 = pvalue(X, 3, 5.67)
            p2 = pvalue(F, 3, 30, 5.67)

Calculadora de P-valores. Retorna P(X > x), onde a distribuição de X é
especificada pela letra c. Entre os argumentos c e x, zero ou mais
argumentos adicionais são necessários para que especifique os parâmetros
da distribuição. Veja "cdf" para detalhes. As distribuições suportadas
pela função pvalue são: normal padrão, t, qui-quadrada, F, gama,
binomial, Poisson, Weibull e Erro Generalizado.

Ver também"critical", "invcdf", "urcpval", "imhof".

# pxnobs
Resultado:  série
Argumentos: y (série)
            mask (série, opcional)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Retorna uma série contendo o número de observações válidas de y
em cada período de tempo (essa operação é repetida para cada unidade de
corte transversal).

Se o segundo argumento (opcional) for fornecido, as observações onde o
valor de mask for igual a zero são ignoradas.

Note que esta função opera em uma dimensão diferente da função "pnobs".

# pxsum
Resultado:  série
Argumentos: y (série)
            mask (série, opcional)

É aplicável somente se o conjunto de dados corrente tiver uma estrutura de
painel. Retorna uma série contendo a soma dos valores de y para cada
unidade de corte transversal em cada período de tempo (sendo os valores
repetidos para cada unidade de corte).

Se o segundo argumento (opcional) for fornecido, as observações onde o
valor de mask for igual a zero são ignoradas.

Note que esta função opera em uma dimensão diferente da função "psum".

# qform
Resultado:  matriz
Argumentos: x (matriz)
            A (matriz simétrica)

Calcula a forma quadrática Y = xAx'. A utilização desta função, ao
invés da multiplicação matricial comum, garante mais velocidade e maior
precisão quando A é uma matriz simétrica genérica. Porém, no caso
especial onde A é uma matriz identidade, a simples expressão x'x tem
desempenho bastante superior em relação a qform(x',I(rows(x)).

Se x e A não forem compatíveis, ou A não for simétrica, é retornado um
erro.

# qlrpval
Resultado:  escalar
Argumentos: X2 (escalar)
            df (número inteiro)
            p1 (escalar)
            p2 (escalar)

Fornece os p-valores para a estatística de teste do teste sup-Wald QLR para
uma quebra estrutural em um ponto desconhecido (veja "qlrtest"), conforme
Hansen (1997).

O primeiro argumento, X2, representa a máxima estatística de teste (na
forma de qui-quadrado) de Wald e df representa os graus de liberdade. O
terceiro e o quarto argumento representa, na forma de frações decimais da
amplitude de estimação geral, os pontos inicial e final da amplitude
central das observações ao longo das quais os sucessivos testes de Wald
são calculados. Por exemplo, se a abordagem padrão de corte de 15 por
cento for utilizada p1 deve ser igual a 0.15 e p2 igual a 0.85.

Ver também"pvalue", "urcpval".

# qnorm
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna os quantis para a distribuição normal padrão. Se x não estiver
entre 0 e 1, será retornado NA. Ver também"cnorm", "dnorm".

# qrdecomp
Resultado:  matriz
Argumentos: X (matriz)
            &R (referência a matriz, ou null)

Calcula a decomposição QR de uma matriz X de ordem m x n, isto é, X = QR
onde Q é uma matriz ortogonal m x n e R é uma matriz triangular superior n
x n. A matriz Q é retornada diretamente, enquanto que R pode ser obtida via
utilização do segundo argumento (opcional).

Ver também"eigengen", "eigensym", "svd".

# quadtable
Resultado:  matriz
Argumentos: n (número inteiro)
            type (número inteiro, opcional)
            a (escalar, opcional)
            b (escalar, opcional)

Retorna uma matriz de ordem n x 2 para utilização a quadratura gaussiana
(integração numérica). A primeira coluna contém os nós ou abscissas e a
segunda os pesos.

O primeiro argumento especifica o número de pontos (linhas) a serem
computados. O segundo argumento indica o tipo de quadratura: use 1 para
Gauss-Hermite (tipo padrão); 2 para Gauss-Legendre; ou 3 para
Gauss-Laguerre. O significado dos parâmetros opcionais a e b dependem da
escolha do argumento type, conforme explicado a seguir.

A quadratura gaussiana é um método para aproximar numericamente a integral
definida de dada função de interesse. Seja a função representada pelo
produto f(x)W(x). Os tipos de quadratura diferem de acordo com a
especificação do componente W(x): no caso de Hermite ela é definida como
exp(-x^2); no caso de Laguerre, exp(-x); e no caso de Legendre como W(x) =
1.

Para cada especificação de W, pode-se calcular um conjunto de abscissas,
x_i, e pesos, w_i, tais que o somatório de i=1 até n de w_i f(x_i) se
aproxima da integral desejada. O método de Golub e Welsch (1969) é
utilizado.

Quando o tipo Gauss-Legendre é selecionado, os argumentos opcionais a e b
podem ser utilizados para controlar os limites inferior e superior de
integração, sendo os valores padrão -1 e 1. Na quadratura de Hermite os
limites são fixados entre menos infinito e mais infinito, enquanto que no
caso de Laguerre eles são fixados entre zero e infinito.

No caso de Hermite a e b exercem um papel diferente: eles podem ser
utilizados para substituir a forma padrão de W (x) pela (proximanente
relacionada) distribuição normal com média a e desvio padrão b.
Fornecendo os valores de 0 e 1 para estes parâmetros, por exemplo, tem o
efeito de transformar W(x ) em uma FDP normal padrão, que é equivalente a
multiplicar as abscissas padrão pela raiz quadrada de dois e dividir os
pesos pela raiz quadrada de pi.

# quantile
Resultado:  escalar ou matriz
Argumentos: y (série ou matriz)
            p (escalar entre 0 e 1)

Se y for uma série, retorna o quantil p da série. Por exemplo, quando p =
0,5, a mediana é retornada.

Se y for uma matriz, retorna um vetor linha contendo os p-quantis das
colunas de y. Isto é, cada coluna é tratada como sendo uma série.

Adicionalmente, para a matriz y existe uma segunda alternativa para o
segundo argumento: p pode ser dado como um vetor. Nesse caso o valor de
retorno é uma matriz de ordem m x n onde m representa o número de
elementos em p e n é o número de colunas em y.

# randgen
Resultado:  série
Argumentos: d (texto)
            p1 (escalar ou série)
            p2 (escalar ou série, condicional)
            p3 (escalar, condicional)
Exemplos:   series x = randgen(u, 0, 100)
            series t14 = randgen(t, 14)
            series y = randgen(B, 0.6, 30)
            series g = randgen(G, 1, 1)
            series P = randgen(P, mu)

Gerador de número aleatório de uso geral. O argumento d é um texto
(string) (sendo geralmente composto por apenas um caractere) que especifica
a distribuição da qual serão extraídos os pseudo-números. Os argumentos
p1 a p3 especificam os parâmetros da distribuição selecionada, sendo que
o número de parâmetros depende da distribuição escolhida. Para
distribuições que não a beta-binomial, os parâmetros p1 e p2 (se for
aplicável) podem estar na forma escalar ou de série. Se forem utilizados
na forma escalar a série resultante será identicamente distribuída. Se
forem utilizadas séries em p1 ou p2 a distribuição será condicional ao
valor do parâmetro em cada observação. No caso da beta-binomial todos os
parâmetros devem ser escalares.

Especificidades são apresentadas abaixo: o código para cada distribuição
é mostrado entre parênteses, seguido da interpretação do argumento p1 e,
quando for aplicável, p2 e p3.

  Uniforme (contínua) (u ou U): mínimo, máximo

  Uniforme (discreta) (i): mínimo, máximo

  Normal (z, n ou N): média, desvio padrão

  t de Student (t): graus de liberdade

  Qui-quadrado (c, x ou X): graus de liberdade

  F de Snedecor (f ou F): graus de liberdade (num.), graus de liberdade
  (den.)

  Gama (g ou G): forma, escala

  Binomial (b ou B): probabilidade, quantidade de tentativas

  Poisson (p ou P): média

  ExponenCial (exp): escala

  Weibull (w ou W): forma, escala

  Laplace (l ou L): média, escala

  Erro Generalizado (E): forma

  Beta (beta): forma1, forma2

  Beta-Binomial (bb): tentativas, forma1, forma2

Ver também"normal", "uniform", "mrandgen", "randgen1".

# randgen1
Resultado:  escalar
Argumentos: d (caractere)
            p1 (escalar)
            p2 (escalar, condicional)
Exemplos:   scalar x = randgen1(z, 0, 1)
            scalar g = randgen1(g, 3, 2.5)

Funciona da mesma forma que "randgen" exceto pelo fato de retornar um
escalar ao invés de uma série.

O primeiro exemplo acima retorna um valor da distribuição normal padrão,
enquanto que o segundo especifica um valor a ser extraído da distribuição
Gama com forma 3 e escala 2.5.

Ver também"mrandgen".

# randint
Resultado:  número inteiro
Argumentos: min (número inteiro)
            max (número inteiro)

Retorna um inteiro pseudo-aleatório no intervalo fechado [min, max]. Ver
também"randgen".

# randperm
Resultado:  vetor
Argumentos: n (número inteiro)
            k (número inteiro, opcional)

Se apenas é dado o primeiro argumento, retorna um vector linha contendo uma
permutação aleatória dos inteiros de 1 a n, sem repetição dos
elementos. Se o segundo argumento é dado, ele tem que ser um inteiro no
intervalo de 1 a n; neste caso a função retorna um vector linha contendo k
inteiros seleccionados aleatóriamente entre 1 e n sem substituição.

Caso se pretenda uma amostra de k linhas de uma matriz X com n linhas (sem
substituição), pode-se proceder como se mostra adiante:

	  matrix S = X[randperm(n, k),]

E case se queira preservar a ordem original das linhas na amostra:

	  matrix S = X[sort(randperm(n, k)),]

Ver também "resample" para a reamostragem com substituição.

# rank
Resultado:  número inteiro
Argumento:  X (matriz)

Retorna o posto de X, calculada numericamente via decomposição em valores
singulares. Ver também"svd".

# ranking
Resultado:  o mesmo tipo que o argumento
Argumento:  y (série ou vetor)

Retorna uma série ou vetor com os ranks de y. O rank para a observação i
é o número de elementos que são menores que y_i mais 1. Se houver
números iguais a y_i adiciona-se 0,5. Intuitivamente, pode-se pensar em uma
partida de xadrez, onde uma vitória vale 1 ponto e um empate vale 0,5
pontos). É adicionado 1 ao rank de forma que o menor rank possível é 1 ao
invés de 0.

Ver também"sort", "sortby".

# rcond
Resultado:  escalar
Argumento:  A (matriz quadrada)

Retorna o número condicional recíproco para A em relação à norma-1. Em
várias circunstâncias, é uma medida de sensibilidade melhor de A em
relação a operações numéricas, tais como a inversão, que o
determinante.

O valor é calculado como a recíproca do produto, norma-1 de A multiplicada
pela norma-1 de A-inverso.

Ver também"det", "ldet", "onenorm".

# Re
Resultado:  matriz
Argumento:  C (matriz complexa)

Retorna uma matriz real com a mesma dimensão que C, contendo a parte real
dessa matriz de entrada. Ver também "Im".

# readfile
Resultado:  texto
Argumentos: fname (texto)
            codeset (texto, opcional)

Se um arquivo com o nome fname existir e puder ser lido, a função retorna
um texto (string) com o conteúdo desse arquivo, caso contrário retorna um
erro. Se fname não contiver o caminho completo até o arquivo, ele será
procurado em algumas localizações "prováveis", começando pelo "workdir"
corrente.

Se fname começar com o identificador de um protocolo de internet suportado
(http://, ftp:// ou https://), libcurl será utilizado para baixar o
arquivo. Veja também "curl" para baixar arquivos de forma mais elaborada.

Se o texto a ser lido não estiver codificado como UTF-8, Gretl tentará
recodificá-lo a partir da codificação corrente se esta não for UTF-8,
ou, caso contrário, a partir da codificação ISO-8859-15. Se essa
estratégia padrão não funcionar é possível utilizar o segundo argumento
(que é opcional) para especificar a codificação. Por exemplo, caso seja
desejada a leitura de texto com codificação Microsoft 1251 e esta não
seja a configuração local, pode-se fornecer o segundo argumento "cp1251".

Exemplos:

        string web_page = readfile("http://gretl.sourceforge.net/")
        print web_page

        string current_settings = readfile("@dotdir/.gretl2rc")
        print current_settings

Veja também as funções "sscanf" e "getline".

# regsub
Resultado:  texto
Argumentos: s (texto)
            match (texto)
            repl (texto)

Retorna uma cópia de s onde todas as ocorrências do padrão match são
substituídas por repl. Os argumentos match e repl são interpretados como
expressões regulares no estilo Perl.

Veja também "strsub" para substituições simples de textos.

# remove
Resultado:  número inteiro
Argumento:  fname (texto)

Deleta o arquivo fname caso ele exista e seja gravável pelo usuário.
Retorna 0 em caso de sucesso e um valor não-nulo se o arquivo não existir
ou não puder ser removido.

Se fname contiver o caminho completo para o arquivo o Gretl tentará
deletá-lo e retornará um erro se ele não existir ou não puder ser
apagado por algum motivo (um exemplo seria um arquivo do tipo
somente-leitura). Se fname não contiver o caminho completo então será
assumido que o arquivo está no diretório de trabalho ("workdir"). Se o
arquivo não existir ou não for gravável o Gretl não irá procurá-lo em
nenhum outro diretório.

# replace
Resultado:  o mesmo tipo que o argumento
Argumentos: x (série ou matriz)
            find (escalar ou vetor)
            subst (escalar ou vetor)

Substitui cada elemento de x igual ao i-ésimo elemento de find pelo
correspondente elemento de subst.

Se find for um escalar, subst também deve ser um escalar. Se find e subst
forem vetores, eles precisam ter o mesmo número de elementos. Mas se find
for um vetor e subst um escalar, então todas as ocorrências serão
substituídas por subst.

Exemplo:

	  a = {1,2,3;3,4,5}
	  find = {1,3,4}
	  subst = {-1,-8, 0}
	  b = replace(a, find, subst)
	  print a b

produz

          a (2 x 3)

          1   2   3
          3   4   5

          b (2 x 3)

          -1    2   -8
          -8    0    5

# resample
Resultado:  o mesmo tipo que o argumento
Argumentos: x (série ou matriz)
            blocksize (número inteiro, opcional)

A descrição inicial desta função refere-se aos dados de corte
transversal ou de séries de tempo. Ao final é tratado o caso de dados em
painel.

Realiza a reamostragem de x com substituição. Quando uma série é
utilizada como argumento, cada valor da série de retorno, y_t, é sorteado
entre todos os valores de x_t com igual probabilidade. Quando uma matriz é
utilizada como argumento, cada linha da matriz retornada é sorteada entre
todas as linhas de x com igual probabilidade.

O argumento opcional blocksize representa o tamanho do bloco para a
reamostragem via deslocamento de blocos. Caso este argumento seja dado, ele
deve ser um número inteiro positivo maior ou igual a 2. Ao se utilizar este
argumento a saída é composta pela seleção aleatória com substituição
de todas as sequências contíguas possíveis com tamanho igual ao valor de
blocksize na entrada (no caso da utilização de matrizes na entrada as
linhas são contíguas). Se o comprimento do dado não for um número
inteiro e múltiplo do tamanho do bloco, o bloco selecionado será truncado
para se ajustar.

Se o argumento x for uma série e o conjunto de dados for do tipo painel, a
reamostragem via deslocamento de blocos não é suportada. A forma básica
de reamostragem é suportada, mas passa a ter a seguinte interpretação: os
dados são reamostrado "por indivíduo". Suponha que você tenha um painel
no qual 100 indivíduos são observados ao longo de 5 períodos. Nesse caso
a série retornada será novamente composta de 100 blocos de 5
observações: cada bloco será sorteado com igual probabilidade entre 100
séries de tempo individuais, com a ordem da série temporal sendo
preservada.

# round
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Arredondamento para o número inteiro mais próximo. Note que quando x
estiver exatamente entre dois inteiros, o arredondamento é feito de moda a
"se afastar de zero", assim, por exemplo, 2.5 é arredondado para 3, mas
round(-3.5) retorna -4. Esta é uma convenção comum em programas de
planilha eletrônica, mas outros programas podem gerar resultados
diferentes. Ver também"ceil", "floor", "int".

# rnameget
Resultado:  texto ou cadeia de texto
Argumentos: M (matriz)
            row (número inteiro, opcional)

Se o argumento row for dado, retorna o nome da linha col da matriz M. Se M
não possuir nomes em suas linhas então será retornada um texto (string)
vazio. Se row for maior que o número de linhas da matriz será sinalizado
um erro.

Se não se indicar o segundo argumento, retornará um vetor de texto
contendo os nomes das linhas de M, ou um vetor de texto vazio se M não
tiver nomes de linhas atribuídos.

Exemplo:

	  matrix A = { 11, 23, 13 ; 54, 15, 46 }
	  rnameset(A, "First Second")
	  string name = rnameget(A, 2)
	  print name

Ver também"rnameset".

# rnameset
Resultado:  número inteiro
Argumentos: M (matriz)
            S (cadeia de texto ou lista)

Adiciona nomes para as linhas da matriz M de ordem m x n . Se S for uma
lista, os nomes serão os das séries listadas. A lista precisa ter m
membros. Se S for um arranjo (array) de variáveis de texto (string), ele
precisa ter m elementos. Para manter a compatibilidade com versões
anteriores do Gretl, uma única variável de texto também pode ser
utilizada como segundo argumento. Nesse caso ela precisa ter m textos
separados por espaços.

Retorna o valor 0 se as linhas forem nomeadas com sucesso. Caso contrário
será retornado um valor não-nulo. Veja também "cnameset".

Exemplo:

	  matrix M = {1, 2; 2, 1; 4, 1}
	  strings S = array(3)
	  S[1] = "Row1"
	  S[2] = "Row2"
	  S[3] = "Row3"
	  rnameset(M, S)
	  print M

# rows
Resultado:  número inteiro
Argumento:  X (matriz)

Retorna o número de linhas da matriz X. Ver também"cols", "mshape",
"unvech", "vec", "vech".

# schur
Resultado:  matriz complexa
Argumentos: A (matriz complexa)
            &Z (referência a matriz, ou null)
            &w (referência a matriz, ou null)

Executa a decomposição de Schur da matriz complexa A, retornando uma
matriz complexa triangular superior T. Caso seja fornecido o segundo
argumento e seja diferente de null a função retorna uma matriz complexa Z
contendo o vector de Schur associado a A e T, tais que A = ZTZ^H. Se é dado
um terceiro argumento retorna os valores próprios de A num vector coluna
complexo.

# sd
Resultado:  escalar ou série
Argumento:  x (série ou lista)

Se x for uma série a função retorna o desvio padrão amostral,
descartando as observações ausentes.

Se x for uma lista a função retorna uma série y tal que y_t representa o
desvio padrão amostral dos valores das variáveis na lista na observação
t, ou NA se existirem valores ausentes em t.

Ver também"var".

# sdc
Resultado:  vetor linha
Argumentos: X (matriz)
            df (escalar, opcional)

Retorna os desvios padrão das colunas da matriz X . Se df for positivo ele
será utilizado como o divisor para as variâncias das colunas, caso
contrário o divisor será igual ao número de linhas em X (isto é, não
será aplicada a correção de graus de liberdade). Ver também"meanc",
"sumc".

# sdiff
Resultado:  o mesmo tipo que o argumento
Argumento:  y (série ou lista)

Calcula diferenças sazonais: y(t) - y(t-k), onde k é a periodicidade do
conjunto de dados corrente (veja "$pd"). Valores iniciais são definidos
como NA.

Quando uma lista for retornada, as variáveis individuais são
automaticamente nomeadas de acordo com o seguinte padrão sd_varname, onde
varname é o nome da série original. A porção que representa o nome
original da série será truncado, caso seja necessário, e ajustado no caso
de não ser único no conjunto de nomes assim construído.

Ver também"diff", "ldiff".

# seasonals
Resultado:  lista
Argumentos: baseline (número inteiro, opcional)
            center (booleano, opcional)

Aplicável somente se o conjunto de dados tiver uma estrutura de série
temporal com periodicidade maior que 1. Retorna uma lista com variáveis
dummy que representam os períodos sazonais. As dummies sazonais são
nomeadas como S1, S2 e assim por diante.

O argumento opcional baseline pode ser utilizado para excluir um período do
conjunto de dummies. Por exemplo, se for fornecido um valor igual a 1 em um
conjunto de dados trimestrais a lista retornada conterá as dummies apenas
para os trimestres 2, 3 e 4. Se este argumento for omitido ou for igual a 0
serão geradas as dummies para todos os períodos. É importante notar que o
argumento deve ser um número inteiro e menor ou igual a periodicidade dos
dados.

O argumento center, se for não-nulo, faz com que as dummies sejam
centradas, isto é, que sejam subtraídas suas médias populacionais. Por
exemplo, com dados trimestrais as dummies sazonais centradas terão valores
iguais a -0.25 e 0.75 ao invés de 0 e 1.

# selifc
Resultado:  matriz
Argumentos: A (matriz)
            b (vetor linha)

Seleciona em A apenas as colunas para as quais o elemento correspondente em
b é não-nulo. b deve ser um vetor linha com o mesmo número de colunas de
A.

Ver também"selifr".

# selifr
Resultado:  matriz
Argumentos: A (matriz)
            b (vetor coluna)

Seleciona em A apenas as linhas para as quais o elemento correspondente em b
é não-nulo. b deve ser um vetor coluna com o mesmo número de linhas de A.

Ver também"selifc", "trimr".

# seq
Resultado:  vetor linha
Argumentos: a (escalar)
            b (escalar)
            k (escalar, opcional)

Retorna um vetor com a sequência crescente de a até b se o primeiro
argumento for menor que o segundo. Se o primeiro argumento for maior que o
segundo a sequência será decrescente. Em ambos os casos o
incremento/decremento será de 1 unidade.

Se o argumento opcional k for dado a função retorna um vetor com a
sequência iniciada em a e aumentada, caso a for menor b), em k unidades a
cada passo. A sequência será finalizada no maior valor possível que seja
menor ou igual a b. Se o primeiro argumento for maior que o segundo a
sequência será reduzida em k unidades e será finalizada no menor valor
possível que seja maior ou igual a b). O argumento k deve ser positivo.

Ver também"ones", "zeros".

# setnote
Resultado:  número inteiro
Argumentos: b (lote)
            key (texto)
            note (texto)

Insere uma nota descritiva para o objeto identificado por key em um pacote
(bundle) b. Esta nota será apresentada quando o comando print for utilizado
no pacote. A função retorna 0 em caso de sucesso e um valor não-nulo em
caso de falha (por exemplo, se não existir o objeto key em b).

# sgn
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o sinal do x, ou seja, 0 se x é zero, 1 se x é positivo, -1 se x
é negativo, ou NA se x é um não-número (Not a Number).

# simann
Resultado:  escalar
Argumentos: &b (referência a matriz)
            f (chamada a função)
            maxit (número inteiro, opcional)

Implementa o algoritmo "simulated annealing" (conhecido também por
recozimento simulado) que pode ser útil para melhorar a questão da
inicialização em problemas de otimização numérica.

O primeiro argumento contém o valor inicial de vetor de parâmetros e o
segundo especifica uma chamada de função que retorna o valor (escalar)
valor da variável a ser maximizada. O terceiro argumento, que é opcional,
especifica o número máximo de iterações (a quantidade padrão é 1024).
Caso seja executada com sucesso, a função simann retorna o valor final da
variável a ser maximizada e b armazena o vetor de parâmetros associado.

Para maiores detalhes e exemplo veja guia de utilização do Gretl
(Capítulo 37). Ver também"BFGSmax", "NRmax".

# sin
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o seno de x. Ver também"cos", "tan", "atan".

# sinh
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna o seno hiperbólico de x.

Ver também"asinh", "cosh", "tanh".

# skewness
Resultado:  escalar
Argumento:  x (série)

Retorna o valor de assimetria para a série x, descartando quaisquer
observações ausentes.

# sleep
Resultado:  escalar
Argumento:  ns (número inteiro)

Faz com que o processo (thread) corrente "hiberne" -- isto é, que
interrompa suas atividades -- por ns segundos. Ao despertar da hibernação,
a função retorna o valor 0. Apesar de não ser diretamente relacionada à
econometria, essa função pode ser útil para testes de métodos de
paralelização.

# smplspan
Resultado:  escalar
Argumentos: startobs (texto)
            endobs (texto)
            pd (número inteiro)

Retorna o número de observações entre startobs e endobs (inclusive) de
uma série temporal com frequência pd.

Os dois primeiros argumentos devem ser dados na forma padrão do Gretl para
dados anuais, trimestrais ou mensais -- por exemplo, 1970, 1970:1 ou 1970:01
para cada uma das frequências, respectivamente -- ou como datas no formato
ISO 8601, YYYY-MM-DD.

O argumento pd deve ser igual a 1, 4 ou 12 (anual, trimestral, mensal); uma
das frequências diárias (5, 6, 7); ou 52 (semanal). Se pd for igual a 1, 4
ou 12, então pode-se utilizar datas no formato ISO 8601 nos dois primeiros
argumentos se elas indicarem o início e o fim do período em questão. Por
exemplo, 2015-04-01 pode ser utilizada no lugar de 2015:2 para representar o
segundo trimestre de 2015.

Se um conjunto de dados já aberto e com frequência pd, com uma suficiente
quantidade de observações, então o resultado dessa função poderia ser
facilmente emulada utilizando "obsnum". A vantagem de smplspan é o fato de
poder calcular o número de observações sem que seja necessário um
conjunto de dados adequado (ou até mesmo nenhum conjunto de dados).
Exemplo:

	  scalar T = smplspan("2010-01-01", "2015-12-31", 5)
	  nulldata T
	  setobs 7 2010-01-01

O código acima produz o seguinte resultado:

	  ? scalar T = smplspan("2010-01-01", "2015-12-31", 5)
	  Gerou-se o escalar T = 1565
	  ? nulldata T
	  periodicidade: 1, máx. obs: 1565
	  intervalo das observações: 1 a 1565
	  ? setobs 7 2010-01-01
	  Intervalo completo dos dados: 2010-01-01 - 2014-04-14 (n = 1565)

Após utilizar esse código pode-se ter a certeza de que a última
observação no conjunto de dados criado via comando "nulldata" será
2015-12-31. Note que a obtenção do número 1565 seria bem mais complicada
de sem o uso dessa função.

# sort
Resultado:  o mesmo tipo que o argumento
Argumento:  x (série ou vetor)

Ordena x de forma ascendente, descartando observações com valores ausentes
quando x for uma série. Ver também"dsort", "values". Especificamente para
matrizes veja "msortby".

# sortby
Resultado:  série
Argumentos: y1 (série)
            y2 (série)

Retorna uma série contendo os elementos de y2 ordenados de acordo com os
valores crescente do primeiro argumento y1. Ver também"sort", "ranking".

# sprintf
Resultado:  texto
Argumentos: format (texto)
            ... (ver abaixo)

O texto (string) retornado é construído pela exibição dos valores dos
argumentos finais, indicados pelas reticências acima, sob o controle do
argumento format. Esta função tem como objetivo oferecer mais
flexibilidade na criação de textos. O argumento format é utilizado para
especificar de uma maneira precisa a forma como você deseja que os
argumentos sejam exibidos.

Em geral, o argumento format (que pode ser chamado de texto de formatação)
deve ser uma expressão avaliada como um texto, mas na maioria dos casos
será apenas um texto literal (uma sequência alfanumérica delimitada por
aspas duplas). Algumas sequências de caracteres em format têm um
significado especial: aqueles iniciados pelo símbolo de porcentagem (%)
são interpretados como "espaços reservados" para os ítens contidos na
lista de argumentos. Além disso, caracteres especiais, tal como o que
indica nova linha (\n ), são representados através da combinação com uma
barra invertida.

Por exemplo, o código a seguir

	  scalar x = sqrt(5)
	  string claim = sprintf("sqrt(%d) é (aproximadamente) %6.4f.\n", 5, x)
	  print claim

irá produzir

	  sqrt(5) é (aproximadamente) 2.2361.

A expressão %d dentro do argumento format indica que queremos na saída um
número inteiro neste local. Como é a expressão "porcento" mais a
esquerda, ela então tem efeito sobre o primeiro argumento, isto é, 5. A
segunda sequência especial é %6.4f, que indica um valor decimal com ao
menos 6 dígitos de largura e com ao menos 4 casas decimais. A quantidade de
sequências como estas deve coincidir com o número de argumentos após o
texto de formatação.

Ver também a ajuda para o comando "printf" para maiores detalhes sobre a
sintaxe que você pode utilizar para a formatação de textos (strings).

# sqrt
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a raiz quadrada positiva de x. Gera NA quando utilizada em valores
negativos.

Note que se o argumento for uma matriz, a operação será realizada para
cada elemento. Além disso, dado que as matrizes não podem conter valores
NA, a função irá gerar um erro se existirem valores negativos. Para a
"raiz quadrada matricial" veja "cholesky".

# square
Resultado:  lista
Argumentos: L (lista)
            cross-products (booleano, opcional)

Retorna uma lista contendo os quadrados das variáveis na lista L. Seus
elementos são nomeados de acordo com o seguinte esquema :sq_varname. Se o
segundo argumento (opcional) estiver presente e tiver um valor não-nulo, a
lista também incluirá os produtos cruzados dos elementos de L que, por sua
vez, são nomeados de acordo com o seguinte esquema: var1_var2. Nesses
esquemas os nomes das séries de entrada serão truncados caso seja
necessário e os nomes de saída podem ser ajustados em caso de de nomes
duplicados na lista retornada.

# sscanf
Resultado:  número inteiro
Argumentos: src (texto)
            format (texto)
            ... (ver abaixo)

Lê os valores de src sob controle do argumeto format e os usa para
determinar os valores de um ou mais argumentos subsequentes, indicados pelas
reticências acima. A função retorna o número de valores determinados.
Esta é uma versão simplificada da função sscanf na linguagem de
programação C.

O argumento src pode ser tanto um texto literal, delimitado por aspas
duplas, ou o nome de uma variável de texto (string) previamente definida. O
format é definido de forma similar ao texto de formatação utilizado em
"printf" (mais detalhes serão dados abaixo). Os demais argumentos,
representados acima pelas reticências devem ser uma lista separada por
vírgulas contendo os nomes de variáveis pré-definidas: estas são os
alvos da conversão de src. Para os usuários com familiaridade com a
linguagem C, pode-se prefixar os nomes de variáveis numéricas com &, mas
isso não é uma exigência.

O texto literal em format é comparado com src . Especificadores de
conversão começam com %, sendo os especificadores reconhecidos %f, %g ou
%lf para números de ponto flutuante; %d para inteiros; %s para textos; e %m
para matrizes. Você pode inserir um número inteiro positivo após o
símbolo de porcentagem: isso ajusta o número máximo de caracteres a serem
lidos por dado especificador de conversão (ou o número máximo de linhas
no caso de conversão de matrizes). Alternativamente, você pode inserir um
asterisco (*) após o símbolo de porcentagem para suprimir a conversão
(ignorando assim quaisquer caracteres que teriam sido convertidos para um
dado tipo). Por exemplo, %3d converte os próximos 3 caracteres de source em
um número inteiro, se possível; %*g ignora a quantidade necessária de
caracteres de source para que se obtenha apenas um número de ponto
flutuante.

A conversão de matrizes funciona da seguinte forma: a função lê uma
linha da entrada e conta (com base na separação por espaço ou por
tabulação) o número de campos numéricos. Isto define o número de
colunas na matriz. Por padrão a leitura continua sendo feita enquanto
enquanto a leitura de linhas devolver a mesma quantidade de colunas
numéricas, mas o número máximo de linhas a serem lidas pode ser limitado
de acorodo com o descrito acima.

No caso de textos, em adição especificador %s, também é possível
utilizar uma versão simplificada do formato utilizado na linguagem C:
%N[chars ]. Neste formato N é o número máximo de caracteres a serem lidos
chars é um conjunto de caracteres aceitáveis, delimitados por colchetes: a
leitura para se N for atingido ou se um caractere que não está em chars
for encontrado. O comportamento de chars pode ser revertido se for utilizado
um circunflexo, ^, como sendo o primeiro caractere. Neste caso a leitura
para se um caractere no dado conjunto for encontrado. Diferentemente de C, o
hífen não exerce papel especial no conjunto chars.

Se o texto fonte (src) não apresentar correspondência (completa) com o
texto de formatação (format), o número de conversões pode ficar abaixo
do número de argumentos dados. Isto não é por si só um erro no que diz
respeito ao Gretl. Caso queira verificar o número de conversões realizadas
basta utilizar o valor retornado pela função.

Alguns exemplos:

	  scalar x
	  scalar y
	  sscanf("123456", "%3d%3d", x, y)

	  S = sprintf("1 2 3 4\n5 6 7 8")
	  S
	  matrix m
	  sscanf(S, "%m", m)
	  print m

# sst
Resultado:  escalar
Argumento:  y (série)

Retorna a soma dos quadrados dos desvios em relação à média das
observações não ausentes na série y. Ver também"var".

# stack
Resultado:  série
Argumentos: L (lista)
            n (número inteiro)
            offset (número inteiro, opcional)

Destina-se a manipular dados em séries temporais para o tipo de dados
empilhados requerido por gretl para dados de painel. O valor retornado é
uma série obtida por empilhar "verticalmente" n observations de cada série
da lista L. Por defeito, são usadas as primeiras n (correspondendo ao
argumento offset = 0) mas o ponto inicial pode ser deslocado ao se fornecer
um valor positivo para offset. Se a série resultante for maior que o
conjunto de dados existente, serão acrescentadas observações conforme
necessário.

Esta função pode lidar com dados de séries temporais lado-a-lado para um
certo número de unidades de secção cruzada, e também no caso onde o
tempo é expresso horizontalmente e cada linha representa uma unidade de
secção cruzada.

Ver a secção intitulada "Detalhes de dados de painel" em guia de
utilização do Gretl (Capítulo 4) para mais detalhes e exemplos de uso.

# stdize
Resultado:  o mesmo tipo que o argumento
Argumentos: X (série, lista ou matriz)
            v (número inteiro, opcional)

Por defeito, retorna uma versão padronizada da série, lista ou matriz: os
dados de entrada são centrados e divididos pelo seu desvio padrão amostral
(com uma correção de graus de liberdade de 1). Os resultados são
calculados por coluna no caso de uma matriz.

O segundo argumento (opcional) pode ser utilizado para influenciar o
resultado. Um valor não negativo de v define os graus de liberdade usados
no desvio padrão, assim, v = 0 resulta no estimador de máxima
verosimilhança. Como caso especial, se v é igual a -1 apenas é feita a
centragem.

# strftime
Resultado:  texto
Argumentos: t (escalar)
            formato (texto, opcional)

O argumento t é interpretado como o número de segundos decorridos desde o
início do ano 1970 no fuso horário UTC (Tempo Universal Coordenado,
anteriomente designado como Tempo Médio de Greenwich (GMT) ); produz uma
cadeia de texto com a data e hora correspondente. O formato por defeito é o
mesmo que o padrão no sistema, mas pode ser modificado se o segundo
argumento (opcional) é uma cadeia de texto de formatação.

Os valores adequados como argumentos t para esta função podem ser obtidos
a partir do acessor "$now" ou da função "strptime".

Os detalhes da opção de formatação podem ser obtidos na página do
manual de strftime, nos sistemas que o disponibilizam, ou num dos muitos
sítios que têm essa informação, como por exemplo
https://devhints.io/strftime.

# stringify
Resultado:  número inteiro
Argumentos: y (série)
            S (cadeia de texto)

Fornece uma maneira de definir valores de texto para a série y. Duas
condições são necessárias para isso: a variável alvo deve ser formada
apenas por números inteiros, com nenhum deles sendo menor que 1, e o
arranjo (array) S deve possuir ao menos n elementos, onde n é o maior valor
em y. Adicionalmente, cada elemento de S deve estar representado com base na
codificação UTF-8. Ver também"strvals".

O valor retornado é zero em caso de sucesso ou um código positivo de erro
caso a função não tenha sucesso.

# strlen
Resultado:  número inteiro
Argumento:  s (texto)

Retorna o número de caracteres no texto (string) s. Note que isso não
será necessariamente igual ao número de bytes se alguns caracteres
estiverem fora do intervalo de impressão ASCII.

Exemplo:

        string s = "regression"
        scalar number = strlen(s)
        print number

# strncmp
Resultado:  número inteiro
Argumentos: s1 (texto)
            s2 (texto)
            n (número inteiro, opcional)

Compara dois textos (string) e retorna um inteiro menor que, igual ou maior
que 0 se s1 se for, respectivamente menor que, igual ou maior que s2, até o
primeiro caractere n. Se n for omitido a comparação irá prosseguir até
onde for possível.

Caso deseje apenas verificar se dois textos são iguais não é necessário
utilizar esta função. Ao invés disso é pode-se usar a seguinte
expressão: if (s1 == s2)....

# strptime
Resultado:  escalar
Argumentos: s (texto)
            formato (texto)

Esta função é a inversa de "strftime"; interpreta a cadeia de texto s
como sendo data ou hora usando o formato especificado e retorna o número de
segundos desde o início de 1970 (UTC).

As opções para o formato estão disponíveis na página do manual de
strptime, nos sistemas que o disponibilizam, ou num dos muitos sítios com
essa informação, como por exemplo
http://man7.org/linux/man-pages/man3/strptime.3.html.

O exemplo abaixo mostra como converter informação de data de um formato
para outro.

	  scalar tm = strptime("Thursday 02/07/19", "%A %m/%d/%y")
	  eval strftime(tm) # default output
	  eval strftime(tm, "%d %B, %Y")

Se a Língua é o Português, o resultado é

          ? scalar tm = strptime("Thursday 02/07/19", "%A %m/%d/%y")
          Gerou-se o escalar tm = 1,5495e+09
          ? eval strftime(tm) # default output
          qui 07 fev 2019 00:00:00
          ? eval strftime(tm, "%d %B, %Y")
          07 fevereiro, 2019

# strsplit
Resultado:  texto ou cadeia de texto
Argumentos: s (texto)
            i (número inteiro, opcional)
            sep (texto, opcional)

Em seu uso mais simples, ou seja, com apenas um argumento, retorna o arranjo
(array) com textos (string) resultante da separação de s de acordo com os
espaços em branco.

Se for fornecido um número inteiro e maior que zero como segundo argumento,
retorna o elemento i do texto s, após ter sido separado por espaços. Se i
for menor irá gerar um erro. Se i for maior que o número total de
elementos será retornado um texto vazio.

O terceiro argumento opcional pode ser utilizado para definir qual será o
critério a ser utilizado para separar s. Por exemplo:

      string basket = "banana,apple,jackfruit,orange"
      strings S = strsplit(basket,,",")

Os comandos acima irão separar o texto de entrada em um vetor contendo
quatro textos utilizando a vírgula como separadora. A vírgula "extra" na
entrada acima serve para indicar que o argumento i não foi utilizado.

As sequências de escape "\n" e "\t" são utilizadas para representar uma
nova linha ou um espaço por tabulação no argumento opcional sep. Caso o
separador seja literalmente uma barra invertida deve-se utilizar a barra de
forma duplicada, "\\". Exemplo:

      string s = "c:\fiddle\sticks"
      strings S = strsplit(s, "\\")

# strstr
Resultado:  texto
Argumentos: s1 (texto)
            s2 (texto)

Procura em s1 o texto s2. Se o texto for encontrado a função retorna uma
cópia da parte de s1 que começa com s2, caso contrário retorna um texto
vazio.

Exemplo:

        string s1 = "Gretl is an econometrics package"
        string s2 = strstr(s1, "an")
        print s2

Se o objetivo for apenas verificar se s1 contém s2 (teste booleano), ver
"instring".

# strstrip
Resultado:  texto
Argumento:  s (texto)

Retorna uma cópia de s na qual os espaços em branco do início e do fim do
texto são removidos.

Exemplo:

        string s1 = "    A lot of white space.  "
        string s2 = strstrip(s1)
        print s1 s2

# strsub
Resultado:  texto
Argumentos: s (texto)
            find (texto)
            subst (texto)

Retorna uma cópia de s na qual todas as ocorrências de find são
substituídas por subst. Veja também "regsub" para substituições mais
complexas via expressões regulares.

Exemplo:

        string s1 =  "Hello, Gretl!"
        string s2 = strsub(s1, "Gretl", "Hansl")
        print s2

# strvals
Resultado:  cadeia de texto
Argumento:  y (série)

Se uma série y for não-numérica, retorna um arranjo (array) contendo
todos os seus valores distintos, ordenados pelos valores numéricos
associados iniciados em 1. Se y não for não-numérico, retorna um arranjo
de texto (strings) vazio. Observação: variáveis não-numéricas surgem,
normalmente, quando existem séries cujas observações são textos. Ver
também"stringify".

# substr
Resultado:  texto
Argumentos: s (texto)
            start (número inteiro)
            end (número inteiro)

Retorna uma parte do texto s começando em start e terminando em end,
inclusive.

Exemplos:

        string s1 = "Hello, Gretl!"
        string s2 = substr(s1, 8, 12)
        string s3 = substr("Hello, Gretl!", 8, 12)
        print s2
        print s3

Esses exemplos fornecem:

      ? print s2
      Gretl
      ? print s3
      Gretl

Deve-se notar que em alguns casos pode-se desejar trocar a clareza da
sintaxe pela sua simplicidade e usar operadores de seleção e incremento.
Por exemplo:

          string s1 = "Hello, Gretl!"
          string s2 = s1[8:12]
          string s3 = s1 + 7
          print s2
          print s3

Esses exemplos fornecem:

      ? print s2
      Gretl
      ? print s3
      Gretl!

# sum
Resultado:  escalar ou série
Argumento:  x (série, matriz ou lista)

Se x for uma série, retorna a soma, na forma de um escalar, das
observações não ausentes em x. Veja também "sumall".

Se x for uma matriz, retorna a soma dos elementos da matriz.

Se x for uma lista, retorna uma série y na qual y_t é a soma dos valores
das variáveis da lista na observação t, ou NA se existir qualquer valor
ausente em t.

# sumall
Resultado:  escalar
Argumento:  x (série)

Retorna a soma das observações de x dentro da amostra selecionada. Se
existir qualquer valor ausente a função retornará NA. Use "sum" caso
deseje que os valores correntes sejam descartados.

# sumc
Resultado:  vetor linha
Argumento:  X (matriz)

Retorna um vetor com a soma das colunas de X Ver também"meanc", "sumr".

# sumr
Resultado:  vetor coluna
Argumento:  X (matriz)

Retorna um vetor com a soma das linhas de X Ver também"meanr", "sumc".

# svd
Resultado:  vetor linha
Argumentos: X (matriz)
            &U (referência a matriz, ou null)
            &V (referência a matriz, ou null)

Realiza a decomposição em valores singulares da matriz X.

Os valores singulares são retornados em um vetor linha. Os vetores
singulares à esquerda e/ou à direta U e V podem ser obtidos ao se fornecer
valores não-nulos para os argumentos 2 e 3, respectivamente. Para qualquer
matriz A, o código

	  s = svd(A, &U, &V)
	  B = (U .* s) * V

deve gerar B idêntico a A (desconsiderando as possíveis discrepâncias
geradas pela questão da precisão de máquina).

Ver também"eigengen", "eigensym", "qrdecomp".

# svm
Resultado:  série
Argumentos: L (lista)
            param (lote)
            bmod (referência a lote, opcional)
            bprob (referência a lote, opcional)

Esta função permite o treinamento de um modelo SVM (Supervised Vector
Machine) e a respectiva predição; o motor utilizado é a biblioteca
LIBSVM. A lista passada como argumento L deve incluir a variável
dependente, seguida pelas variáveis independentes, e o bundle param é
usado para passar opções para o mecanismo SVM. A função retorna uma
série contendo as predições SVM. Os dois outros parâmetros opcionais
são ponteiros para bundles para recolher informação adicional após o
treinamento e ou a predição.

Para mais detalhes, consultar a documentação em PDF: gretl + SVM.

# tan
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a tangente de x. Ver também"atan", "cos", "sin".

# tanh
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar, série ou matriz)

Retorna a tangente hiperbólica de x.

Ver também"atanh", "cosh", "sinh".

# tdisagg
Resultado:  matriz
Argumentos: Y (série ou matriz)
            X (série, lista ou matriz, opcional)
            s (escalar)
            opções (lote, opcional)
            resultados (lote, opcional)

Produz desagregação temporal (conversão para maior frequência) da série
temporal em Y. O argumento s fornece o factor de expansão (por exemplo, 3
de trimestral para mensal). O argumento X pode conter uma ou mais
covariáveis na frequência maior para auxiliar na desagregação. Podem ser
passadas diversas opções em opções, e os detalhes da desagregação
podem ser obtidos por via nos resultados.

Ver mais detalhes em guia de utilização do Gretl (Capítulo 9).

# toepsolv
Resultado:  vetor coluna
Argumentos: c (vetor)
            r (vetor)
            b (vetor)

Resolve um sistema de Toeplitz de equações lineares, isto é Tx = b onde T
é uma matriz quadrada cujo elemento T_i,j é igual a c_i-j para i>=j e
r_j-i para i<=j. Note que os primeiros elementos de c e r precisam ser
iguais, caso contrário um erro é retornado. Se executada com sucesso, a
função retorna o vetor x.

O algoritmo utilizado por esta função se aproveita da estrutura especial
que a matriz T possui, o que o torna bem mais eficiente que outros
algoritmos não especializados, em especial para grandes problemas.
Atenção! Em certos casos a função pode, de forma espúria, emitir uma
mensagem apontando que a matriz tem problemas de singularidade quando na
verdade T é não-singular. Este problema, entretanto, não pode ocorrer
quando T é definida positiva.

# tolower
Resultado:  texto
Argumento:  s (texto)

Retorna uma cópia de s na qual todos os caracteres maiúsculos são
convertidos em minúsculos.

Exemplos:

        string s1 = "Hello, Gretl!"
        string s2 = tolower(s1)
        print s2

        string s3 = tolower("Hello, Gretl!")
        print s3

# toupper
Resultado:  texto
Argumento:  s (texto)

Retorna uma cópia de s na qual todos os caracteres minúsculos são
convertidos em maiúsculos.

Exemplos:

        string s1 = "Hello, Gretl!"
        string s2 = toupper(s1)
        print s2

        string s3 = toupper("Hello, Gretl!")
        print s3

# tr
Resultado:  escalar
Argumento:  A (matriz quadrada)

Retorna o traço de uma matriz quadrada A, isto é, a soma dos elementos de
sua diagonal. Ver também"diag".

# transp
Resultado:  matriz
Argumento:  X (matriz)

Retorna a transposta de X. Observação: esta função é raramente
utilizada. Para transpor uma matriz, na maior parte dos casos, pode-se
simplesmente utilizar o operador de transposição: X'.

# trimr
Resultado:  matriz
Argumentos: X (matriz)
            ttop (número inteiro)
            tbot (número inteiro)

Retorna uma cópia da matriz X com ttop linhas superiores excluídas e tbot
linhas inferiores excluídas. Os dois últimos argumentos devem ser
não-negativos e sua soma deve ser menor que o total de linhas de X.

Ver também"selifr".

# typeof
Resultado:  número inteiro
Argumento:  name (texto)

Retorna o código numérico de tipo se name for o identificador de um objeto
definido: 1 para escalar, 2 para série, 3 para matriz, 4 para texto
(string), 5 para pacote (bundle), 6 para arranjo (array) e 7 para lista.
Caso contrário retorna 0. A função "typestr" pode ser utilizada para
obter o nome do objeto que corresponde ao código numérico.

Essa função também pode ser utilizada para obter o tipo de um membro de
um pacote ou de um elemento de um arranjo. Por exemplo:

	  matrices M = array(1)
	  eval typestr(typeof(M))
	  eval typestr(typeof(M[1]))

O primeiro resultado do comando eval é "array " e o segundo é "matrix".

# typestr
Resultado:  texto
Argumento:  typecode (número inteiro)

Retorna o nome do tipo de dado correspondente a typecode. Pode ser utilizada
em conjunto com as funções "typeof" e "inbundle". O valor retornado pode
ser "scalar", "series", "matrix", "string", "bundle", "array" ou "null".

# uniform
Resultado:  série
Argumentos: a (escalar)
            b (escalar)

Cria uma variável pseudo-aleatória uniforme no intervalo ( a, b) ou, se
não forem fornecidos argumentos, será utilizado o intervalo (0,1). O
algoritmo utilizado por padrão é o "SIMD-oriented Fast Mersenne Twister"
desenvolvido por Saito and Matsumoto (2008).

Ver também"randgen", "normal", "mnormal", "muniform".

# uniq
Resultado:  vetor coluna
Argumento:  x (série ou vetor)

Retorna um vetor contendo os elementos distintos de x de forma não
ordenada, mas na ordem em que aparecem em x. Veja "values" para a variante
desta função que retorna os valores ordenados.

# unvech
Resultado:  matriz quadrada
Argumento:  v (vetor)

Retorna uma matriz simétrica de ordem n x n rearranjando os elementos de v.
O número de elementos de v deve ser um inteiro triangular, ou seja, um
número k tal que exista um inteiro n que tenha a seguinte propriedade: k =
n(n+1)/2. Esta função é a inversa de "vech".

Ver também"mshape", "vech".

# upper
Resultado:  matriz quadrada
Argumento:  A (matriz quadrada)

Retorna uma matriz triangular superior de ordem n x n. Os elementos da
diagonal e acima desta são iguais aos elementos correspondentes de A e os
demais iguais a zero.

Ver também"lower".

# urcpval
Resultado:  escalar
Argumentos: tau (escalar)
            n (número inteiro)
            niv (número inteiro)
            itv (número inteiro)

P-valores para a estatística de teste do teste de raízes unitárias de
Dickey-Fuller e do teste de cointegração de Engle-Granger, conforme James
MacKinnon (1996).

Os argumentos dessa função são: tau representa a estatística de teste; n
representa o número de observações (ou 0 para um resultado assintótico);
niv representa o número de variáveis potencialmente cointegradas quando se
estiver testando a cointegração (ou 1 para testes univariados de raiz
unitária) e; itv é um código para a especificação do modelo: 1 para
teste sem constante, 2 para teste com constante, 3 para teste com contante e
tendência linear, 4 para teste com constante e tendência quadrática.

Note que se a regressão de teste for "aumentada" com defasagens da
variável dependente, então será necessário fornecer um valor n igual a 0
para obter resultados assintóticos.

Ver também"pvalue", "qlrpval".

# values
Resultado:  vetor coluna
Argumento:  x (série ou vetor)

Retorna um vetor contendo os elementos distintos de x ordenados de forma
ascendente. Caso deseje truncar a parte decimal antes de aplicar a função,
utilize a expressão values(int(x)).

Ver também"uniq", "dsort", "sort".

# var
Resultado:  escalar ou série
Argumento:  x (série ou lista)

Se x for uma série, retorna a variância amostral na forma de um escalar,
ignorando quaisquer observações ausentes.

Se x for uma lista, retorna uma série y tal que y_t é a variância
amostral dos valores das variáveis na lista na observação t, ou NA se
existir algum valor ausente em t.

Em cada caso, a soma dos desvios ao quadrado em relação à média é
dividido por (n - 1) para n > 1. Caso contrário, a variância é igual a
zero se n = 1, ou é NA se n = 0.

Ver também"sd".

# varname
Resultado:  texto
Argumento:  v (número inteiro ou lista)

Se for utilizado um inteiro como argumento, a função retorna o nome da
variável com número ID igual a v ou um erro se esta variável não
existir.

Se for utilizado uma lista como argumento, retorna o texto (string) contendo
os nomes das variáveis na lista, separados por vírgulas. Se for fornecida
uma lista vazia será retornado um texto vazio. Para obter um arranjo
(array) de textos pode-se utilizar "varnames".

Exemplo:

        open broiler.gdt
        string s = varname(7)
        print s

# varnames
Resultado:  cadeia de texto
Argumento:  L (lista)

Retorna um arranjo (array) de textos (string) contendo os nomes das
variáveis na lista L. Se a lista for vazia será retornado um arranjo
vazio.

Exemplo:

        open keane.gdt
        list L = year wage status
        strings S = varnames(L)
        eval S[1]
        eval S[2]
        eval S[3]

# varnum
Resultado:  número inteiro
Argumento:  varname (texto)

Retorna o número ID da variável varname ou NA se a variável não existir.

# varsimul
Resultado:  matriz
Argumentos: A (matriz)
            U (matriz)
            y0 (matriz)

Simula um VAR de ordem p com n variáveis, ou seja, y(t) = A1 y(t-1) + ... +
Ap y(t-p) + u(t). A matriz de coeficientes A é composta através do
empilhamento das matrizes A_i horizontalmente, e tem ordem n x np, com uma
linha por equação. Isso corresponde as primeiras n linhas da matriz
companheira, acessada via $compan após o uso dos comandos var e vecm.

Os vetores u_t estão contidos (como linhas) em U (T x n). Valores iniciais
estão contidos em y0 (p x n).

Se o VAR contiver termos determinísticos e/ou regressores exógenos, estes
podem ser incluídos na matriz U. Cada linha de U passa a incluir esses
termos, ou seja, u(t) = B'x(t) + e(t).

A matriz de saída tem T + p linhas e n colunas e armazena os p valores
iniciais das variáveis endógenas mais T valores simulados.

Ver também"$compan", "var", "vecm".

# vec
Resultado:  vetor coluna
Argumento:  X (matriz)

Empilha as colunas de X como um vetor coluna. Ver também"mshape", "unvech",
"vech".

# vech
Resultado:  vetor coluna
Argumento:  A (matriz quadrada)

Retorna em um vetor coluna os elementos de A que estão em sua diagonal e
acima dela. Normalmente essa função é utilizada em matrizes simétricas.
Neste caso a essa operação pode ser revertida através da função
"unvech". Ver também"vec".

# weekday
Resultado:  o mesmo tipo que o argumento
Argumentos: ano (escalar ou série)
            mês (escalar ou série)
            dia (escalar ou série)

Retorna o dia da semana (domingo = 0, segunda-feira = 1, etc.) para a(s)
data(s) especificadas por três argumentos ou NA se a data for inválida.
Note que os três argumentos devem ser do mesmo tipo, ou seja, devem ser
todos do tipo escalar (inteiro) ou todos do tipo séries.

# wmean
Resultado:  série
Argumentos: Y (lista)
            W (lista)

Retorna uma série y tal que y_t é a média ponderada dos valores das
variáveis na lista Y na observação t, com os respectivos pesos dados
pelos valores das variáveis na lista W em t. Os pesos podem assim variar no
tempo. As listas Y e W devem ter o mesmo tamanho e os pesos devem ser
não-negativos.

Ver também"wsd", "wvar".

# wsd
Resultado:  série
Argumentos: Y (lista)
            W (lista)

Retorna uma série y tal que y_t é o desvio padrão amostral ponderado dos
valores das variáveis na lista Y na observação t, com os respectivos
pesos dados pelos valores das variáveis na lista W em t. Os pesos podem
assim variar no tempo. As listas Y e W devem ter o mesmo tamanho e os pesos
devem ser não-negativos.

Ver também"wmean", "wvar".

# wvar
Resultado:  série
Argumentos: X (lista)
            W (lista)

Retorna uma série y tal que y_t é a variância amostral ponderada dos
valores das variáveis na lista Y na observação t, com os respectivos
pesos dados pelos valores das variáveis na lista W em t. Os pesos podem
assim variar no tempo. As listas Y e W devem ter o mesmo tamanho e os pesos
devem ser não-negativos.

Ver também"wmean", "wsd".

# xmax
Resultado:  escalar
Argumentos: x (escalar)
            y (escalar)

Retorna o maior valor na comparação entre x e y. Se algum dos valores for
ausente será retornado NA.

Ver também"xmin", "max", "min".

# xmin
Resultado:  escalar
Argumentos: x (escalar)
            y (escalar)

Retorna o menor valor na comparação entre x e y. Se algum dos valores for
ausente será retornado NA.

Ver também"xmax", "max", "min".

# xmlget
Resultado:  texto
Argumentos: buf (texto)
            path (texto ou cadeia de texto)

O argumento buf deve ser um buffer XML, que pode ser obtido de alguma
página na internet via função "curl" (ou lida a partir de arquivo via
função "readfile"), e o argumento path deve ser uma especificação única
ou um vetor de especificações.

Esta função retorna uma variável de texto (string) representando os dados
encontrados no buffer XML no path especificado. Se múltiplos nós
corresponderem com a expressão path, os itens dos dados são apresentados
em linhas separadas no texto retornado. Se um vetor de paths for utilizado
como segundo argumento, o texto retornado assume a forma de um buffer
separado por vírgulas, com a coluna i contendo as correspondências do path
i. Nesse caso, se um texto obtido do buffer XML contiver quaisquer espaços
ou vírgulas ela ficará entre aspas duplas.

Por padrão um erro é sinalizado se path não encontrar correspondência no
buffer XML, mas esse comportamento é modificado se o terceiro argumento,
que é opcional, for dado: nesse caso o argumento recupera o número de
correspondências e uma variável de texto vazia é retornada caso não haja
correspondências. Exemplo:

	  ngot = 0
	  ret = xmlget(xbuf, "//some/thing", &ngot)

Entretanto, um erro ainda é sinalizado no caso de uma consulta (query) mal
formada.

Uma boa introdução sobre a utilização da sintaxe de XPath pode ser
encontrada em https://www.w3schools.com/xml/xml_xpath.asp. O backend para
xmlget é fornecido pelo módulo xpath do biblioteca libxml2 que, por sua
vez, suporta o XPath 1.0 mas não o XPath 2.0.

Ver também"jsonget", "readfile".

# zeromiss
Resultado:  o mesmo tipo que o argumento
Argumento:  x (escalar ou série)

Converte zeros para NAs. Se x for uma série a conversão será feita
elemento por elemento. Ver também"missing", "misszero", "ok".

# zeros
Resultado:  matriz
Argumentos: r (número inteiro)
            c (número inteiro)

Retorna uma matriz nula com r linhas e c colunas. Ver também"ones", "seq".