gretl-common 2017d-3build1 / usr / share / gretl / gretl_cli_fnref.gl

## Accessors
# $ahat
Resultado:     serie

Debe de executarse logo de que o último modelo se estimase con datos de
panel de efectos fixos ou de efectos aleatorios. Devolve unha serie que
contén as estimacións dos efectos individuais.

# $aic
Resultado:     escalar

Se pode calcularse, devolve un escalar co valor do Criterio de Información
de Akaike (AIC) do último modelo estimado. Máis detalles sobre o cálculo
no Guía de usuario de Gretl (Capítulo 24).

# $bic
Resultado:     escalar

Se pode calcularse, devolve un escalar co valor do Criterio de Información
Bayesiano (BIC) de Schwarz do último modelo estimado. Máis detalles sobre
o cálculo no Guía de usuario de Gretl (Capítulo 24).

# $chisq
Resultado:     escalar

Se pode calcularse, devolve un escalar co valor do estatístico Khi-cadrado
global da proba de Razón de Verosimilitudes do último modelo estimado.

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

Sen argumentos $coeff devolve un vector columna que contén os coeficientes
do último modelo estimado. Co argumento opcional de texto (nome dun
regresor) a función devolve un escalar co valor do parámetro estimado dese
regresor. Mira tamén "$stderr", "$vcv".

Exemplo:

	  open bjg
	  arima 0 1 1 ; 0 1 1 ; lg
	  b = $coeff               # Devolve un vector
	  macoef = $coeff(theta_1) # Devolve un escalar

Se o "modelo" en cuestión é un sistema de ecuacións, o resultado depende
das características deste; para VARs e VECMs o resultado devolto é una
matriz con unha columna por cada ecuación; noutro caso é un vector columna
que contén os coeficientes da primeira ecuación seguidos polos
coeficientes da segunda ecuación e así de maneira sucesiva.

# $command
Resultado:     cadea

Debe executarse tras estimar un modelo e devolve a cadea cos caracteres da
instrución utilizada (exemplo: ols ou probit).

# $compan
Resultado:     matriz

Debe executarse logo da estimación dun VAR ou dun VECM e devolve a matriz
compañeira.

# $datatype
Resultado:     escalar

Devolve un escalar enteiro que representa o tipo de datos que se están
utilizando actualmente: 0 = sen datos; 1 = datos de corte transversal; 2 =
datos de series temporais; 3 = datos de panel.

# $depvar
Resultado:     cadea

Debe executarse logo da estimación dun modelo con unha única ecuación e
devolve unha cadea de texto co nome da variable dependente.

# $df
Resultado:     escalar

Devolve un escalar cos graos de liberdade do último modelo estimado. Se
este é un sistema de ecuacións, o valor devolto é o número de graos de
liberdade por cada ecuación. Se os graos de liberdade das diferentes
ecuacións non son os mesmos en todas elas, entón o valor devolto se
calcula restando o número de observacións menos a media do número de
coeficientes das ecuacións (esta media arredóndase ao valor enteiro
inmediatamente superior).

# $diagpval
Resultado:     escalar

Debe executarse logo da estimación dun sistema de ecuacións e devolve un
escalar coa probabilidade asociada ao valor do estatístico "$diagtest".

# $diagtest
Resultado:     escalar

Debe executarse logo da estimación dun sistema de ecuacións. Devolve un
escalar co valor do estatístico utilizado para probar a hipótese nula de
que a matriz de varianzas-covarianzas dos erros das ecuacións do sistema,
é diagonal. Esta é a proba de Breusch-Pagan, agás cando o estimador é o
dun SUR reiterado (sen restricións), pois nese caso é unha proba de Razón
de Verosimilitudes. Para obter máis detalles, véxase o Guía de usuario de
Gretl (Capítulo 30) (tamén "$diagpval").

# $dwpval
Resultado:     escalar

Se pode calcularse, devolve un escalar coa probabilidade asociada ao valor
do estatístico de Durbin-Watson do último modelo estimado. Calcúlase
utilizando o método Imhof.

Debido á limitada precisión da aritmética das computadoras, o resultado
do cálculo da integral do método Imhof pode volverse negativo cando o
estatístico de Durbin-Watson está próximo ao seu límite inferior; por
iso este accesorio devolve NA nesa situación. Dado que calquera outra
modalidade de fallo ten como resultado un erro que se sinaliza, posiblemente
é seguro asumir que un resultado NA indica que a verdadeira probabilidade
asociada é "moi pequena", aínda que non sexa posible cuantificala.

# $ec
Resultado:     matriz

Debe executarse logo da estimación dun VECM e devolve unha matriz que
contén os termos de Corrección de Erros. O número de filas é igual ao
número de observacións utilizadas e o número de columnas é igual á orde
de cointegración do sistema.

# $error
Resultado:     escalar

Devolve un escalar cun dos códigos internos de fallo do programa. Ese
código é un valor non nulo cando ocorre un fallo pero é capturado usando
a función "catch". Cae na conta de ao utilizar este accesorio, o código
interno de fallo vólvese novamente cero. Se desexas obter a mensaxe de
fallo asociada a un $error en concreto, é preciso gardar o seu valor nunha
variable provisional, por exemplo utilizando o código:

	  err = $error
	  if (err)
	      printf "Obtívose o fallo %d (%s)\n", err, errmsg(err);
	  endif

Mira tamén "catch", "errmsg".

# $ess
Resultado:     escalar

Se pode calcularse, devolve un escalar coa suma dos erros cadrados do
último modelo estimado.

# $evals
Resultado:     matriz

Debe executarse logo da estimación dun VECM e devolve un vector que contén
os autovalores que se utilizan no cálculo da proba da traza para verificar
se existe cointegración.

# $fcast
Resultado:     matriz

Debe executarse logo da instrución de predición "fcast" e devolve unha
matriz cos valores previstos. Se o modelo que se utiliza para facer as
predicións é un sistema de ecuacións, a matriz está formada por unha
columna para cada ecuación; noutro caso é un vector columna.

# $fcse
Resultado:     matriz

Se pode calcularse, debe executarse logo de procesar a instrución "fcast" e
devolve unha matriz cas desviacións padrón das predicións. Se o modelo
que se utiliza para facer as predicións é un sistema de ecuacións, a
matriz está formada por unha columna para cada ecuación; noutro caso é un
vector columna.

# $fevd
Resultado:     matriz

Debe executarse logo da estimación dun VAR e devolve unha matriz que
contén a descomposición da varianza dos erros de predición (FEVD, na
sigla en inglés). Esa matriz ten h filas que indican o número de períodos
do horizonte de predición, o cal pode escollerse de forma manual por medio
de set horizon ou de forma automática en base á frecuencia dos datos.

Para un VAR con p variables, a matriz ten p ^2 columnas: as primeiras p
columnas conteñen a FEVD para a primeira variable do VAR; as p columnas
seguintes conteñen a FEVD para a segunda variable do VAR e así de maneira
sucesiva. A fracción (decimal) do erro de predición da variable i causada
por unha innovación na variable j vai atoparse entón inspeccionando a
columna (i - 1) p + j.

# $Fstat
Resultado:     escalar

Se pode calcularse, devolve un escalar co estatístico F da proba de validez
global do último modelo estimado.

# $gmmcrit
Resultado:     escalar

Debe executarse logo dun bloque gmm (do Método Xeneralizado dos Momentos) e
devolve un escalar co mínimo da función obxectivo.

# $h
Resultado:     serie

Debe executarse logo da instrución garch e devolve unha serie coas
varianzas condicionais estimadas.

# $hausman
Resultado:     vector fila

Debe executarse logo de estimar un modelo por medio de tsls ou panel coa
opción de efectos aleatorios e devolve un vector fila 1 x 3 que contén
nesta orde: o valor do estatístico da proba de Hausman, os graos de
liberdade que se corresponden e a probabilidade asociada ao valor do
estatístico.

# $hqc
Resultado:     escalar

Se pode calcularse, devolve un escalar co valor do Criterio de Información
de Hannan-Quinn para o último modelo estimado. Para detalles sobre o
cálculo, consulta o Guía de usuario de Gretl (Capítulo 24).

# $huge
Resultado:     escalar

Devolve un escalar cun número positivo moi grande. Por defecto é igual a
1.0E100, pero pode cambiarse coa instrución "set".

# $jalpha
Resultado:     matriz

Debe executarse logo de estimar un VECM e devolve a matriz de carga. O
número de filas desa matriz é igual ao número de variables do VECM, e o
número de columnas é igual ao rango de cointegración.

# $jbeta
Resultado:     matriz

Debe executarse logo de estimar un VECM e devolve a matriz de
cointegración. O seu número de filas é igual ao número de variables do
VECM (máis o número de variables esóxenas que se restrinxen ao espazo de
cointegración, se hai algunha); e o seu número de columnas é igual ao
rango de cointegración.

# $jvbeta
Resultado:     matriz cadrada

Debe executarse logo de estimar un VECM e devolve a matriz estimada de
varianzas-covarianzas dos elementos dos vectores de cointegración.

No caso de tratarse dunha estimación sen restricións, o número de filas
desa matriz é igual ao número de elementos non restrinxidos do espazo de
cointegración logo da normalización de Phillips. Polo contrario, de
tratarse da estimación dun sistema restrinxido por medio da instrución
restrict coa opción --full, obtense unha matriz singular con (n+m)r filas
(onde n é o número de variables endóxenas, m o número de variables
esóxenas restrinxidas ao espazo de cointegración e r o rango de
cointegración).

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

... orixina o seguinte resultado:

	  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:     cadea

Devolve unha cadea de texto que representa o idioma que se está usando (se
este pode determinarse). A cadea de texto está composta por dúas letras do
código de linguaxe ISO 639-1 (por exemplo, en para o idioma inglés, jp
para o xaponés, el para o grego) seguidas dun subliñado máis outras dúas
letras do código de país ISO 3166-1. Así, por exemplo, o idioma
portugués de Portugal represéntase por pt_PT ao tempo que o idioma
portugués do Brasil represéntase por pt_BR.

Se non é posible determinar o idioma actual, se devolve o texto "unknown".

# $llt
Resultado:     serie

Para unha selección de modelos que se estiman polo método de Máxima
Verosimilitude, a función devolve unha serie cos valores do logaritmo da
verosimilitude para cada observación. Polo momento esa función só está
dispoñible para logit e probit binarios, tobit e heckit.

# $lnl
Resultado:     escalar

Devolve un escalar co logaritmo da verosimilitude do último modelo estimado
(se fose aplicable).

# $macheps
Resultado:     escalar

Devolve un escalar co valor do "épsilon da máquina", o cal proporciona un
límite superior para o erro relativo debido ao arredondamento na
aritmética de punto flotante con dobre precisión.

# $mnlprobs
Resultado:     matriz

Debe executarse tras estimar un modelo logit multinomial (unicamente) e
devolve unha matriz coas probabilidades estimadas de cada resultado posible,
en cada observación da mostra utilizada na estimación do modelo. Cada
liña representa unha observación e cada columna un resultado.

# $model
Resultado:     paquete

Debe executarse logo de estimar modelos cunha única ecuación e devolve un
feixe ("bundle") que contén varias unidades de datos pertencentes ao
modelo. Inclúense todos os accesorios habituais dos modelos, que son
designados mediante claves iguais aos nomes deses accesorios habituais menos
o signo dólar inicial. Por exemplo, os erros aparecen baixo a clave uhat e
a suma de erros cadrados baixo ess.

Dependendo do estimador, podes dispoñer de información adicional. As
claves para tal información é de agardar que sexan explicativas por si
mesmas. Para ver o que está dispoñible podes gardar unha copia do feixe e
mostrar o seu contido, como por exemplo co código:

	  ols y 0 x
	  bundle b = $model
	  print b

# $ncoeff
Resultado:     enteiro

Devolve un número enteiro coa cantidade de coeficientes estimados no
último modelo.

# $nobs
Resultado:     enteiro

Devolve un número enteiro coa cantidade total de observacións que están
seleccionadas na mostra actual. Relacionado: "dtmax".

# $nvars
Resultado:     enteiro

Devolve un número enteiro coa cantidade de variables incluídas no conxunto
de datos actual (contando coa constante).

# $obsdate
Resultado:     serie

Pode executarse cando o conxunto de datos actual está formado por series
temporais con frecuencia decenal, anual, trimestral, mensual, datadas
semanalmente ou datadas diariamente. Tamén pode utilizarse con datos de
panel se a información temporal está axustada correctamente (consulta a
instrución "setobs"). Devolve unha serie formada por números con 8
díxitos co padrón YYYYMMDD (o formato de datos "básico" do ISO 8601), que
corresponden ao día da observación, ou ao primeiro día da observación no
caso dunha frecuencia temporal menor que a diaria.

Estas series poden resultar de utilidade cando se emprega a instrución
"join".

# $obsmajor
Resultado:     serie

Pode executarse cando as observacións do conxunto de datos actual teñen
unha estrutura maior:menor, como en series temporais trimestrais
(ano:trimestre), en series temporais mensuais (ano:mes), datos de horas
(día:hora) e datos de panel (individuo:período). Devolve unha serie que
mantén a compoñente maior (de menor frecuencia), de cada observación (por
exemplo, o ano).

Mira tamén "$obsminor", "$obsmicro".

# $obsmicro
Resultado:     serie

Pode executarse cando as observacións do conxunto de datos actual teñen
unha estrutura maior:menor:micro, como nas series temporais datadas
diariamente (ano:mes:día). Devolve unha serie que contén a compoñente
micro (de maior frecuencia) de cada observación (por exemplo, o día).

Mira tamén "$obsmajor", "$obsminor".

# $obsminor
Resultado:     serie

Pode executarse cando as observacións do conxunto de datos actual teñen
unha estrutura maior:menor, como en series temporais trimestrais
(ano:trimestre), series temporais mensuais (ano:mes), datos de horas
(día:hora) e datos de panel (individuo:período). Devolve unha serie que
contén a compoñente menor (de maior frecuencia) de cada observación (por
exemplo, o mes).

No caso de datos datados diariamente, $obsminor devolve unha serie co mes de
cada observación.

Mira tamén "$obsmajor", "$obsmicro".

# $pd
Resultado:     enteiro

Devolve un número enteiro coa frecuencia ou periodicidade dos datos (por
exemplo: 4 para datos trimestrais). No caso de datos de panel o valor
devolto é a cantidade de períodos de tempo do conxunto de datos.

# $pi
Resultado:     escalar

Devolve un escalar co valor de pi con dobre precisión.

# $pvalue
Resultado:     escalar ou matriz

Devolve a probabilidade asociada ao valor do estatístico de proba que foi
xerado pola última instrución explícita de proba de hipóteses (por
exemplo: chow). Consulta o Guía de usuario de Gretl (Capítulo 9) para
obter máis detalles.

Xeralmente devolve un escalar, mais nalgúns casos devolve unha matriz (por
exemplo, isto ocorre coas probabilidades asociadas aos valores dos
estatísticos da traza e do máximo-lambda da proba de cointegración de
Johansen). Neste caso os valores están dispostos na matriz do mesmo xeito
que nos resultados presentados.

Mira tamén "$test".

# $qlrbreak
Resultado:     escalar

Debe executarse logo da instrución "qlrtest" (que permite facer a proba QLR
para a quebra estrutural nun punto descoñecido). Devolve un escalar co
número enteiro positivo que indexa a observación na que se maximiza o
valor do estatístico de proba.

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

Sen argumentos este accesorio devolve o coeficiente de autocorrelación de
primeira orde para os erros do último modelo estimado. Agora ben, coa
sintaxe $rho(n) logo da estimación dun modelo por medio da instrución ar,
devolve a valor estimado correspondente ao coeficiente rho(n).

# $rsq
Resultado:     escalar

Se pode calcularse, devolve un escalar co valor do coeficiente R^2 non
corrixido do último modelo estimado.

# $sample
Resultado:     serie

Debe executarse logo de estimar un modelo dunha soa ecuación. Devolve unha
serie con unha variable ficticia que ten valores iguais a: 1 nas
observacións utilizadas na estimación, 0 nas observacións da mostra
actual non utilizadas na estimación (posiblemente debido a valores
ausentes), e NA nas observacións fora da mostra seleccionada actual.

Se desexas calcular estatísticos baseados na mostra que se utiliza para un
modelo dado, pode facerse, por exemplo co código:

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

# $sargan
Resultado:     vector fila

Debe executarse logo da instrución tsls. Devolve un vector fila 1 x 3 que
contén, nesta orde: o valor do estatístico da proba de
Sobreidentificación de Sargan, os correspondentes graos de liberdade e a
probabilidade asociada ao valor do estatístico. Se o modelo está
exactamente identificado, o estatístico non se pode calcular e tratar de
facelo provoca un fallo.

# $sigma
Resultado:     escalar ou matriz

Se o último modelo estimado foi uniecuacional, devolve un escalar coa
Desviación Padrón da regresión (S, ou noutras palabras, a desviación
padrón dos erros do modelo coa oportuna corrección dos graos de
liberdade). Se o último modelo estimado foi un sistema de ecuacións,
devolve unha matriz coas varianzas-covarianzas dos erros das ecuacións do
sistema.

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

Cando se utiliza sen argumentos, $stderr devolve un vector columna que
contén as desviacións padrón dos coeficientes do último modelo estimado.
Co argumento opcional (nome dun regresor) devolve un escalar co valor do
parámetro estimado dese regresor. s.

Se o "modelo" é un sistema de ecuacións, o resultado depende das
características deste: para VARs e VECMs o valor devolto é unha matriz que
contén unha columna por cada ecuación; noutro caso é un vector columna
que contén os coeficientes da primeira ecuación seguidos polos
coeficientes da segunda ecuación e así de maneira sucesiva.

Mira tamén "$coeff", "$vcv".

# $stopwatch
Resultado:     escalar

Debe executarse logo da instrución set stopwatch que activa a medición de
tempo da CPU. Ao usar este accesorio por primeira vez obtense un escalar coa
cantidade de segundos de CPU que pasaron dende a instrución set stopwatch.
Con cada acceso, reiníciase o reloxo, polo que as sucesivas utilizacións
de $stopwatch xeran cada vez un escalar cos segundos da CPU dende o acceso
previo.

# $sysA
Resultado:     matriz

Debe executarse logo de estimar un sistema de ecuacións simultáneas.
Devolve a matriz cos coeficientes das variables endóxenas retardadas (no
caso de que existan), na forma estrutural do sistema. Consulta tamén a
instrución "system".

# $sysB
Resultado:     matriz

Debe executarse logo de estimar un sistema de ecuacións simultáneas.
Devolve unha matriz cos coeficientes das variables esóxenas, na forma
estrutural do sistema. Consulta a instrución "system".

# $sysGamma
Resultado:     matriz

Debe executarse logo de estimar un sistema de ecuacións simultáneas.
Devolve unha matriz cos coeficientes das variables endóxenas
contemporáneas, na forma estrutural so sistema. Consulta a instrución
"system".

# $sysinfo
Resultado:     paquete

Devolve un feixe ("bundle") que contén información das capacidades do
Gretl e do sistema operativo no que está executándose. Os elementos do
feixe indícanse deseguido:

  mpi: número enteiro igual a 1 se o sistema admite MPI (Message Passing
  Interface) e 0 noutro caso.

  omp: número enteiro igual a 1 se Gretl compilouse con soporte para Open
  MP e 0 noutro caso.

  nproc: número enteiro que indica o número de procesadores dispoñibles.

  mpimax: número enteiro que indica o máximo número de procesos MPI que
  poden executarse en paralelo. É igual a cero se non se admite MPI; noutro
  caso é igual ao valor de nproc local, agás que se especifique un
  ficheiro de hosts MPI, caso no que é igual a suma do número de
  procesadores ou "slots" ao longo de todas a máquinas ás que se fai
  referencia no ficheiro.

  wordlen: número enteiro igual a 32 ou a 64 en sistemas de 32 bit e 64
  bit, respectivamente.

  os: cadea de texto que representa o sistema operativo, ben linux, osx,
  windows ou other.

  hostname: cadea de texto co nome da máquina (ou "host") onde o proceso
  actual de Gretl está executándose. Se non é posible determinar o nome,
  prodúcese unha volta atrás do localhost.

Fíxate en que pode accederse a elementos individuais do feixe mediante a
notación "dot" sen necesidade de copiar o feixe enteiro cun nome de usuario
específico. Por exemplo co código:

	  if $sysinfo.os == "linux"
	      # Faga algo que sexa propio do Linux
	  endif

# $T
Resultado:     enteiro

Devolve un número enteiro co número de observacións utilizadas na
estimación do último modelo.

# $t1
Resultado:     enteiro

Devolve un enteiro positivo co número que indexa a primeira observación da
mostra actualmente seleccionada.

# $t2
Resultado:     enteiro

Devolve un enteiro positivo co número que indexa a derradeira observación
da mostra actualmente seleccionada.

# $test
Resultado:     escalar ou matriz

Devolve o valor do estatístico de proba que foi xerado pola última
instrución explícita para unha proba de hipóteses (por exemplo: chow).
Consulta o Guía de usuario de Gretl (Capítulo 9) para obter máis
detalles.

Xeralmente devolve un escalar, mais nalgúns casos devolve unha matriz (por
exemplo, iso ocorre cos estatísticos da traza e do máximo-lambda da proba
de cointegración de Johansen). Neste caso os valores están dispostos na
matriz do mesmo xeito que nos resultados presentados.

Mira tamén "dpvalue".

# $tmax
Resultado:     enteiro

Devolve un enteiro co máximo valor válido establecido para indicar o final
do rango da mostra mediante a instrución "smpl". Na maioría dos casos,
isto vai ser igual ao número de observacións do conxunto de datos, pero
nunha función de Hansl, o valor $tmax podería ser menor, posto que o
acceso habitual aos datos dentro das funcións, limítase ao rango mostral
establecido polo solicitante.

Ten en conta que, en xeral, $tmax non é igual a "dnobs", que proporciona o
número de observacións do rango da mostra vixente.

# $trsq
Resultado:     escalar

Devolve o escalar TR^2 (o tamaño da mostra multiplicado polo R-cadrado do
último modelo), se está dispoñible.

# $uhat
Resultado:     serie

Devolve unha serie cos erros do último modelo estimado. Isto pode ter
diferentes significados dependendo dos estimadores utilizados. Por exemplo,
logo da estimación dun modelo ARMA, $uhat contén os erros da predición de
1 paso á fronte; logo da estimación dun probit, contén os erros
xeneralizados.

Cando o "modelo" en cuestión actual é un sistema de ecuacións (un VAR, un
VECM ou un sistema de ecuacións simultáneas), o $uhat sen parámetros xera
unha matriz cos erros de estimación de cada ecuación ordenados por
columnas.

# $unit
Resultado:     serie

Só e válido para datos de panel. Devolve unha serie con valor igual a 1 en
todas as observacións na primeira unidade ou grupo, 2 en todas as
observacións na segunda unidade ou grupo, e así sucesivamente.

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

Cando se utiliza sen argumentos, $vcv devolve unha matriz cadrada que
contén as varianzas-covarianzas estimadas dos coeficientes do último
modelo estimado. Se este último era uniecuacional pódense indicar os nomes
de dous regresores entre parénteses, para así obter un escalar coa
covarianza estimada entre s1 e s2. Mira tamén "$coeff", "$stderr".

Este accesorio non está dispoñible para VARs ou VECMs. Para modelos dese
tipo "$sigma" e "$xtxinv".

# $vecGamma
Resultado:     matriz

Debe executarse logo de estimar un VECM e devolve unha matriz na que as
matrices Gamma (cos coeficientes das diferenzas retardadas das variables
cointegradas) se agrupan unhas ao lado das outras. Cada fila indica unha
ecuación; para un VECM con nivel de retardo p existen p - 1 submatrices.

# $version
Resultado:     escalar

Devolve un escalar cun valor enteiro que designa a versión de Gretl. A
versión actual de Gretl está formada por unha cadea de texto que indica o
ano con formato de 4 díxitos seguido dunha letra desde a ata j, que
representa as sucesivas actualizacións dentro de cada ano (por exemplo,
2015d). O valor devolto por este accesorio está calculado multiplicando o
ano por 10 e sumándolle un número que representa á letra, na orde léxica
en base cero. Así, 2015d represéntase mediante 20153.

En versións anteriores ao Gretl 2015d, o identificador tiña o seguinte
formato: x.y.z (tres números enteiros separados por puntos); nese caso o
valor da función calculábase con 10000*x + 100*y + z. Por exemplo, a
última versión co formato antigo (1.10.2) transcribíase mediante 11002.
Deste xeito a orde numérica de $version foi preservada aínda despois de
mudar o esquema das versións.

# $vma
Resultado:     matriz

Debe executarse logo de estimar un VAR ou un VECM e devolve unha matriz que
contén a representación VMA ata a orde especificada por medio da
instrución set horizon. Para ter máis detalles, consulta o Guía de
usuario de Gretl (Capítulo 28).

# $windows
Resultado:     enteiro

Devolve un número enteiro co valor 1 se o Gretl esta executándose no
Windows, e 0 noutro caso. Poñendo como condición un destes valores, podes
escribir instrucións "shell " que podan executarse en diferentes sistemas
operativos.

Consulta tamén a instrución "shell".

# $xlist
Resultado:     lista

Se o último modelo estimado era uniecuacional, o accesorio devolve unha
lista cos seus regresores. Se o último modelo era un sistema de ecuacións,
devolve unha lista "global" coas variables esóxenas e predeterminadas (na
mesma orde na que aparecen co accesorio "$sysB"). Se o último modelo era un
VAR, devolve unha lista cos regresores esóxenos, se hai algún.

# $xtxinv
Resultado:     matriz

Debe executarse logo da estimación dun VAR ou VECM (unicamente) e devolve a
matriz X'X^-1, onde X é a matriz habitual cos regresores utilizados en cada
ecuación. Este accesorio non está dispoñible para un VECM estimado con
restricións impostas sobre a matriz de cargas(α).

# $yhat
Resultado:     serie

Devolve unha serie cos valores estimados da variable explicada da última
regresión.

# $ylist
Resultado:     lista

Se o último modelo estimado foi un VAR, un VECM ou un sistema de ecuacións
simultáneas, o accesorio devolve unha lista coas variables endóxenas. Se o
último modelo estimado foi uniecuacional, o accesorio devolve unha lista
cun único elemento, a variable dependente. No caso especial do modelo
biprobit, a lista contén dous elementos.

## Functions proper
# abs
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co valor absoluto de x.

# acos
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) cos radiáns do arco coseno dex;
é dicir, dá o arco cuxo coseno é x (o argumento debe estar entre -1 e 1).

# acosh
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co coseno hiperbólico inverso
de x (solución positiva). Este último debe ser maior ca 1, pois se non a
función devolverá NA. Mira tamén "cosh".

# aggregate
Resultado:     matriz
Argumentos:  x (serie ou lista)
            byvar (serie ou lista)
            funcname (cadea, opcional)

Na forma máis simple de uso desta función, x establécese igual a null,
byvar é unha serie individual e o terceiro argumento omítese. Nese caso
devólvese unha matriz con dúas columnas que contén: os distintos valores
de byvar ordenados de forma crecente na primeira columna, e o número de
observacións nas que byvar toma cada un deses valores. Por exemplo...

	  open data4-1
	  eval aggregate(null, bedrms)

... amosará que a serie bedrms ten os valores 3 (en total 5 veces) e 4 (en
total 9 veces).

Se x e byvar son ambas series individuais, e indicas o terceiro argumento
desta función, o valor que se devolve é unha matriz con tres columnas que
vai conter respectivamente: os distintos valores de byvar ordenados de forma
crecente, o número de observacións nas que byvar toma cada un deses
valores, e os valores do estatístico que especifica a función funcname,
calculado para a serie x, pero usando tan só aquelas observacións nas que
byvar toma o mesmo valor que se especifica na primeira columna da matriz.

De xeito máis xeral, se byvar é unha lista con n elementos, entón as n
columnas á esquerda conteñen as combinacións dos distintos valores de
cada unha das n series e a columna de reconto contén o número de
observacións nas que se produce cada combinación. Se x é unha lista con m
elementos, entón as m columnas máis a dereita conteñen os valores do
estatístico especificado, para cada unha das variables de x, novamente
calculadas na submostra indicada na(s) primeira(s) columna(s).

As seguintes opcións de funcname mantéñense de forma "orixinal": "sum",
"sumall", "mean", "sd", "var", "sst", "skewness", "kurtosis", "min", "max",
"median", "nobs" e "gini". Cada unha destas funcións utiliza á súa vez
unha serie como argumento e devolve un valor escalar; por iso, neste
sentido, pode dicirse que de algún xeito "agregan" a serie. Podes utilizar
unha función definida polo usuario como "agregador"; nese caso, da mesma
forma que as funcións orixinais, esa función debe de ter como argumento
unicamente unha serie e devolver un valor escalar.

Cae na conta de que, a pesar de que aggregate fai o reconto de casos de
forma automática, a opción nobs, non é redundante como función
"agregadora", posto que proporciona o número de observacións válidas (non
ausentes) de x en cada combinación de byvar.

Como exemplo sinxelo, supón que con rexion se definen uns códigos para
representar unha distribución xeográfica por rexións, utilizándose para
iso enteiros desde 1 ata n e que con renda se representa a renda dos
fogares. Entón o código indicado deseguido debe producir unha matriz de
orde n x 3 que contén os códigos das rexións, o reconto de observacións
de cada unha e a renda media dos fogares en cada unha:

	  matrix m = aggregate(renda, rexion, mean)

Como exemplo de utilización con listas de variables, sexa xenero unha
variable binaria home/muller, sexa raza unha variable categórica con tres
valores e considera o seguinte código:

	  list BY = xenero raza
	  list X = renda idade
	  matrix m = aggregate(X, BY, sd)

Invocar a función aggregate producirá unha matriz de orde 6 x 5. As dúas
primeiras columnas conteñen as 6 distintas combinacións dos valores de
xénero e raza; a columna do medio contén o reconto do número de casos
para cada unha desas combinacións; e as dúas columnas máis á dereita
conteñen as desviacións padrón mostrais de renda e idade.

Observa que se byvar é unha lista de variables, algunhas combinacións dos
valores de byvar poden non estar presentes nos datos (producíndose un
reconto igual a cero). Nese caso os valores dos estatísticos para x se
rexistran como NaN (e dicir, non son números). Se queres ignorar eses
casos, podes usar a función "selifr" para escoller só aquelas filas que
non teñan reconto igual a cero. A columna a comprobar estará unha
posición á dereita da indicada polo número de variables de byvar, polo
que pode usarse o código:

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

# argname
Resultado:     cadea
Argumento:   s (cadea)

Se s é o nome dun parámetro dunha función definida previamente polo
usuario, devolve unha cadea co nome dese argumento, ou baleira se o
argumento fora anónimo.

# array
Resultado:     Mira máis abaixo
Argumento:   n (enteiro)

Esta é a función "construtora" básica dunha nova variable de tipo arranxo
("array"). Ao usar esta función é necesario que especifiques un tipo (na
forma plural) para o arranxo: strings, matrices, bundles ou lists. Devolve
un arranxo do tipo especificado con n elementos "baleiros" (por exemplo unha
cadea de texto ("string") baleira ou unha matriz nula). Exemplos de
utilización:

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

Consulta tamén "defarray".

# asin
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) cos radiáns do arco seno dex;
é dicir, dá o arco cuxo seno é x (o argumento debe estar entre -1 e 1).

# asinh
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co seno hiperbólico inverso de
x. Mira tamén "sinh".

# atan
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) cos radiáns do arco tanxente de
x; é dicir, devolve o arco cuxa tanxente é x.

Mira tamén "cos", "sin", "tan".

# atanh
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) coa tanxente hiperbólica
inversa de x. Mira tamén "tanh".

# atof
Resultado:     escalar
Argumento:   s (cadea)

Función moi relacionada coa da linguaxe de programación C co mesmo nome.
Devolve un escalar co resultado de converter a cadea de texto s (ou o seu
anaco relevante, logo de descartar calquera espazo en branco inicial) nun
número de punto flotante. A diferenza do que ocorre na linguaxe C, a
función atof sempre asume que o carácter decimal é o "." (por cuestións
de transportabilidade). Ignóranse todos os caracteres que seguen logo da
parte de s que se converte en número de punto flotante.

Se, baixo o suposto establecido, non puidera converterse ningún dos
caracteres de s que queden logo de descartar os espazos en branco, a
función devolve NA.

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

Consulta tamén "sscanf" se queres ter maior flexibilidade nas conversións
de cadeas de texto en números.

# bessel
Resultado:     mesmo tipo que o introducido
Argumentos:  type (carácter)
            v (escalar)
            x (escalar, serie ou matriz)

Permite calcular unha das variantes da función de Bessel de clase v con
argumento x. O valor que devolve é do mesmo tipo que este x. A clase de
función escóllese co primeiro argumento que debe ser J, Y, I ou K. Unha
boa discusión sobre as funcións de Bessel pode atoparse na Wikipedia, mais
aquí ofrécense uns breves comentarios.

Caso J: función de Bessel de primeira clase que se asemella a unha onda
sinusoidal amortecida. Defínese para v real e x, pero se x fose negativo,
entón v debe ser un número enteiro.

Caso Y: función de Bessel de segunda clase. Defínese para v real e x, pero
con unha singularidade en x = 0.

Caso I: función de Bessel modificada de primeira clase que presenta un
crecemento exponencial. Os argumentos que poden usarse con ela son os mesmos
que no caso J.

Caso K: función de Bessel modificada de segunda clase que presenta un
decrecemento exponencial. Diverxe en x = 0, non está definida para valores
negativos de x e é simétrica arredor de v = 0.

# BFGSmax
Resultado:     escalar
Argumentos:  &b (referencia a matriz)
            f (chamada a función)
            g (chamada a función, opcional)

Devolve un escalar co resultado dunha maximización numérica feita co
método de Broyden, Fletcher, Goldfarb e Shanno. O argumento b debe de
conter os valores iniciais dun conxunto de parámetros e o argumento f debe
de especificar unha chamada á función que vai calcular o criterio
obxectivo (escalar) que se quere maximizar, dados os valores actuais dos
parámetros, así como calquera outros datos que sexan relevantes. Se o que
pretendes é en realidade minimizar o criterio obxectivo, esta función
devolve o valor negativo dese criterio obxectivo. Cando se completa con
éxito a súa execución, BFGSmax devolve o valor maximizado do criterio
obxectivo, e b contén finalmente os valores dos parámetros que
proporcionan o máximo dese criterio.

O terceiro argumento (opcional) establece unha maneira de proporcionar
derivadas analíticas (noutro caso o gradiente compútase numericamente). A
chamada g á función gradiente debe de ter como primeiro argumento a unha
matriz definida previamente que teña o tamaño axeitado para poder
almacenar o gradiente, dado en forma de punteiro. Así mesmo tamén precisa
ter como argumento (en forma de punteiro ou non) ao vector de parámetros.
Outros argumentos son opcionais.

Para máis detalles e exemplos, consulta o capítulo sobre métodos
numéricos no Guía de usuario de Gretl (Capítulo 33). Mira tamén
"BFGScmax", "NRmax", "fdjac", "simann".

# BFGSmin
Resultado:     escalar

Un alcume de "BFGSmax". Se invocas a función baixo este nome, execútase
facendo unha minimización.

# BFGScmax
Resultado:     escalar
Argumentos:  &b (referencia a matriz)
            bounds (matriz)
            f (chamada a función)
            g (chamada a función, opcional)

Devolve un escalar co resultado dunha maximización con restricións por
medio do método L-BFGS-B (BFGS con memoria limitada, consulta Byrd, Lu,
Nocedal e Zhu, 1995). O argumento b debe de conter os valores iniciais dun
conxunto de parámetros, o argumento bounds debe de conter as restricións
aplicadas aos valores dos parámetros (consulta máis abaixo) e o argumento
f debe de especificar unha chamada á función que vai calcular o criterio
obxectivo (escalar) que se quere maximizar, dados os valores actuais dos
parámetros así como calquera outros datos que sexan relevantes. Se o que
pretendes realmente é minimizar o criterio obxectivo, esta función debe
devolver o valor negativo dese criterio. Ao completar con éxito a súa
execución, BFGScmax devolve o valor máximo do criterio obxectivo, dadas as
restricións de bounds, e b contén finalmente os valores dos parámetros
que maximizan o criterio.

A matriz bounds debe de ter 3 columnas e un número de filas igual ao
número de elementos restrinxidos no vector de parámetros. O primeiro
elemento dunha fila dada é o enteiro positivo que indexa o parámetro
restrinxido; o segundo e o terceiro elementos son os límites inferior e
superior, respectivamente. Os valores -$huge e $huge deben usarse para
indicar que o parámetro non posúe restricións inferiores ou superiores,
respectivamente. Por exemplo, a seguinte expresión é a forma de
especificar que o segundo elemento do vector de parámetros debe de ser non
negativo:

	  matrix bounds = {2, 0, $huge}

O cuarto argumento (opcional) estabelece unha maneira de proporcionar
derivadas analíticas (noutro caso o gradiente compútase numericamente). A
chamada g á función gradiente debe de ter como primeiro argumento a unha
matriz definida previamente que teña o tamaño axeitado para poder
almacenar o gradiente, dado en forma de punteiro. Así mesmo tamén precisa
ter como argumento (en forma de punteiro ou non) ao vector de parámetros.
Outros argumentos son opcionais.

Para máis detalles e exemplos, consulta o capítulo sobre métodos
numéricos no Guía de usuario de Gretl (Capítulo 33). Mira tamén
"BFGSmax", "NRmax", "fdjac", "simann".

# BFGScmin
Resultado:     escalar

Un alcume de "BFGScmax". Se invocas a función baixo este nome, execútase
facendo unha minimización.

# bkfilt
Resultado:     serie
Argumentos:  y (serie)
            f1 (enteiro, opcional)
            f2 (enteiro, opcional)
            k (enteiro, opcional)

Devolve unha serie co resultado da aplicación do filtro paso-banda de
Baxter-King a unha serie y. Os parámetros opcionais f1 e f2 representan, de
maneira respectiva, os límites inferior e superior do rango de frecuencias
que se vai extraer, namentres que k representa a orde de aproximación que
se vai utilizar.

Se non se proporcionan eses argumentos, entón os valores por defecto van
depender da periodicidade do conxunto de datos. Para datos anuais os valores
por defecto para f1, f2 e k son 2, 8 e 3 respectivamente; para datos
trimestrais son 6, 32 e 12; e para datos mensuais son 18, 96 e 36. Eses
valores escóllense para coincidir coa elección máis común entre os
usuarios, que consiste na utilización deste filtro para extraer a
compoñente de frecuencia do "ciclo de negocios". Isto, á súa vez,
defínese habitualmente comprendido entre 18 meses e 8 anos. O filtro abarca
3 anos de datos, na elección por defecto.

Se f2 é maior ou igual ao número de observacións dispoñibles, entón
execútase a versión "paso-baixo" do filtro, e a serie resultante debe
considerarse como unha estimación da compoñente de tendencia, máis ca da
compoñente do ciclo. Mira tamén "bwfilt", "hpfilt".

# boxcox
Resultado:     serie
Argumentos:  y (serie)
            d (escalar)

Devolve a serie resultante da transformación de Box-Cox con parámetro d
dunha serie positiva y.

A serie transformada é (y^d - 1)/d para d distinto de cero ou log(y) para d
= 0.

# bread
Resultado:     paquete
Argumentos:  fname (cadea)
            import (booleano, opcional)

Devolve a lectura dun feixe ("bundle") a partir dun ficheiro de texto. A
cadea de texto debe de conter o nome do ficheiro do cal se le o feixe. Se
ese nome ten a extensión ".gz" asúmese que se aplicou a compresión gzip
cando se gardou ese ficheiro.

O ficheiro en cuestión debe ser un ficheiro XML apropiadamente definido:
debe de conter un elemento gretl-bundle, que se use para almacenar cero ou
máis 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 cabería agardar, estes ficheiros os xera automaticamente a función
asociada "bwrite".

Se o nome do ficheiro non contén a especificación completa do camiño ao
cartafol que o contén, entón vai procurarse en varias localizacións
"probables", comezando no establecido como "workdir" actual. Agora ben,
cando se proporciona un valor non nulo para o argumento opcional import, o
ficheiro vai procurarse no cartafol "dot" do usuario. Neste caso o argumento
fname deberá ser un nome simple de ficheiro, sen a inclusión do camiño ao
cartafol.

Se ocorre algún fallo (por exemplo que o ficheiro estea mal formatado ou
sexa inaccesible), devólvese o fallo por medio do accesorio "$error".

Mira tamén "mread", "bwrite".

# bwfilt
Resultado:     serie
Argumentos:  y (serie)
            n (enteiro)
            omega (escalar)

Devolve unha serie co que resulta de aplicar un filtro paso-baixo de
Butterworth de orde n e frecuencia de corte omega na serie y. O corte
exprésase en graos e debe de ser maior ou igual a cero, e menor ca180. Os
valores de corte máis pequenos van restrinxir o paso-banda a menores
frecuencias e así producen unha tendencia máis suave. Os valores maiores
de n producen un corte máis agudo, mais co custo de poder ter
inestabilidade numérica.

A inspección preliminar do periodograma da serie de interese é moi útil
cando se desexa aplicar esta función. Para obter máis detalles, consulta o
Guía de usuario de Gretl (Capítulo 26). Mira tamén "bkfilt", "hpfilt".

# bwrite
Resultado:     enteiro
Argumentos:  B (paquete)
            fname (cadea)
            export (booleano, opcional)

Escribe o feixe ("bundle") B nun ficheiro XML con nome fname. Se xa existe
un ficheiro denominado fname, vaise sobrescribir. Para unha descrición
concisa do seu formato, consulta "bread". Esta función devolve o valor 0 no
caso de conclusión con éxito; se ocorren fallos, tales como a
imposibilidade de sobrescribir o ficheiro, a función devolve un valor non
nulo.

O ficheiro de saída gárdase no cartafol "workdir" actual agás que a cadea
fname conteña o camiño completo co cartafol onde vai ser gardado. Agora
ben, cando se indica un valor non nulo para o argumento export, o ficheiro
de saída vaise gardar no cartafol "dot" do usuario. Neste caso o argumento
fname deberá de ser un nome simple de ficheiro, sen a inclusión do camiño
ao cartafol.

Por defecto, o ficheiro XML gárdase sen comprimir, mais se o fname ten a
extensión .gz entón aplícase a compresión gzip.

Mira tamén "bread", "mwrite".

# cdemean
Resultado:     matriz
Argumento:   X (matriz)

Devolve unha matriz coas columnas da matriz X centradas con respecto ás
súas medias.

# cdf
Resultado:     mesmo tipo que o introducido
Argumentos:  d (cadea)
            ... (Mira máis abaixo)
            x (escalar, serie ou matriz)
Exemplos:   p1 = cdf(N, -2.5)
            p2 = cdf(X, 3, 5.67)
            p3 = cdf(D, 0.25, -1, 1)

Calcula o valor da función de distribución acumulativa e devolve un
resultado (do mesmo tipo ca o argumento) coa probabilidade P(X <= x), onde a
distribución de X se especifica por medio da letra d. Entre os argumentos d
e x, pode necesitarse algún argumento adicional escalar para especificar os
parámetros da distribución, tal e como se indica a continuación (pero
observa que a distribución Normal ten a súa propia función, por
conveniencia, "cnorm"):

  Normal estándar (c = z, n ou N): sen argumentos extras

  Normal bivariante (D): coeficiente de correlación

  t de Student (t): graos de liberdade

  Khi-cadrado (c, x ou X): graos de liberdade

  F de Snedecor (f ou F): graos de liberdade (num.), graos de liberdade
  (den.)

  Gamma (g ou G): forma, escala

  Binomial (b ou B): probabilidade, cantidade de ensaios

  Poisson (p ou P): media

  Exponencial (exp): escala

  Weibull (w ou W): forma, escala

  Erro Xeneralizado (E): forma

  Khi-cadrado non central (ncX): graos de liberdade, parámetro de non
  centralidade

  F non central (ncF): graos de liberdade (num.), graos de liberdade (den.),
  parámetro de non centralidade

  t non central (nct): graos de liberdade, parámetro de non centralidade

Cae na conta de que na maioría dos casos existen alcumes para axudar a
memorizar os códigos. O caso da normal bivariante é especial: a sintaxe é
x = cdf(D, rho, z1, z2) onde rho é o coeficiente de correlación entre as
variables z1 e z2.

Mira tamén "pdf", "critical", "invcdf", "pvalue".

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

Devolve unha matriz co resultado de dividir números complexos. Os dous
argumentos deben comporse do mesmo número de filas, n, e dunha ou dúas
columnas. A primeira columna contén a parte real e a segunda (se existe)
contén a parte imaxinaria. O resultado que se devolve é unha matriz de
orde n x 2 ou, no caso de non existir a parte imaxinaria, un vector con n
filas. Mira tamén "cmult".

# cdummify
Resultado:     lista
Argumento:   L (lista)

Esta función devolve unha lista na que cada serie do argumento L que teña
o atributo "codificado" substitúese por un conxunto de variables ficticias
que representan cada un dos seus valores codificados, pero omitindo o valor
máis pequeno. Se o argumento L non contén ningunha serie codificada, o
valor que se devolve vai ser idéntico a L.

No caso de que se xeren, as variables ficticias noméanse co padrón
Dvarname_vi, no que vi indica o i^ésimo valor representado da variable que
se codifica. No caso de que algúns dos valores sexan negativos, vaise
inserir "m" antes do valor (absoluto) de vi.

Por exemplo, supón que L contén unha serie codificada chamada C1 cos
valores -9, -7, 0, 1 and 2. Entón, as variables ficticias xeradas van ser
DC1_m7 (que codifica cando C1 = -7), DC1_0 (que codifica cando C1 = 0),
etcétera.

Mira tamén "dummify", "getinfo".

# ceil
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Función tope: devolve un resultado (do tipo do argumento) co menor enteiro
que sexa maior ou igual a x. Mira tamén "floor", "int".

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

Realiza a descomposición de Cholesky da matriz A, asumindo que esta é
simétrica e definida positiva. O resultado é unha matriz triangular
inferior L que verifica a igualdade A = LL'. A función vai fallar se A non
é simétrica ou non é definida positiva. Mira tamén "psdroot".

# chowlin
Resultado:     matriz
Argumentos:  Y (matriz)
            xfac (enteiro)
            X (matriz, opcional)

Devolve unha matriz como resultado de expandir os datos de entrada, Y, a
unha frecuencia maior co método de Chow e Lin (1971). Asúmese que as
columnas de Y representan series de datos. A matriz que se devolve ten o
mesmo número de columnas que Y e xfac veces o seu número de filas.

O segundo argumento representa o factor de expansión: debe de ser igual a 3
para expandir datos trimestrais a mensuais, ou igual a 4 para facelo de
datos anuais a trimestrais (estes son os únicos factores admitidos
actualmente). O terceiro argumento (opcional) pode usarse para prover unha
matriz de covariables con maior frecuencia obxectivo.

Os regresores que se utilizan por defecto son unha constante e unha
tendencia cadrada. Cando se proporciona X, as súas columnas utilízanse
como regresores adicionais. A función devolve un fallo se o número de
filas de X non é igual a xfac veces o número de filas de Y.

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

Devolve unha matriz co resultado de multiplicar números complexos. Os dous
argumentos deben comporse do mesmo número de filas, n, e dunha ou dúas
columnas. A primeira columna contén a parte real e a segunda (se existe)
contén a parte imaxinaria. O resultado que se devolve é unha matriz de
orde n x 2 ou, no caso de non existir a parte imaxinaria, un vector con n
filas. Mira tamén "cdiv".

# cnorm
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve a función de distribución acumulativa para unha Normal estándar.
Mira tamén "dnorm", "qnorm".

# cnumber
Resultado:     escalar
Argumento:   X (matriz)

Devolve un escalar co número de condición dunha matriz X de orde n x k,
conforme se define en Belsley, Kuh e Welsch (1980). Se as columnas de X son
mutuamente ortogonais, o número de condición de X é a unidade. Pola
contra, un valor grande do número de condición enténdese como un indicio
de alto grao de multicolinearidade; habitualmente considérase que o valor
é "grande" se é maior ou igual a 50 (ou, algunhas veces, a 30).

Os pasos para facer os cálculos son: (1) conformar unha matriz Z cuxas
columnas sexan o resultado de dividir cada columna de X pola súa respectiva
norma euclidiana; (2) construír a matriz Z'Z e obter os seus autovalores; e
(3) calcular a raíz cadrada da razón entre o maior e o menor autovalor.

Mira tamén "rcond".

# colname
Resultado:     cadea
Argumentos:  M (matriz)
            col (enteiro)

Devolve unha cadea co nome da columna col da matriz M. Se as columnas de M
non teñen nome, entón devólvese unha cadea baleira; e se col está fóra
dos límites do número de columnas desta matriz, amósase un fallo.
Consulta tamén "colnames".

Exemplo:

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

# colnames
Resultado:     escalar
Argumentos:  M (matriz)
            S (arranxo de cadeas ou lista)

Engade nomes ás columnas da matriz de orde T x k, M. Cando S é unha lista,
os nomes son os das series listadas (é preciso que esa lista teña
kelementos). Cando S é un arranxo de cadeas de texto, deberá de ter k
elementos. Para manter a compatibilidade con versións anteriores de Gretl,
podes tamén utilizar unha única cadea de texto como segundo argumento.
Nese caso, esta cadea precisa ter k subcadeas separadas por espazos.

Devolve o valor 0 se as columnas son nomeadas con éxito; noutro caso
devolve un valor non nulo. Consulta tamén "rownames".

Exemplo:

	  matrix M = {1, 2; 2, 1; 4, 1}
	  strings S = array(2)
	  S[1] = "Col1"
	  S[2] = "Col2"
	  colnames(M, S)
	  print M

# cols
Resultado:     enteiro
Argumento:   X (matriz)

Devolve un enteiro co número de columnas da matriz X. Mira tamén "mshape",
"rows", "unvech", "vec", "vech".

# corr
Resultado:     escalar
Argumentos:  y1 (serie ou vector)
            y2 (serie ou vector)

Devolve un escalar co valor do coeficiente de correlación entre y1 e y2. Os
argumentos deben de ser dúas series ou dous vectores do mesmo tamaño. Mira
tamén "cov", "mcov", "mcorr", "npcorr".

# corrgm
Resultado:     matriz
Argumentos:  x (serie, matriz ou lista)
            p (enteiro)
            y (serie ou vector, opcional)

Cando se proporcionan só os dous primeiros argumentos, a función devolve
unha matriz co correlograma de x para os retardos de 1 ata p. Se k é o
número de elementos de x (igual a 1 se x é unha serie, igual ao número de
columnas se x é unha matriz, ou igual ao número de elementos se x é unha
lista), o valor que se devolve é unha unha matriz con p filas e 2k
columnas, onde as k primeiras columnas conteñen as respectivas
autocorrelacións e as restantes conteñen as respectivas autocorrelacións
parciais.

Cando se indica o terceiro argumento, esta función calcula o correlograma
cruzado desde +p ata -p para cada un dos k elementos de x e y. A matriz que
se devolve componse de 2p + 1 filas e k columnas. Se x é unha serie ou unha
lista, e y é un vector, este último é preciso que teña tantas filas coma
o número total de observacións que hai na mostra actualmente seleccionada.

# cos
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co coseno de x. Mira tamén
"sin", "tan", "atan".

# cosh
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co coseno hiperbólico de x.

Mira tamén "acosh", "sinh", "tanh".

# cov
Resultado:     escalar
Argumentos:  y1 (serie ou vector)
            y2 (serie ou vector)

Devolve un escalar coa covarianza entre y1 e y2. Os argumentos deben de ser
ben dúas series ou ben dous vectores da mesma longura. Mira tamén "corr",
"mcov", "mcorr".

# critical
Resultado:     mesmo tipo que o introducido
Argumentos:  c (carácter)
            ... (Mira máis abaixo)
            p (escalar, serie ou matriz)
Exemplos:   c1 = critical(t, 20, 0.025)
            c2 = critical(F, 4, 48, 0.05)

Permite calcular valores críticos e devolve un resultado do mesmo tipo que
o introducido. O valor x que se devolve vai cumprir P(X > x) = p, onde a
distribución X determínase pola letra c. Entre os argumentos d e x, pode
necesitarse algún outro adicional (escalar) para indicar os parámetros da
distribución. Isto faise deste xeito:

  Normal estándar (c = z, n ou N): sen argumentos extras

  t de Student (t): graos de liberdade

  Khi-cadrado (c, x ou X): graos de liberdade

  F de Snedecor (f ou F): graos de liberdade (num.), graos de liberdade
  (den.)

  Binomial (b ou B): probabilidade, cantidade de ensaios

  Poisson (p ou P): media

Mira tamén "cdf", "invcdf", "pvalue".

# cum
Resultado:     mesmo tipo que o introducido
Argumento:   x (serie ou matriz)

Acumula x (isto é, crea unha suma móbil). Cando x é unha serie, produce
unha serie y na que cada un dos seus elementos é igual á suma dos valores
de x ata a observación correspondente. O punto de partida para a
acumulación é a primeira observación non ausente da mostra actualmente
seleccionada. Cando x é unha matriz, os seus elementos acumúlanse por
columnas.

Mira tamén "diff".

# curl
Resultado:     escalar
Argumento:   &b (referencia a paquete)

Ofrece un medio bastante flexible de obter un "buffer" de texto que contén
datos dun servidor de internet, utilizando a biblioteca libcurl. Ao
escribila, o argumento de tipo feixe b, debe de conter unha cadea de texto
chamada URL que indica o enderezo completo do recurso no host de destino.
Outros elementos opcionais preséntanse deseguido:

  "header": unha cadea de texto que especifica un header HTTP que vai
  enviarse ao host.

  "postdata": unha cadea de texto que contén os datos que van enviarse ao
  host.

Os campos header e postdata destínanse para usarse cunha solicitude HTTP do
tipo POST. Se está presente postdata, vai implícito o método POST; noutro
caso vai implícito o método GET. (Mais observa que para sinxelas
solicitudes GET, a función "readfile" ofrece unha interface máis simple.)

Recoñécese outro elemento opcional do feixe: se está presente un escalar
chamado include e ten un valor non nulo, isto enténdese como unha
solicitude para incluír o header recibido do host, no corpo da saída.

Ao completarse a solicitude, o texto recibido do servidor engádese ao feixe
e recibe o nome de "output".

A función vai fallar se hai unha equivocación ao formular a solicitude
(por exemplo, se non existe a URL na entrada); noutro caso vai devolver o
valor 0 se a solicitude prospera, ou un valor non nulo se non o fai. Neste
último caso, engádese a mensaxe de fallo da biblioteca curl ao feixe, co
identificador "errmsg". Cae na conta, porén, que "éxito" neste senso non
significa necesariamente que obtés os datos que desexabas; en realidade
significa tan só que se recibiu algunha resposta do servidor. Debes
comprobar o contido do "buffer" de saída (que de feito pode ser unha
mensaxe tal como "Páxina non atopada").

Aquí temos un exemplo de como utilizar esta función: para baixar algúns
datos da web do US Bureau of Labor Statistics, que require o envío dunha
consulta JSON. Observa o uso de "sprintf" para inserir comiñas nos datos
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

Consulta tamén as funcións "jsonget" e "xmlget" para ver xeitos de
procesamento de datos recibidos no formato JSON e XML, respectivamente.

# dayspan
Resultado:     enteiro
Argumentos:  ed1 (enteiro)
            ed2 (enteiro)
            weeklen (enteiro)

Devolve un número enteiro co número de días (relevantes) entre os días
de época ed1 e ed2, ambos incluídos, considerando a duración de semana
indicada polo argumento weeklen. Este debe de ser igual a 5, 6 ou 7
(indicando o valor 6 que non se contan os domingos, e o 5 que non se contan
nin os sábados nin os domingos.

Para obter os días de época no formato máis familiar das datas, consulta
"epochday". Relacionado con isto, consulta "smplspan".

# defarray
Resultado:     Mira máis abaixo
Argumento:   ... (... (Mira máis abaixo))

Permite definir cumpridamente unha variable de tipo arranxo ("array"),
proporcionando un ou máis elementos. Ao utilizar esta función debes
especificar o tipo de arranxo (en forma plural): strings, matrices, bundles
ou lists. Cada un dos argumentos debe de ser un obxecto do mesmo tipo que o
tipo especificado na definición do arranxo. No caso de completarse con
éxito, a función devolve como resultado un arranxo con 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:])

Consulta tamén "array".

# defbundle
Resultado:     paquete
Argumento:   ... (... (Mira máis abaixo))

Te permite a carga inicial dunha variable feixe extensamente, proporcionando
cero ou máis pares co formato key, member. Se contamos os argumentos desde
1, cada argumento numerado impar debe de avaliar unha cadea de texto (chave)
e cada argumento numerado par debe de avaliar un obxecto dun tipo que poida
incluírse nun feixe.

Un par de exemplos sinxelos:

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

O primeiro exemplo xera un feixe cuxos elementos son unha cadea de texto e
unha matriz; o segundo, un feixe cun elemento que é unha serie e outro que
é escalar. Ten en conta que non podes especificar un tipo de cada argumento
cando utilizas esta función, entón debes de aceptar o tipo "natural" de
argumento en cuestión. Se queres engadir unha serie cun valor constante de
5 a un feixe chamado b1 sería necesario facer algo como o seguinte (despois
de enunciar b1):

	  series b1.s5 = 5

Se non indicas ningún argumento para esta función, iso equivale a xerar un
feixe baleiro (ou a baleirar un feixe existente do seu contido), como
podería facer mediante

	  bundle b = null

# deflist
Resultado:     lista
Argumento:   ... (... (Mira máis abaixo))

Xera unha lista (de series xa definidas) dados un ou máis argumentos
apropiados. Cada argumento debe de ser, ben unha serie xa definida (indicada
polo seu nome ou número enteiro ID) ou ben unha lista (indicada polo nome
dunha lista definida previamente ou por unha expresión que se corresponda
cunha lista).

Un punto a ter en conta é que esta función simplemente encadea as series
e/ou listas indicadas como argumentos, para producir a lista que devolve.
Cando se pretende que o valor que devolva non teña duplicados (que non se
refira a ningunha serie máis dunha vez), depende do solicitante asegurarse
de que se satisfaga ese requirimento.

# deseas
Resultado:     serie
Argumentos:  x (serie)
            c (carácter, opcional)

Precisa que estean instalados o TRAMO/SEATS e/ou X-12-ARIMA. Devolve unha
versión desestacionalizada (axustada estacionalmente) da serie x, que debe
de ser unha serie temporal mensual ou trimestral. Para utilizar o X-12-ARIMA
indica X como segundo argumento; e para usar o TRAMO/SEATS indica T. Se
omites o segundo argumento, Gretl utiliza o X-12-ARIMA.

Observa que cando a serie de entrada non ten unha compoñente estacional
detectable, a execución da función vai fallar. Cae na conta tamén de que
tanto o TRAMO/SEATS como o X-12-ARIMA ofrecen un gran número de opcións;
agora ben, a función deseas as utiliza con todas as súas opcións nos seus
valores por defecto. En ambos os dous programas, os factores estacionais
calcúlanse baseados nun modelo ARIMA automaticamente seleccionado. Unha das
diferenzas entre os dous que pode levar a resultados bastante distintos, é
que o TRAMO/SEATS realiza un axuste previo das observacións con valores
atípicos mentres que o X-12-ARIMA non o fai.

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

Devolve un escalar co valor do determinante de A, calculado por medio da
descomposición LU. Mira tamén "ldet", "rcond", "cnumber".

# diag
Resultado:     matriz
Argumento:   X (matriz)

Devolve un vector columna cos valores da diagonal principal de X. Advirte
que se X é unha matriz de orde m x n, o número de elementos do vector
resultante é igual a min(m, n). Mira tamén "tr".

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

Devolve unha matriz coa suma directa de A e B, é dicir, unha matriz que
abrangue a A no recanto superior esquerdo e a B no recanto inferior dereito.
Se A e B son ambas cadradas, a matriz resultante é diagonal por bloques.

# diff
Resultado:     mesmo tipo que o introducido
Argumento:   y (serie, matriz ou lista)

Devolve un resultado (do mesmo tipo que o argumento) coas primeiras
diferenzas. Se y é unha serie ou unha lista de series, os valores iniciais
son NA; se y é unha matriz, a diferenciación faise por columnas e os
valores iniciais son 0.

Cando esta función devolve unha lista, cada unha das variables da mesma
noméase de xeito automático conforme ao padrón d_varname, onde varname
substitúese polo nome da serie orixinal. De ser necesario, o nome vai
tronzarse, e mesmo axustarase no caso de que o conxunto de nomes que se
constrúe así, dea lugar a que algún deles non sexa único.

Mira tamén "cum", "ldiff", "sdiff".

# digamma
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co valor da función digamma (ou
Psi) de x, é dicir, a derivada do logaritmo da función Gamma.

# dnorm
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do mesmo tipo que o argumento) co valor da densidade
da distribución de probabilidade Normal estándar en x. Para obter a
densidade dunha distribución Normal non estándar en x, transforma
tipificando x en z, aplícalle a isto a función dnorm e multiplica o
resultado polo Jacobiano da transformación z, é dicir , 1/sigma, conforme
se ilustra deseguido:

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

Mira tamén "cnorm", "qnorm".

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

Devolve unha lista cos mesmos elementos que X, mais excluíndo as series que
causan multicolinearidade perfecta. En consecuencia, se todas as series que
hai en X son linearmente independentes, a lista que resulta é simplemente
unha copia de X.

O algoritmo usa a descomposición QR (transformación de Householder), polo
que está suxeita a erro de precisión finita. Co obxecto de calibrar a
sensibilidade do algoritmo, podes especificar un segundo parámetro
(opcional) epsilon para facer a proba de multicolinearidade máis ou menos
estrita, segundo desexes. Por defecto, o valor para epsilon é 1.0e-8, pero
axustando epsilon dándolle valores maiores, elévase a probabilidade de que
se descarte unha das series.

O 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
	  # Indica un épsilon cun valor moi pequeno
	  list Y = dropcoll(X, 1.0e-30)
	  list print Y

produce

	  ? 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:     mesmo tipo que o introducido
Argumento:   x (serie ou vector)

Ordena x de forma decrecente, descartando observacións con valores ausentes
cando x é unha serie. Mira tamén "sort", "values".

# dummify
Resultado:     lista
Argumentos:  x (serie)
            omitval (escalar, opcional)

O argumento x debe ser unha serie discreta. Esta función devolve unha lista
cun conxunto de variables ficticias, unha para cada un dos diferentes
valores da serie. Por defecto, o menor valor trátase como a categoría
omitida e non vai representarse explicitamente.

O segundo argumento (opcional) indica o valor de x que debe tratarse como a
categoría omitida. Cando se indica un único argumento, o efecto é
equivalente ao de utilizar a instrución: dummify(x, min(x)). Para producir
un conxunto completo de variables ficticias, é dicir, sen omitir ningunha
categoría, podes usar dummify(x, NA).

As variables que se xeran noméanse automaticamente de acordo co seguinte
padrón: Dvarname_i onde varname indica o nome da serie orixinal e i é un
índice enteiro positivo. De ser necesario, a porción orixinal do nome vai
tronzarse, e mesmo axustarase no caso de que o conxunto de nomes que se
constrúe así, dea lugar a que algún deles non sexa único.

# easterday
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Poñendo un ano como argumento x, devolve un resultado do mesmo tipo ca
este, coa data do domingo de Pascua dese ano no calendario gregoriano, co
formato mes + día/100. Observa que con esta convención, o 10 de abril é
4.1; de aí que 4.2 represente o día 20 de abril e non o 2 de abril (que é
4.02). Exemplo:

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

# ecdf
Resultado:     matriz
Argumento:   y (serie ou vector)

Calcula a función de distribución acumulativa (CDF) empírica de y. O
resultado devólvese nun formato de matriz con dúas columnas: a primeira
contén os valores únicos ordenados de y e a segunda contén a frecuencia
relativa acumulada, é dicir o número de casos nos que o seu valor é menor
ou igual ao valor correspondente da primeira columna, dividido polo número
total de observacións.

# eigengen
Resultado:     matriz
Argumentos:  A (matriz cadrada)
            &U (referencia a matriz, ou null)

Calcula os autovalores e, opcionalmente, os autovectores da matriz A de orde
n x n. Cando todos os autovalores son reais, devólvese unha matriz n x 1.
Noutro caso o resultado é unha matriz n x 2, cunha primeira columna que
contén os elementos reais e unha segunda columna cos elementos imaxinarios.
Non se garante que os autovalores se vaian clasificar en ningunha orde en
particular.

Hai dúas opcións para o segundo argumento: que se trate do nome dunha
matriz xa existente precedida por & (para indicar o "enderezo" da matriz en
cuestión), en cuxo caso nesta matriz gárdase un resultado auxiliar; ou que
se trate da palabra chave null, en cuxo caso non se produce o resultado
auxiliar.

Cando o segundo argumento non é nulo, vaise sobrescribir a matriz
especificada co resultado auxiliar (e non é necesario que a matriz
existente teña a dimensión adecuada para recibir o resultado). O resultado
na matriz U organízase do seguinte xeito:

  Se o i-ésimo autovalor é real, a i-ésima columna de U vai conter o
  autovector correspondente;

  Se o i-ésimo autovalor é complexo, a i-ésima columna de U vai conter a
  parte real do autovector correspondente, e a seguinte columna a parte
  imaxinaria. O autovector do autovalor conxugado é o conxugado do
  autovector.

Noutras palabras, os autovectores gárdanse na mesma orde ca os autovalores;
agora ben, os autovectores reais ocupan unha columna, no entanto os
autovectores complexos ocupan dúas (e a parte real gárdase primeiro).
Aínda así, o número total de columnas é n, pois o autovector conxugado
ignórase.

Mira tamén "eigensym", "eigsolve", "qrdecomp", "svd".

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

Funciona da mesma forma que a función "eigengen", mais o argumento A debe
de ser simétrico (polo que neste caso pódense acurtar os cálculos).
Devolve unha matriz na que, a diferenza do que acontece con "eigengen", os
autovalores sitúanse en orde ascendente.

Aviso: Se o que te interesa é a descomposición espectral dunha matriz da
forma X'X, onde X é unha matriz grande, é preferible calculala a través
do operador X'X en lugar de utilizar a sintaxe máis xeral X'*X. A primeira
expresión utiliza un algoritmo especializado que ten unha dobre vantaxe
pois é máis eficiente dende o punto de vista do cómputo, e garante que o
resultado, por construción, está libre de artefactos de precisión de
máquina que poden convertela en numericamente non simétrica.

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

Resolve o problema do autovalor xeneralizado de tipo |A - lambdaB| = 0, onde
ambas A e B son matrices simétricas e B defínese positiva. Devólvese
directamente unha matriz cos autovalores ordenados de forma ascendente.
Cando utilizas o terceiro argumento (opcional), este debe ser o nome dunha
matriz xa existente, precedida por &. Neste caso os autovectores
xeneralizados escríbense nesta matriz que se indica.

# epochday
Resultado:     escalar ou serie
Argumentos:  year (escalar ou serie)
            month (escalar ou serie)
            day (escalar ou serie)

Devolve un escalar ou unha serie, co número do día na época actual
especificada polo ano, mes e día, nesa orde. O número do día é igual a 1
para o día 1 de xaneiro do ano 1 despois de Cristo, e a 733786 na data
2010-01-01. Se algún dos argumentos é unha serie, o valor que se devolve
tamén terá a forma dunha serie, noutro caso devólvese un escalar.

Por defecto, os valores dos argumentos year, month e day se presupón que se
están indicando de acordo ao calendario Gregoriano, mais se o ano ten un
valor negativo, a interpretación muda á do calendario Xuliano.

Para a inversa desta función consulta "isodate", e tamén "juldate" (para o
calendario Xuliano).

# errmsg
Resultado:     cadea
Argumento:   errno (enteiro)

Devolve unha cadea de texto coa mensaxe de fallo do Gretl asociada ao errno,
que debe ser un número enteiro. Consulta tamén "$error".

# exists
Resultado:     enteiro
Argumento:   name (cadea)

Devolve un escalar non nulo se name é o nome que identifica un obxecto que
xa se definiu, sexa un escalar, unha serie, unha matriz, unha lista, unha
cadea de texto, un feixe ou un arranxo. Noutro caso devolve 0. Consulta
tamén "typeof".

# exp
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do mesmo tipo que o argumento) coa transformación e^x
. Con matrices aplícase elemento a elemento. Para a función exponencial
matricial consulta "mexp".

# fcstats
Resultado:     matriz
Argumentos:  y (serie ou vector)
            f (serie, lista ou matriz)

Xera unha matriz que contén varios estatísticos que serven para avaliar a
f como predición dos datos observados y.

Cando f é unha serie ou un vector, o resultado é un vector columna. Cando
f é unha lista con k elementos ou unha matriz de dimensión T x k, o
resultado ten k columnas nas que cada unha contén os estatísticos do termo
correspondente (serie da lista ou columna da matriz) como predición de y.

En tódolos casos, a dimensión "vertical" dos datos introducidos (o longo
da mostra vixente para unha serie ou unha lista, e o número de filas para
unha matriz) debe de coincidir entre os dous argumentos.

As filas da matriz que se devolve son como se indica deseguido:

	  1  Erro Medio (ME)
	  2  Raíz do Erro Cadrado Medio (RMSE)
	  3  Erro Absoluto Medio (MAE)
	  4  Porcentaxe de Erro Medio (MPE)
	  5  Porcentaxe de Erro Absoluto Medio (MAPE)
	  6  U de Theil
	  7  Proporción do nesgo, UM
	  8  Proporción de regresión, UR
	  9  Proporción de perturbación, UD

Para obter máis detalles sobre o cálculo deses estatísticos e da
interpretación dos valores de U, consulta o Guía de usuario de Gretl
(Capítulo 31).

# fdjac
Resultado:     matriz
Argumentos:  b (vector columna)
            fcall (chamada a función)
            h (escalar, opcional)

Permite calcular unha aproximación numérica ao Jacobiano asociado ao
n-vector b, así como a función de transformación especificada polo
argumento fcall. Ao apelar a esta función debes de utilizar b como o seu
primeiro argumento (ben directamente ou en forma de punteiro), seguido de
calquera argumento adicional que poda necesitarse; e como resultado deberase
producir unha matriz m x 1. Cando se executa con éxito, fdjac vai devolver
unha matriz m x n que contén o Jacobiano.

Podes utilizar o terceiro argumento (opcional) para determinar o tamaño da
medida h que se usa no mecanismo de aproximación (mira máis abaixo). Cando
omites este argumento, o tamaño da medida determínase automaticamente.

Aquí tes un exemplo do seu uso:

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

A función pode utilizar tres métodos distintos: diferenza simple cara
adiante, diferenza bilateral ou extrapolación de 4-nodos de Richardson.
Estas correspóndense respectivamente con:

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

Estas tres alternativas xeralmente proporcionan unha transacción entre
precisión e velocidade. Podes elixir entre os distintos métodos utilizando
a instrución "set" e especificando o valor 0, 1 ou 2 para a variable
fdjac_quality.

Para máis detalles e exemplos, consulta o capítulo sobre métodos
numéricos no Guía de usuario de Gretl (Capítulo 33).

Mira tamén "BFGSmax", "numhess", "set".

# fft
Resultado:     matriz
Argumento:   X (matriz)

Devolve unha matriz coa transformación de Fourier real. Se a matriz X do
argumento ten n columnas, a que se devolve ten 2n columnas, onde as partes
reais gárdanse nas columnas impares e as partes complexas nas columnas
pares.

Cando necesites aplicar a transformación de Fourier sobre varios vectores
co mesmo número de elementos, resulta numericamente máis eficiente agrupar
os vectores nunha matriz ca executar fft para cada un por separado. Mira
tamén "ffti".

# ffti
Resultado:     matriz
Argumento:   X (matriz)

Devolve unha matriz con n columnas co resultado da transformación inversa
discreta real de Fourier. Asúmese que a matriz X consta de n vectores
columna complexos, coa parte real nas columnas impares e a parte imaxinaria
nas columnas pares, de forma que deberá ter 2n columnas.

Cando necesites aplicar a transformación inversa de Fourier sobre varios
vectores co mesmo número de elementos, resulta numericamente máis
eficiente agrupar os vectores nunha matriz ca executar ffti para cada un por
separado. Mira tamén "fft".

# filter
Resultado:     Mira máis abaixo
Argumentos:  x (serie ou matriz)
            a (escalar ou vector, opcional)
            b (escalar ou vector, opcional)
            y0 (escalar, opcional)

Devolve o resultado de aplicar un filtro semellante a un ARMA ao argumento
x. A transformación pode escribirse 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 é unha serie, o resultado que se devolve tamén é unha
serie. Noutro caso se x é unha matriz con T filas e k columnas, o que se
devolve é a matriz do mesmo tamaño que resulta de aplicar o filtro columna
por columna.

Os argumentos a e b son opcionais. Poden ser escalares, vectores ou a
palabra chave null.

Cando a é un escalar, vaise utilizar como a_0 e implicará que q=0. Cando
é un vector con q+1 elementos, vai conter os coeficientes de a_0 ata a_q.
Cando a é null ou se omite, isto é equivalente a definir a_0 =1 e q=0.

Cando b é un escalar, vaise utilizar como b_1 e implicará que p=1. Cando
é un vector con p elementos, vai conter os coeficientes de b_1 ata b_p.
Cando b é null ou se omite, isto é equivalente a definir B(L)=1.

O argumento escalar opcional y0 utilízase para representar todos os valores
de y anteriores ao comezo da mostra (úsase só cando p>0). Cando se omite,
enténdese que é igual a 0. Asúmese que os valores de x anteriores ao
comezo da mostra son sempre 0.

Mira tamén "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

produce

          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:     enteiro
Argumento:   y (serie)

Devolve o número enteiro positivo que indexa a primeira observación non
ausente da serie y. Ten en conta que se está activa algunha forma de
submostraxe, o valor que se devolve pode ser menor ca o valor devolto polo
accesorio "$t1". Mira tamén "lastobs".

# fixname
Resultado:     cadea
Argumento:   rawname (cadea)

Esta función está ideada para utilizarse en conxunto coa instrución
"join". Devolve unha cadea co resultado da conversión de rawname nun
identificador válido de Gretl; debe iniciarse cunha letra, debe conter só
letras ASCII, díxitos e/ou trazo baixo, e non debe ter máis ca 31
caracteres. As regras que se utilizan na conversión son:

1. Quitar do inicio do nome, calquera carácter que non sexa unha letra.

2. Ata que se acada o límite dos 31 caracteres ou ata que se esgota o
indicado no argumento: transcribe os caracteres "legais", substitúe un ou
varios espazos consecutivos por un trazo baixo (agás que o carácter
anterior transcrito sexa un trazo baixo, pois entón elimínase o espazo) e
omite os outros tipos de caracteres "ilegais".

# floor
Resultado:     mesmo tipo que o introducido
Argumento:   y (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co valor do maior enteiro que é
menor ou igual que x. Cae na conta de que "int" e floor teñen efectos
distintos con argumentos negativos:int(-3.5) xera -3, namentres floor(-3.5)
xera -4.

# fracdiff
Resultado:     serie
Argumentos:  y (serie)
            d (escalar)

Devolve unha serie coa diferenza fraccionaria de orde d da a serie y.

Observa que, en teoría, a diferenciación fraccionaria supón un filtro
infinitamente longo. Pero os valores de y_t anteriores á mostra, na
práctica asúmese que son iguais a cero.

Podes utilizar valores negativos para d, e nese caso a función realiza a
integración fraccionaria.

# gammafun
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co valor da función Gamma de x.

# genseries
Resultado:     escalar
Argumentos:  varname (cadea)
            rhs (serie)

Proporciónalle ao guionista un procedemento adecuado de xerar series cuxos
nomes non se coñecen a priori, e/ou de crear series e engadilas a unha
lista por medio dunha única operación (devolve un escalar).

O primeiro argumento proporciona o nome da serie que se vai crear (ou
modificar); e pode ser un texto literal, unha cadea de texto ou unha
expresión cuxo resultado sexa unha cadea de texto. O segundo argumento, rhs
("lado dereito" en inglés), define a serie orixinal: isto pode ser o nome
dunha serie existente ou unha expresión cuxo resultado sexa unha serie, no
xeito no que aparece habitualmente do lado dereito do símbolo de igualdade
cando se definen series.

O valor que devolve esta función é un escalar co número ID da serie no
conxunto de datos, que é axeitado para incluír a serie nunha lista (ou -1
no caso de fallar a execución da función).

Por exemplo, supón que queres engadir n series aleatorias con distribución
de probabilidade Normal ao conxunto de datos e colocalas nunha lista. O
seguinte código fai iso:

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

Ao rematar a execución, a lista Normals vai conter as series norm1, norm2 e
así sucesivamente.

# getenv
Resultado:     cadea
Argumento:   s (cadea)

Cando xa está definida unha variable de entorno co nome do argumento s, a
función devolve o valor desa variable como cadea de texto; noutro caso
devolve unha cadea de texto baleira. Consulta tamén "ngetenv".

# getinfo
Resultado:     paquete
Argumento:   y (serie)

Devolve información sobre a serie especificada, a que podes indicar
mediante o seu nome ou o seu número ID. O paquete que se devolve contén
tódolos atributos que se poden establecer por medio da instrución
"setinfo". E tamén contén información adicional relevante para series que
se xeraron como transformacións de datos primarios (mediante retardos,
logaritmos, etc.); isto inclúe a palabra da instrución de Gretl para a
transformación coa clave "transform" e o nome da serie asociada primaria
coa clave "parent". Para as series retardadas, podes atopar o número
específico de retardos baixo a clave "lag".

Aquí tes un exemplo do seu uso:

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

Ao executar o anterior, podemos ver:

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

Para probar se a serie 5 dun conxunto de datos é un termo retardado, podes
facer este tipo de cousas:

	  if getinfo(5).lag != 0
	     printf "A serie 5 é un retardo de %s\n", getinfo(5).parent
	  endif

Ten en conta que podes utilizar a notación co punto para acceder aos
elementos dun paquete, mesmo cando o paquete é "anónimo" (non gardado co
seu propio nome).

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

Esta función le filas consecutivas de source, que debe de ser unha cadea de
texto xa definida. Con cada chamada á función escríbese unha liña de
texto en target (que tamén debe de ser unha cadea de texto) sen o carácter
de nova liña. O valor que se devolve é un escalar igual a 1, cando existe
algo por ler (incluídas filas en branco), ou igual a 0 se todas as filas de
source xa se leron.

A continuación preséntase un exemplo onde o contido dun ficheiro de texto
divídese en filas:

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

No exemplo pódese asegurar que, cando remate o bucle, o texto de source
está esgotado. Se non desexas esgotalo todo, podes facer unha chamada
normal a getline, seguida dunha nova chamada de "limpeza", trocando o
argumento target por null (ou deixalo en branco), co que se reinicia a
lectura de source, como en

	  getline(s, line) # Obtén unha única fila
	  getline(s, null) # Reinicia a lectura

Ten en conta que, aínda que avanza a posición de lectura cada vez que se
executa getline, o argumento source non se altera por esa función; só
cambia target.

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

Calcula a aproximación GHK (Geweke, Hajivassiliou, Keane) á función de
distribución normal multivariante; podes consultar, por exemplo, Geweke
(1991). O valor que se devolve é un vector n x 1 de probabilidades.

O argumento matricial C (m x m) debe de achegar o factor de Cholesky (matriz
triangular inferior) da matriz de covarianzas de m variables normais. Os
argumentos matriciais A e B deben de ser ambos n x m, e indicar
respectivamente os límites inferior e superior que se aplican ás variables
en cada unha das n observacións. Onde as variables non teñan límites, iso
débese indicar usando a constante "$huge" ou o seu negativo.

A matriz U debe de ser m x r, onde r indica o número de extraccións
pseudoaleatorias dunha distribución uniforme. Para crear U son adecuadas as
funcións "muniform" e "halton".

Debaixo ilústrase isto cun exemplo relativamente simple, onde as
probabilidades multivariantes poden calcularse analiticamente. As series P e
Q deben de ser numericamente moi semellantes unha á outra, denotando como P
á probabilidade "verdadeira" e como Q á súa aproximación 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 úsase para obter a matriz n x k de derivadas das
probabilidades, onde k equivale a 2m + m(m + 1)/2. As primeiras m columnas
van conter as derivadas con respecto a os límites inferiores, as seguintes
m van recoller as derivadas con respecto a os límites superiores, e as
restantes columnas van recoller as derivadas con respecto a os elementos
singulares da matriz C na orde que sigue a semivectorización "vech" dunha
matriz simétrica.

# gini
Resultado:     escalar
Argumento:   y (serie ou vector)

Devolve un escalar co índice de desigualdade de Gini para a serie ou vector
(non negativos) y. Un valor de Gini igual a cero indica igualdade perfecta.
O máximo valor de Gini para unha serie con n elementos é (n - 1)/n, o que
acontece cando unicamente un elemento ten un valor positivo; polo tanto, un
valor de Gini igual a 1.0 é o límite que se acada cando unha serie moi
longa ten máxima desigualdade.

# ginv
Resultado:     matriz
Argumento:   A (matriz)

Devolve a matriz A^+, a matriz pseudoinversa de Moore-Penrose ou inversa
xeneralizada de A, calculada por medio da descomposición en valores
singulares.

Esta matriz posúe as seguintes propiedades: A A^+ A = A e A^+ A A^+ = A^+.
Ademais diso, os produtos A A^+ e A^+ A son simétricos por construción.

Mira tamén "inv", "svd".

# GSSmax
Resultado:     escalar
Argumentos:  &b (referencia a matriz)
            f (chamada a función)
            toler (escalar, opcional)

Maximización unidimensional mediante o método Golden Section Search (GSS).
A matriz bdo argumento debe de ser un vector de 3 elementos. Ao definila, o
primeiro elemento ignórase mentres que o segundo e terceiro elementos
establecen os límites inferior e superior da procura. O argumento fncall
deberá de especificar unha chamada á función que devolve o valor do
concepto a maximizar; o termo 1 de b (que deberá conter o valor vixente do
parámetro que se axusta cando se invoca a función) debe de indicarse como
primeiro argumento; calquera outro argumento requirido pode ir entón a
continuación. A función en cuestión deberá de ser unimodal (non debe de
ter outro máximo local que non sexa o máximo global) no rango estipulado,
pois do contrario non se asegura que GSS atope o máximo.

Ao completarse con éxito, GSSmax devolverá o valor óptimo do concepto que
se quere maximizar, mentres que b conterá o valor óptimo do parámetro
xunto cos límites da súa fiestra de valores.

O terceiro argumento (opcional) pode utilizarse para establecer a tolerancia
para acadar a converxencia; é dicir, a amplitude máxima admisible da
fiestra final de valores do parámetro. Se non indicas este argumento,
utilízase o valor 0.0001.

Se o teu obxectivo realmente é acada un mínimo, podes ben trocar a
función considerando o negativo do criterio, ou ben, alternativamente,
podes invocar a función GSSmaxbaixo o alcume GSSmin.

Aquí tes un exemplo sinxelo de utilización:

	  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

Un alcume de "GSSmax". Se invocas a función baixo este nome, execútase
facendo unha minimización.

# halton
Resultado:     matriz
Argumentos:  m (enteiro)
            r (enteiro)
            offset (enteiro, opcional)

Devolve unha matriz m x r que contén m secuencias de Halton de lonxitude r,
onde o valor de m está limitado a un máximo de 40. As secuencias
constrúense utilizando os primeiros m números primos. Por defecto
descártanse os primeiros 10 elementos de cada unha das secuencias, aínda
que iso pode axustarse por medio do argumento opcional offset, que debe de
ser un número enteiro non negativo. Para obter máis detalles podes
consultar Halton e Smith (1964).

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

Devolve a matriz que resulta do produto directo horizontal de dúas
matrices. Os dous argumentos deben de ter o mesmo número de filas, r. O
valor que se devolve é unha matriz que ten r filas, e na que a i-ésima
fila é o produto de Kronecker das respectivas filas das matrices X e Y.

Esta operación chámase "produto directo horizontal" en conformidade coa
forma en que se pon en funcionamento e aplica na linguaxe de programación
GAUSS. A súa equivalente na álxebra matricial estándar podería
denominarse produto horizontal (row-wise) de Khatri-Rao.

Exemplo: o código...

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

produce a seguinte matriz:

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

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

Dada unha "MIDAS list", a función devolve outra lista da mesma lonxitude
que contén as primeiras diferenzas de alta frecuencia. O segundo argumento
é opcional e, por defecto, igual a 1: podes utilizalo para multiplicar as
diferenzas por algunha constante.

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

Dada unha "MIDAS list", a función devolve outra lista da mesma lonxitude
que contén as diferenzas logarítmicas de alta frecuencia. O segundo
argumento é opcional e, por defecto, igual a 1: pode utilizarse para
multiplicar as diferenzas por algunha constante; por exemplo poderías
darlle o valor 100 para obter aproximadamente as variacións porcentuais.

# hflags
Resultado:     lista
Argumentos:  minlag (enteiro)
            maxlag (enteiro)
            hfvars (lista)

Dada unha "MIDAS list" hfvars, a función devolve outra lista cos retardos
de alta frecuencia desde minlag ata maxlag. Debes utilizar valores positivos
para indicar os retardos e negativos para indicar os adiantos. Por exemplo,
se minlag é -3, e maxlag é 5, entón a lista que se vai devolver conterá
9 series: 3 adiantos, o valor actual e 5 retardos.

Cae na conta de que o retardo 0 de alta frecuencia correspóndese co
primeiro período de alta frecuencia, dentro dun período de baixa
frecuencia; por exemplo, correspondería co primeiro mes dentro dun
trimestre ou co primeiro día dentro dun mes.

# hflist
Resultado:     lista
Argumentos:  x (vector)
            m (enteiro)
            prefix (cadea)

Produce unha "MIDAS list" de m series a partir do vector x, onde m indica a
razón entre a frecuencia (maior) das observacións da variable x e a
frecuencia base (menor) do conxunto de datos actual. O valor de m debe de
ser maior ou igual a 3, e o tamaño de x debe de ser igual a m veces o
tamaño do rango da mostra actual.

Os nomes das series da lista que se devolve, constrúense a partir do prefix
indicado (que debe de ser unha cadea de texto, dunha lonxitude máxima de 24
caracteres ASCII e válida como identificador de Gretl), á que se engade un
ou máis díxitos que representan o subperíodo da observación. Se algún
deses nomes duplica o de algún obxecto xa existente, amósase un fallo.

# hpfilt
Resultado:     serie
Argumentos:  y (serie)
            lambda (escalar, opcional)

Devolve unha serie que recolle a compoñente cíclica do filtro de
Hodrick-Prescott aplicado á serie y. Se non se indica o parámetro de
suavizado lambda, o Gretl usa valores por defecto baseados na periodicidade
dos datos; concretamente, o parámetro é igual a 100 veces o cadrado da
periodicidade (100 para datos anuais, 1600 para datos trimestrais, etc.).
Mira tamén "bkfilt", "bwfilt".

# I
Resultado:     matriz cadrada
Argumento:   n (enteiro)

Devolve unha matriz identidade con n filas e columnas.

# imaxc
Resultado:     vector fila
Argumento:   X (matriz)

Devolve un vector fila que indica, para cada columna da matriz X, cal é a
fila que ten o valor máis grande.

Mira tamén "imaxr", "iminc", "maxc".

# imaxr
Resultado:     vector columna
Argumento:   X (matriz)

Devolve un vector columna que indica, para cada fila da matriz X, cal é a
columna que ten o valor máis grande.

Mira tamén "imaxc", "iminr", "maxr".

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

Calcula a Prob(u'Au < x) para unha forma cuadrática de variables Normais
estándar, u, usando o procedemento desenvolvido por Imhof (1961).

Se o primeiro argumento M é unha matriz cadrada, tómase para que
represente a A. Se é un vector columna, tómanse os seus elementos como se
fosen os autovalores calculados previamente de A, e noutro caso preséntase
un fallo.

Mira tamén "pvalue".

# iminc
Resultado:     vector fila
Argumento:   X (matriz)

Devolve un vector fila que indica, para cada columna da matriz X, cal é a
fila que ten o valor máis pequeno.

Mira tamén "iminr", "imaxc", "minc".

# iminr
Resultado:     vector columna
Argumento:   X (matriz)

Devolve un vector columna que indica, para cada fila da matriz X, cal é a
columna que ten o valor máis pequeno.

Mira tamén "iminc", "imaxr", "minr".

# inbundle
Resultado:     enteiro
Argumentos:  b (paquete)
            key (cadea)

Comproba se o feixe ("bundle") b contén un elemento co nome key. Devolve un
enteiro co código do tipo de elemento: 0 no caso de non achalo e, no caso
de atopalo, 1 para un escalar, 2 para unha serie, 3 para unha matriz, 4 para
unha cadea de texto, 5 para un feixe e 6 para un arranxo. En base ao valor
do seu código, a función "typestr" pódese usar para obter a cadea de
texto que expresa o tipo de elemento que é.

# infnorm
Resultado:     escalar
Argumento:   X (matriz)

Devolve un escalar coa norma-infinito da matriz X, é dicir, o máximo valor
que se obtén ao sumar os valores absolutos dos elementos da matriz X que
hai en cada fila.

Mira tamén "onenorm".

# inlist
Resultado:     enteiro
Argumentos:  L (lista)
            y (serie)

Devolve un enteiro positivo coa posición de y na lista L, ou 0 se y non
está presente en L.

O segundo argumento podes indicalo tanto co nome da serie como co enteiro
positivo que identifica a serie (ID). Cando se sabe que existe unha serie
cun nome concreto (por exemplo, foo), podes executar esta función da
seguinte forma:

	  pos = inlist(L, foo)

Coa expresión anterior estás pedindo: "Indícame cun enteiro a posición
da serie foo na lista L (ou 0 se non está incluída nesa lista)". De
calquera xeito, se non tes certeza de que exista unha serie cun nome
concreto, debes indicar ese nome entre comiñas desta forma:

	  pos = inlist(L, "foo")

Neste caso o que estás solicitando é: "Se existe unha serie chamada foo na
lista L, indícame a súa posición ou 0 no caso de que non exista."

# int
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) coa parte enteira de x,
tronzando a parte decimal. Ten en conta que int e "floor" producen distintos
efectos con argumentos negativos: int(-3.5) xera -3, namentres floor(-3.5)
xera -4. Mira tamén "ceil".

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

Devolve a matriz inversa de A. Cando esta última é unha matriz singular ou
non cadrada, prodúcese unha mensaxe de fallo e non se devolve nada. Cae na
conta de que o Gretl comproba automaticamente a estrutura de A e utiliza o
procedemento numérico máis eficiente para realizar a inversión.

Os tipos de matriz que o Gretl comproba automaticamente son: identidade,
diagonal, simétrica definida positiva, simétrica definida non positiva, e
triangular.

Nota: En boa lóxica, só debes utilizar esta función cando tratas de
aplicar a inversa de A máis dunha vez. Cando unicamente necesitas calcular,
por exemplo, unha expresión da forma A^-1B, é preferible que utilices os
operadores de "división": \ e /. Para obter máis detalles, podes consultar
o Guía de usuario de Gretl (Capítulo 15).

Mira tamén "ginv", "invpd".

# invcdf
Resultado:     mesmo tipo que o introducido
Argumentos:  d (cadea)
            ... (Mira máis abaixo)
            p (escalar, serie ou matriz)

Calcula a inversa da función de distribución acumulativa e devolve un
resultado (do tipo do argumento) co valor de x que cumpre P(X <= x) = p,
onde o tipo de distribución de X se especifica por medio da letra d. Entre
os argumentos d e p, podes necesitar algún argumento adicional escalar para
especificar os parámetros da distribución de que se trate. Isto faise da
forma que se indica a continuación:

  Normal estándar (c = z, n ou N): sen argumentos extras

  Gamma (g ou G): forma, escala

  t de Student (t): graos de liberdade

  Khi-cadrado (c, x ou X): graos de liberdade

  F de Snedecor (f ou F): graos de liberdade (num.), graos de liberdade
  (den.)

  Binomial (b ou B): probabilidade, cantidade de ensaios

  Poisson (p ou P): media

  Erro Xeneralizado (E): forma

  Khi-cadrado non central (ncX): graos de liberdade, parámetro de non
  centralidade

  F non central (ncF): graos de liberdade (num.), graos de liberdade (den.),
  parámetro de non centralidade

  t non central (nct): graos de liberdade, parámetro de non centralidade

Mira tamén "cdf", "critical", "pvalue".

# invmills
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) coa razón inversa de Mills en
x, é dicir, a razón entre a densidade Normal estándar e o complementario
da función de distribución Normal estándar, ambas avaliadas en x.

Esta función utiliza un algoritmo axeitado que proporciona unha precisión
moito mellor que a que se acada facendo os cálculos con "dnorm" e "cnorm",
agora ben, a diferenza entre os dous métodos é considerable só para
valores moi negativos de x.

Mira tamén "cdf", "cnorm", "dnorm".

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

Devolve a matriz cadrada resultante de inverter a matriz simétrica definida
positiva A. Esta función é lixeiramente máis rápida ca "inv" para
matrices moi grandes, posto que con ela non se comproba se a matriz é
simétrica. Por esta razón, esa función debe de utilizarse con prudencia.

Nota: Se pretendes inverter unha matriz da forma X'X onde X é unha matriz
moi grande, é preferible que a calcules por medio do operador principal X'X
en lugar de usar a sintaxe máis xeral X'*X. A primeira expresión utiliza
un algoritmo especializado que ten unha dobre vantaxe: resulta máis
eficiente desde o punto de vista do cómputo, e vai garantir que a matriz
resultante estea libre, por construción, dos artefactos de precisión de
máquina que puideran convertela en numericamente non simétrica.

# irf
Resultado:     matriz
Argumentos:  target (enteiro)
            shock (enteiro)
            alpha (escalar entre 0 e 1, opcional)

Esta función só está dispoñible cando o último modelo estimado foi un
VAR ou un VECM. Como resultado, devolve unha matriz que contén a resposta
estimada da variable target ante un impulso na variable shock de magnitude
igual a unha vez a súa desviación padrón. Estas dúas variables
identifícanse tendo en conta as súas posicións na especificación do
modelo: por exemplo, cando indicas os argumentos target e shock cos valores
1 e 3, respectivamente, a matriz que se devolve proporciona a resposta da
primeira variable do sistema ante un impulso da terceira variable.

Se indicas o terceiro argumento alpha (opcional), a matriz que te devolve a
función ten tres columnas: a primeira coa estimación por punto das
respostas, e as outras cos límites inferior e superior do intervalo con
confianza (1 - α) para as mesmas, obtidas mediante autosuficiencia
("bootstrapping"). Se alpha = 0.1, a confianza será do 90 por cento. Cando
alpha se omite ou se iguala a cero, tan só se proporciona a estimación por
punto.

O número de períodos (filas) sobre os que se traza a resposta se determina
automaticamente dependendo da frecuencia dos datos; mais iso pode axustarse
por medio da instrución "set", como por exemplo con set horizon 10.

# irr
Resultado:     escalar
Argumento:   x (serie ou vector)

Devolve un escalar coa Taxa Interna de Rendemento (TIR) para x, considerada
como unha secuencia de pagos (negativos) e ingresos (positivo). Mira tamén
"npv".

# isconst
Resultado:     enteiro
Argumentos:  y (serie ou vector)
            panel-code (enteiro, opcional)

Sen o segundo argumento (opcional), devolve o número enteiro igual a 1
cando y teña un valor constante ao longo da mostra actual seleccionada (ou
ao longo de toda a súa extensión se y é un vector); noutro caso, devolve
o enteiro 0.

O segundo argumento só se acepta cando y é unha serie, e o conxunto de
datos actual é un panel. Neste caso, un valor de panel-code igual a 0
solicita que a función verifique se a serie non varía co paso do tempo; e
un valor igual a 1 fai que a función verifique se a serie non varía
transversalmente (é dicir, se o valor de y en cada período de tempo, é o
mesmo para todos os grupos).

Se y é unha serie, as observacións con valores ausentes ignóranse durante
a verificación da invariabilidade da serie.

# isdiscrete
Resultado:     enteiro
Argumento:   name (cadea)

Se name é unha cadea que identifica unha serie xa definida, e se está
marcada como de tipo discreto, a función devolve un enteiro igual a1;
noutro caso devolve 0. Se name non identifica unha serie, a función devolve
NA.

# isdummy
Resultado:     enteiro
Argumento:   x (serie ou vector)

Se todos os valores contidos en x son iguais a 0 ou 1 (ou ausentes), devolve
un enteiro co número de uns; senón devolve 0.

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

Dado un argumento escalar, devolve 1 se x non é un número, "Not a Number"
(NaN); noutro caso devolve 0. Dada unha matriz como argumento, devolve outra
matriz da mesma dimensión que contén valores iguais a 1 nas posicións
onde os elementos que lles corresponden da matriz de entrada son NaN, e 0
nas demais posicións.

# isoconv
Resultado:     escalar
Argumentos:  date (serie)
            &year (referencia a serie)
            &month (referencia a serie)
            &day (referencia a serie, opcional)

Dada a serie date que contén datas no formato ISO 8601 "básico"
(YYYYMMDD), esta función converte as compoñentes de ano, mes e
(opcionalmente) día en novas series designadas polo segundo e seguintes
argumentos. Un exemplo da súa aplicación, asumindo que a serie dates
contén valores axeitados de 8 díxitos, sería:

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

Esta función devolve o escalar 0 no caso de completarse con éxito, e un
escalar non nulo en caso de fallo.

# isodate
Resultado:     Mira máis abaixo
Argumentos:  ed (escalar ou serie)
            as-string (booleano, opcional)

O argumento ed interprétase como un día de época (que tomará o valor 1
para o primeiro día de xaneiro do ano 1 despois de Cristo no proléptico
calendario Gregoriano). O valor que se devolve por defecto é un número de
8 díxitos do mesmo tipo ca ed, ou unha serie composta por números desa
clase. Séguese o padrón YYYYMMDD (formato ISO 8601 "básico") para
proporcionar a data no calendario Gregoriano que se corresponde ao dia na
época actual.

Cando ed é unicamente un escalar e o segundo argumento as-string (opcional)
é non nulo, a función non devolve un valor numérico senón unha cadea de
texto que segue o padrón YYYY-MM-DD (formato ISO 8601 "estendido").

Con relación á función inversa consulta "epochday". Consulta tamén
"juldate".

# iwishart
Resultado:     matriz
Argumentos:  S (matriz simétrica)
            v (enteiro)

Dada S (unha matriz de orde p x p definida positiva), esta función devolve
unha matriz xerada a partir dunha realización da distribución Inversa de
Wishart con v graos de liberdade. O resultado que se devolve tamén é unha
matriz p x p. Utilízase o algoritmo de Odell e Feiveson (1966).

# jsonget
Resultado:     cadea
Argumentos:  buf (cadea)
            path (cadea)

Como argumento buf deberás utilizar un "buffer" JSON, tal como pode
recuperarse dun sitio web adecuado por medio da función "curl"; e como
argumento path deberás usar unha especificación de tipo JsonPath.

Esta función devolve unha cadea de texto que representa os datos que se
atopan no "buffer" na ruta especificada. Se admiten os tipos de datos
"double" (punto flotante), "int" (enteiro) e cadea de texto. No caso de
enteiros ou de puntos flotantes, devólvese a súa representación como
cadeas de texto (usando "C" local para os segundos). Se o obxecto ao que se
refire a ruta (path) é un arranxo, os seus elementos imprímense un por
cada fila na cadea de texto devolta.

Podes atopar unha exposición fidedigna da sintaxe JsonPath en
http://goessner.net/articles/JsonPath/. De calquera xeito, observa que o
sostemento de jsonget o fornece json-glib, que non necesariamente soporta
tódolos elementos de JsonPath. E ademais, a funcionalidade concreta que
desenvolve json-glib pode ser moi diferente, dependendo da versión que
teñas no teu sistema. Podes consultar http://developer.gnome.org/json-glib/
se necesitas ter máis detalles.

Dito isto, os seguintes operadores deberan de estar dispoñibles para
jsonget:

  nodo raíz, por medio do carácter $

  operador descendente recursivo: ..

  operador comodín: *

  operador subíndice: []

  operador de notación de conxunto, por exemplo [i,j]

  operador de tronzado: [inicio:fin:paso]

# juldate
Resultado:     Mira máis abaixo
Argumentos:  ed (escalar ou serie)
            as-string (booleano, opcional)

O argumento ed interprétase como un día de época (que tomará o valor 1
para o primeiro día de xaneiro do ano 1 despois de Cristo no proléptico
calendario Gregoriano). O valor que se devolve por defecto é un número de
8 díxitos do mesmo tipo ca ed, ou unha serie composta por números desa
clase. Séguese o padrón YYYYMMDD (formato ISO 8601 "básico") para
proporcionar a data no calendario Xuliano que se corresponde ao dia na
época actual.

Cando ed é unicamente un escalar e o segundo argumento as-string (opcional)
é non nulo, a función non devolve un valor numérico senón unha cadea de
texto que segue o padrón YYYY-MM-DD (formato ISO 8601 "estendido").

Consulta tamén "isodate".

# kdensity
Resultado:     matriz
Argumentos:  x (serie ou vector)
            scale (escalar, opcional)
            control (booleano, opcional)

Calcula unha estimación da densidade kernel da serie ou vector x. A matriz
que se devolve ten dúas columnas, a primeira inclúe un conxunto de
abscisas equidistantes e a segunda a densidade estimada correspondente a
cada unha delas.

O parámetro scale (opcional) podes usalo para axustar o grao de suavizado
en relación ao valor por defecto que é 1.0 (valores maiores producen un
resultado máis suave). O parámetro control (opcional) actúa como un
booleano: 0 (valor por defecto) significa que se utiliza o kernel gaussiano;
un valor non nulo troca ao kernel de Epanechnikov.

Podes obter un gráfico dos resultados utilizando a instrución "gnuplot",
como en

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

# kdsmooth
Resultado:     escalar
Argumentos:  &Mod (referencia a paquete)
            MSE (booleano, opcional)

Realiza o suavizado das perturbacións dun feixe de Kalman, configurado
previamente mediante a instrución "ksetup", e devolve o escalar 0 cando se
completa con éxito, ou o escalar 1 cando se atopan problemas numéricos.

Cando se completa con éxito a operación, as perturbacións suavizadas van
estar dispoñibles como Mod.smdist.

O argumento MSE (opcional) determina o contido da chave Mod.smdisterr. Cando
é 0 ou se omite, esta matriz vai estar composta das desviacións padrón
incondicionais das perturbacións suavizadas, que habitualmente se utilizan
para calcular os denominados erros auxiliares. Mais no caso contrario,
Mod.smdisterr vai conter as raíces das desviacións cadradas medias entre
os erros auxiliares e os seus valores verdadeiros.

Para obter máis detalles, consulta o Guía de usuario de Gretl (Capítulo
32).

Mira tamén "ksetup", "kfilter", "ksmooth", "ksimul".

# kfilter
Resultado:     escalar
Argumento:   &Mod (referencia a paquete)

Realiza o filtrado cara adiante dun feixe de Kalman configurado previamente
mediante a instrución "ksetup", e devolve o escalar 0 cando se completa con
éxito, ou o escalar 1 cando se atopan problemas numéricos.

Cando se completa con éxito, os erros de predición dun paso adiante van
estar dispoñibles como Mod.prederr e a secuencia das súas matrices de
covarianzas como Mod.pevar. Por outra banda, Mod.llt permitirá que teñas
acceso a un T-vector que vai conter o logaritmo da verosimilitude de cada
observación.

Para obter máis detalles, consulta o Guía de usuario de Gretl (Capítulo
32).

Mira tamén "kdsmooth", "ksetup", "ksmooth", "ksimul".

# kmeier
Resultado:     matriz
Argumentos:  d (serie ou vector)
            cens (serie ou vector, opcional)

Devolve unha matriz co cálculo do estimador non paramétrico de
Kaplan-Meier da función de supervivencia (Kaplan e Meier, 1958), dada unha
mostra d de datos de duración, posiblemente acompañada dun rexistro de
estado de censura, cens. A matriz que se devolve ten tres columnas que
conteñen, respectivamente: os valores únicos ordenados en d, a estimación
da función de supervivencia que se corresponde cos valores de duración da
columna 1, e a desviación padrón (para mostras grandes) do estimador,
calculados por medio do método de Greenwood (1926).

Cando indicas a serie cens, utilízase o valor 0 para sinalar que unha
observación non está censurada, namentres que o valor 1 indica que unha
observación está censurada do lado dereito (é dicir, o período de
observación do individuo en cuestión concluíu antes da duración ou o
período rexistrouse como rematado). Cando non indicas cens, asúmese que
todas as observacións son non censuradas. (Aviso: a semántica de cens pode
estenderse nalgún punto para cubrir outros tipos de censura.)

Mira tamén "naalen".

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

Devolve un vector fila que contén os valores críticos aos niveis de 10, 5
e 1 por cento da proba KPSS para a estacionariedade dunha serie temporal. O
argumento T debe indicar o número de observacións e o argumento trend debe
de ser igual a 1 se a proba inclúe unha constante, ou 0 noutro caso.

Os valores críticos que se ofrecen están baseados en superficies de
resposta estimadas do xeito que está establecido por Sephton (Economics
Letters,1995). Consulta tamén a instrución "kps".

# ksetup
Resultado:     paquete
Argumentos:  Y (serie, matriz ou lista)
            H (escalar ou matriz)
            F (escalar ou matriz)
            Q (escalar ou matriz)
            C (matriz, opcional)

Configura un feixe de Kalman, é dicir un obxecto que contén toda a
información necesaria para definir un modelo de espazo dos estados linear,
da forma

  y(t) = H'a(t)

e coa ecuación de transición de estado

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

onde Var(u) = Q.

Os obxectos que creas mediante esta función podes utilizalos máis adiante,
coa intervención das seguintes funcións específicas: "kfilter" para facer
filtrado, "ksmooth" e "kdsmooth" para suavizado e "ksimul" para facer
simulacións.

En realidade, o tipo de modelos que Gretl pode manexar é moito máis amplo
ca o implicado na anterior representación: é posible dispoñer de modelos
variantes no tempo, de modelos con precedentes difusos e con variable
esóxena na ecuación de medida, e de modelos con innovacións con
correlacións cruzadas. Para obter máis detalles, consulta o Guía de
usuario de Gretl (Capítulo 32).

Mira tamén "kdsmooth", "kfilter", "ksmooth", "ksimul".

# ksimul
Resultado:     escalar
Argumento:   &Mod (referencia a paquete)

Devolve un escalar. Utiliza un feixe de tipo Kalman previamente definido coa
a función "ksetup" para simular datos.

Para obter máis detalles, consulta o Guía de usuario de Gretl (Capítulo
32).

Mira tamén "ksetup", "kfilter", "ksmooth".

# ksmooth
Resultado:     matriz
Argumento:   &Mod (referencia a paquete)

Realiza un suavizado de punto fixo (cara atrás) dun feixe de Kalman
previamente configurado mediante "ksetup" e devolve un 0 cando se executa
con éxito, ou un 1 cando se atopan problemas de tipo numérico.

Cando se completa con éxito, vas ter á túa disposición o estado xa
suavizado como Mod.state e a secuencia das súas matrices de
varianzas-covarianzas como Mod.stvar. Para obter máis detalles, consulta o
Guía de usuario de Gretl (Capítulo 32).

Mira tamén "ksetup", "kdsmooth", "kfilter", "ksimul".

# kurtosis
Resultado:     escalar
Argumento:   x (serie)

Devolve o exceso de curtose da serie x, descartando calquera observación
ausente.

# lags
Resultado:     lista ou matriz
Argumentos:  p (escalar ou vector)
            y (serie, lista ou matriz)
            bylag (booleano, opcional)

Cando o primeiro argumento é un escalar, xera os retardos do 1 ao p da
serie y ou. Cando y é unha lista, xera eses retardos para todas as series
que contén esa lista. Cando y é unha matriz, xera eses retardos para todas
as columnas da matriz. No caso de que p = 0, e y sexa unha serie ou unha
lista, o retardo máximo toma por defecto a periodicidade dos datos; aparte
diso p deberá de ser positivo.

Cando o primeiro argumento é un vector, os retardos xerados son os que
están especificados nese vector. Un uso habitual neste caso podería ser o
de poñer, por exemplo, p como seq(3,7); daquela omitindo o primeiro e
segundo retardos. Así e todo, tamén é correcto indicar un vector con
saltos como en {3,5,7}, aínda que os retardos deberán indicarse sempre en
orde ascendente.

No caso de que o resultado sexa unha lista, noménase automaticamente as
variables xeradas co padrón varname_i onde varname estará indicando o nome
da serie orixinal e i expresará o retardo concreto de cada caso. A parte
orixinal do nome vaise tronzar cando así resulte necesario, e mesmo poderá
axustarse oportunamente para garantir que resulte único dentro do conxunto
de nomes que así se vaian construír.

Cando o segundo argumento y é unha lista ou unha matriz con máis dunha
columna, e o nivel de retardo é maior ca 1, a disposición por defecto dos
elementos na lista que se devolve é por orde de variable: primeiro se
devolven todos os retardos da primeira serie ou columna contida nese
argumento, seguidos de todos os da segunda, e así de forma sucesiva. O
terceiro argumento (opcional) podes usalo para cambiar isto: se é non nulo
bylag, entón os elementos ordénanse por retardo: o primeiro retardo de
todas as series ou columnas, logo o segundo retardo de todas as series ou
columnas, etc.

Consulta tamén "mlag" para a utilización con matrices.

# lastobs
Resultado:     enteiro
Argumento:   y (serie)

Devolve o número enteiro positivo que indexa a última observación non
ausente da serie y. Ten en conta que se está activa algunha forma de
submostraxe, o valor que se devolve pode ser maior ca o valor devolto polo
accesorio "$t2". Mira tamén "firstobs".

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

Devolve un escalar co logaritmo natural do determinante de A, calculado por
medio da descomposición LU. Mira tamén "det", "rcond", "cnumber".

# ldiff
Resultado:     mesmo tipo que o introducido
Argumento:   y (serie ou lista)

Devolve un resultado (do tipo do argumento) coas primeiras diferenzas do
logaritmo deste; os valores iniciais considéranse NA.

Cando se devolve unha lista, as variables individuais noméanse de forma
automática seguindo o padrón ld_varname, onde varname indica o nome da
serie orixinal. A parte orixinal do nome vai tronzarse cando así resulte
necesario, e mesmo poderá axustarse para garantir que sexa único dentro do
conxunto de nomes que así se vaian construír.

Mira tamén "diff", "sdiff".

# lincomb
Resultado:     serie
Argumentos:  L (lista)
            b (vector)

Devolve unha nova serie calculada como unha combinación linear das series
da lista L. Os coeficientes veñen dados polo vector b, cuxo tamaño debe
ser igual ao número de series que hai en L.

Mira tamén "wmean".

# linearize
Resultado:     serie
Argumento:   x (serie)

Para executalo é preciso ter instalado o TRAMO. Devolve unha serie que é
unha versión "linearizada" do argumento; é dicir, unha serie onde calquera
valor ausente substitúese por valores interpolados, e onde as observacións
anómalas axústanse. Para iso utilízase un mecanismo completamente
automático do TRAMO. Para obter máis detalles, consulta a documentación
do TRAMO.

Cae na conta de que, se a serie do argumento non posúe valores ausentes nin
observacións que o TRAMO considere anómalas, esta función devolve unha
copia da serie orixinal.

# ljungbox
Resultado:     escalar
Argumentos:  y (serie)
            p (enteiro)

Devolve un escalar co cálculo do estatístico Q de Ljung-Box para a serie
y, utilizando o nivel de retardo p, ao longo da mostra actualmente
seleccionada. O nivel de retardo debe de ser maior ou igual a 1, e menor ca
o número de observacións dispoñibles.

Ese valor do estatístico podes cotexalo coa distribución Khi-cadrado con p
graos de liberdade para verificar a hipótese nula de que a serie y non ten
correlación serial. Mira tamén "pvalue".

# lngamma
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co log da función Gamma de x.

# loess
Resultado:     serie
Argumentos:  y (serie)
            x (serie)
            d (enteiro, opcional)
            q (escalar, opcional)
            robust (booleano, opcional)

Realiza unha regresión polinómica ponderada localmente, e devolve unha
serie que contén os valores previstos de y para cada valor non ausente de
x. O método que se utiliza é do tipo que está descrito por William
Cleveland (1979).

Os argumentos d e q (opcionais) permiten especificar: a orde do polinomio de
x e que proporción dos puntos de datos se van utilizar na estimación
local, respectivamente. Os valores que se lles supoñen por defecto son d =
1 e q = 0.5; e outros valores admisibles para d son 0 e 2. Cando establezas
d = 0 vas reducir a regresión local a unha forma de media móbil. O valor
de q debe de ser maior ca 0 e non pode ser maior ca 1; os valores máis
grandes producen un resultado final máis suavizado.

Cando se especifica un valor non nulo para o argumento robust, as
regresións locais reitéranse dúas veces, con modificacións nas
ponderacións en base aos erros da iteración previa, e de xeito que teñan
menos influenza as observacións anómalas.

Revisa tamén a función "nadarwat" e, por engadido, consulta o Guía de
usuario de Gretl (Capítulo 36) para obter máis detalles sobre métodos non
paramétricos.

# log
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie, matriz ou lista)

Devolve un resultado (do tipo do argumento) co logaritmo natural de x,
xerando NA se este non é positivo. Aviso: ln é un pseudónimo admisible
para log.

Cando se devolve unha lista, as variables individuais noméanse de forma
automática seguindo o padrón l_varname, onde varname indica o nome da
serie orixinal. A parte orixinal do nome vai tronzarse cando así resulte
necesario, e mesmo poderá axustarse para garantir que sexa único dentro do
conxunto de nomes que así se vaian construír.

# log10
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co logaritmo en base 10 de x,
xerando NA se este non é positivo.

# log2
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co logaritmo en base 2 de x,
xerando NA se este non é positivo.

# logistic
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do mesmo tipo do argumento x) coa función loxística
deste; isto é, e^x/(1 + e^x). Se x é unha matriz, a función aplícase a
cada elemento.

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

Devolve unha matriz triangular inferior de orde n x n: os elementos da
diagonal principal e abaixo desta son iguais aos elementos correspondentes
de A e os demais son iguais a cero.

Mira tamén "upper".

# lrvar
Resultado:     escalar
Argumentos:  y (serie ou vector)
            k (enteiro)

Devolve un escalar coa varianza de longo prazo do argumento y, que se
calcula utilizando un núcleo ("kernel") de Bartlett con tamaño de xanela
igual a k. Podes seleccionar o tamaño por defecto da xanela, é dicir a
parte enteira da raíz cúbica do tamaño da mostra, se lle das un valor
negativo a k.

# max
Resultado:     escalar ou serie
Argumento:   y (serie ou lista)

Se o argumento y é unha serie, a función devolve un escalar co valor
máximo desa serie (nas observacións non ausentes). Se o argumento é unha
lista, devolve unha serie onde cada un dos seus valores indica o máximo de
entre as series listadas, para cada observación.

Mira tamén "min", "xmax", "xmin".

# maxc
Resultado:     vector fila
Argumento:   X (matriz)

Devolve un vector fila que contén os valores máximos de cada columna da
matriz X.

Mira tamén "imaxc", "maxr", "minc".

# maxr
Resultado:     vector columna
Argumento:   X (matriz)

Devolve un vector fila que contén os valores máximos de cada fila da
matriz X.

Mira tamén "imaxc", "maxc", "minr".

# mcorr
Resultado:     matriz
Argumento:   X (matriz)

Calcula unha matriz de correlacións tratando cada columna da matriz
argumento X como se fose unha variable. Mira tamén "corr", "cov", "mcov".

# mcov
Resultado:     matriz
Argumento:   X (matriz)

Calcula unha matriz de varianzas-covarianzas tratando cada columna da matriz
argumento X como se fose unha variable. Mira tamén "corr", "cov", "mcorr".

# mcovg
Resultado:     matriz
Argumentos:  X (matriz)
            u (vector, opcional)
            w (vector, opcional)
            p (enteiro)

Devolve a matriz covariograma para outra matriz X de orde T x k (que
xeralmente contén regresores), un vector u de orde T (opcional, que adoita
conter erros), un vector w de orde p+1 (opcional, que contén unhas
ponderacións), e un número enteiro p que indica o nivel de retardo e debe
de ser maior ou igual a 0.

A matriz que se devolve ven dada por

sum_{j=-p}^p sum_j w_{|j|} (X_t' u_t u_{t-j} X_{t-j})

Cando se establece que u é null, omítense todos os elementos de u; e cando
se indica que w é null, suponse que todas as ponderacións son 1.0.

# mean
Resultado:     escalar ou serie
Argumento:   x (serie ou lista)

Se x é unha serie, a función devolve un escalar coa súa media na mostra,
ignorando calquera observación ausente.

Se x é unha lista, a función devolve unha serie y tal que y_t indica a
media dos valores das variables desa lista na observación t, ou NA no caso
de que exista algún valor ausente en t.

# meanc
Resultado:     vector fila
Argumento:   X (matriz)

Devolve un vector fila coa media de cada columna de X. Mira tamén "meanr",
"sumc", "sdc".

# meanr
Resultado:     vector columna
Argumento:   X (matriz)

Devolve un vector columna coa media de cada fila de X. Mira tamén "meanc",
"sumr".

# median
Resultado:     escalar ou serie
Argumento:   x (serie ou lista)

Se x é unha serie, a función devolve un escalar coa súa mediana na
mostra, ignorando calquera observación ausente.

Se x é unha lista, a función devolve unha serie y tal que y_t indica a
mediana dos valores das variables desa lista na observación t, ou NA no
caso de que exista algún valor ausente en t.

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

Calcula e devolve a matriz exponencial dunha matriz cadrada A utilizando
para elo o algoritmo 11.3.1 de Golub e Van Loan (1996).

# mgradient
Resultado:     matriz
Argumentos:  p (enteiro)
            theta (vector)
            type (enteiro ou cadea)

Derivadas analíticas para as ponderacións de MIDAS. Denotando como k ao
número de elementos que compoñen o vector theta de hiperparámetros, esta
función devolve unha matriz de orde p x k que contén o gradiente do vector
de ponderacións (tal como o calcula a función "mweights") con respecto a
os elementos de theta. O primeiro argumento representa o nivel de retardo
desexado e o derradeiro argumento especifica o tipo de disposición de
parámetros. Consulta a función mweights para ter unha relación dos
valores admisibles para type.

Mira tamén "mweights", "mlincomb".

# min
Resultado:     escalar ou serie
Argumento:   y (serie ou lista)

Cando o argumento y é unha serie, devolve un escalar co valor mínimo das
observacións non ausentes da serie. Cando o argumento é unha lista,
devolve unha serie onde cada elemento é o valor mínimo de entre as series
listadas, en cada observación.

Mira tamén "max", "xmax", "xmin".

# minc
Resultado:     vector fila
Argumento:   X (matriz)

Devolve un vector fila co valor mínimo de cada columna de X.

Mira tamén "iminc", "maxc", "minr".

# minr
Resultado:     vector columna
Argumento:   X (matriz)

Devolve un vector columna co valor mínimo de cada fila de X.

Mira tamén "iminr", "maxr", "minc".

# missing
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou lista)

Devolve unha variable binaria (do mesmo tipo que o argumento) que toma o
valor 1, cando x é NA. Cando x é unha serie, faise a comprobación para
cada elemento. Cando x é unha lista de series, devolve unha serie que toma
o valor 1 nas observacións nas que ao menos unha das series presenta un
valor ausente, e o valor 0 noutro caso.

Mira tamén "misszero", "ok", "zeromiss".

# misszero
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar ou serie)

Devolve un resultado do tipo do argumento, mudando os NAs en ceros. Se x é
unha serie, múdase cada elemento. Mira tamén "missing", "ok", "zeromiss".

# mlag
Resultado:     matriz
Argumentos:  X (matriz)
            p (escalar ou vector)
            m (escalar, opcional)

Move cara arriba ou abaixo as filas da matriz X. Cando p é un escalar
positivo, a función devolve unha matriz semellante a X, pero cos valores de
cada columna desprazados p filas cara abaixo e coas primeiras p filas
cubertas co valor m. Cando p é un número negativo, a matriz que se devolve
seméllase a X, pero cos valores de cada columna desprazados cara arriba e
as últimas filas cubertas co valor m. Se omites m, enténdese que é igual
a cero.

Se p é un vector, a operación indicada no parágrafo anterior realízase
con cada un dos elementos de p, xuntando horizontalmente as matrices
resultantes.

Consulta tamén "lags".

# mlincomb
Resultado:     serie
Argumentos:  hfvars (lista)
            theta (vector)
            type (enteiro ou cadea)

Esta é unha función MIDAS moi oportuna que combina as funcións "lincomb"
e "mweights". Dada a lista hfvars, elabora unha serie que é unha suma
ponderada dos elementos desa lista. As ponderacións baséanse no vector
theta de hiperparámetros e no tipo de disposición de parámetros: consulta
a función mweights para obter máis detalles. Cae na conta de que "hflags"
xeralmente é o mellor xeito de crear unha lista apropiada para que sexa o
primeiro argumento desta función.

Para ser máis explícitos, a orde

	  series s = mlincomb(hfvars, theta, 2)

é equivalente a

	  matrix w = mweights(nelem(hfvars), theta, 2)
	  series s = lincomb(hfvars, w)

pero utilizar a función mlincomb, permite economizar algo ao teclear e
tamén algúns ciclos de uso de CPU.

# mnormal
Resultado:     matriz
Argumentos:  r (enteiro)
            c (enteiro)

Devolve unha matriz feita con valores xerados de forma pseudoaleatoria
mediante variables con distribución Normal estándar, e que vai ter r filas
e c columnas. Mira tamén "normal", "muniform".

# mols
Resultado:     matriz
Argumentos:  Y (matriz)
            X (matriz)
            &U (referencia a matriz, ou null)
            &V (referencia a matriz, ou null)

Devolve unha matriz k x n de estimacións de parámetros obtidos mediante a
regresión de Mínimos Cadrados Ordinarios da matriz Y de orde T x n sobre a
matriz X de orde T x k.

Cando se indica o terceiro argumento, e non é null, a función vai xerar
unha nova matriz U de orde T x n, que contén os erros. Cando se indica o
último argumento, e non é null, a matriz V que se xera vai ser de orde k x
k e contén (a) a matriz de covarianzas dos estimadores dos parámetros, se
Y ten só unha columna, ou (b) a matriz X'X^-1 se Y ten varias columnas.

Por defecto, as estimacións obtéñense por medio da descomposición de
Cholesky, cun último recurso á descomposición QR se as columnas de X
teñen alta multicolinearidade. Podes forzar o uso da descomposición SVD
mediante a instrución set svd on.

Mira tamén "mpols", "mrls".

# monthlen
Resultado:     enteiro
Argumentos:  month (enteiro)
            year (enteiro)
            weeklen (enteiro)

Devolve un número enteiro que expresa cantos días (relevantes) ten un mes
dun ano (no proléptico calendario Gregoriano) especificados nos dous
primeiros argumentos, considerando a duración de semana indicada por
weeklen. Este debe de ser igual a 5, 6 ou 7 (indicando o valor 6 que non se
contan os domingos, e 5 que non se contan nin os sábados nin os domingos).

# movavg
Resultado:     serie
Argumentos:  x (serie)
            p (escalar)
            control (enteiro, opcional)
            y0 (escalar, opcional)

Devolve unha serie que é unha media móbil de x, e dependendo do valor do
parámetro p resultará unha media móbil simple ou ponderada
exponencialmente.

Cando p > 1, a función calcula unha media móbil simple de p elementos; é
dicir, calcula a media aritmética de x desde o período t ata o período
t-p+1. Cando indicas un valor non nulo para o argumento control (opcional),
a media móbil "céntrase"; noutro caso "retárdase". O outro argumento y0
non se vai ter en conta.

Cando p é un fracción decimal entre 0 e 1, a función calcula unha media
móbil exponencial:

y(t) = p*x(t) + (1-p)*y(t-1)

Por defecto, a serie y que se devolve, iníciase utilizando o primeiro valor
válido de x. Pero podes utilizar o parámetro control para especificar o
número de observacións iniciais que deben de tomarse para que a súa media
sexa y(0); un valor de cero para control expresa que deben de tomarse todas
as observacións para iso. Outra posibilidade consiste en que podes
especificar o valor inicial utilizando o argumento opcional y0; nese caso o
argumento control non vai terse en conta.

# mpols
Resultado:     matriz
Argumentos:  Y (matriz)
            X (matriz)
            &U (referencia a matriz, ou null)

Funciona igual que "mols", devolvendo unha matriz, agás que os cálculos
fanse con alta precisión utilizando a biblioteca GMP.

Por defecto, GMP utiliza 256 bits para cada número de punto flotante, pero
podes axustar isto utilizando a variable de contexto GRETL_MP_BITS; por
exemplo, GRETL_MP_BITS=1024.

# mrandgen
Resultado:     matriz
Argumentos:  d (cadea)
            p1 (escalar)
            p2 (escalar, condicional)
            p3 (escalar, condicional)
            rows (enteiro)
            cols (enteiro)
Exemplos:   matrix mx = mrandgen(u, 0, 100, 50, 1)
            matrix mt14 = mrandgen(t, 14, 20, 20)

Funciona da mesma forma que a función "randgen" agás polo feito de que
devolve unha matriz en troques dunha serie. Os argumentos iniciais (cuxo
número depende da distribución escollida) para esta función, xa se
describen para randgen, pero deben de seguirse con dous números enteiros
para especificar o número de filas e de columnas que vai ter a matriz
aleatoria desexada.

O primeiro dos exemplos precedentes crea un vector columna con 50 elementos,
a partir dunha distribución uniforme. O segundo exemplo crea unha matriz
aleatoria de orde 20 x 20, con valores xerados da distribución t con 14
graos de liberdade.

Mira tamén "mnormal", "muniform".

# mread
Resultado:     matriz
Argumentos:  fname (cadea)
            import (booleano, opcional)

Le unha matriz gardada no ficheiro chamado fname. Se o ficheiro posúe a
extensión ".gz" asúmese que se aplicou a compresión gzip ao gardar os
datos. Se ten a extensión ".bin" asúmese que o ficheiro está en formato
binario (consulta a función "mwrite" para ter máis detalles). Noutro caso,
asúmese que o ficheiro ten un formato de texto simple, de acordo coas
seguintes especificacións:

  O ficheiro pode comezar con unha cantidade calquera de comentarios,
  definidos por liñas que comezan co carácter cancelo, #; estas liñas van
  ignorarse.

  A primeira liña que non sexa un comentario debe de conter dous enteiros,
  separados por un espazo ou unha tabulación, para indicar o número de
  filas e columnas, respectivamente.

  As columnas deben de estar separadas por espazos ou por tabulacións.

  O separador decimal debe de ser o carácter punto, ".".

Se no primeiro argumento non está especificado o camiño completo ata o
ficheiro, vaise procurar en algunhas localizacións que se consideren
"probables", empezando polo cartafol de traballo actualmente establecido en
"workdir". Non obstante, cando se indica un valor non nulo para o segundo
argumento import (opcional) da función, o ficheiro procúrase no cartafol
"dot" do usuario. Isto ten a intención de que se use esta función xunto
coas que exportan matrices e que se ofrecen o contexto da instrución
"foreign". Nese caso o argumento fname debe de ser un nome de ficheiro
simple, sen indicar o camiño ata o ficheiro.

Mira tamén "bread", "mwrite".

# mreverse
Resultado:     matriz
Argumento:   X (matriz)

Devolve unha matriz que contén as filas de X en orde inversa. Para obter
unha matriz na que as columnas de X aparezan en orde inversa pódese
utilizar:

	  matrix Y = mreverse(X')'

# mrls
Resultado:     matriz
Argumentos:  Y (matriz)
            X (matriz)
            R (matriz)
            q (vector columna)
            &U (referencia a matriz, ou null)
            &V (referencia a matriz, ou null)

Mínimos cadrados restrinxidos: xera a matriz de orde k x n cos parámetros
estimados mediante a regresión de mínimos cadrados da matriz Y de orde T x
n, sobre a matriz X de orde T x k, suxeita ao conxunto de restricións
lineais dos parámetros RB = q, onde B representa o vector que formarían os
parámetros encastelados uns sobre os outros. R debe de ter kn columnas e
cada liña dela indica os coeficientes dunha das restricións lineais. O
número de filas de q debe de coincidir co número de filas de R.

Se o quinto argumento da función non é null, entón a matriz U de orde T x
n vai conter os erros. Cando proporcionas un argumento final que non é
null, entón a matriz V de orde k x k vai gardar a contrapartida restrinxida
da matriz X'X^-1. Podes construír a matriz de varianzas-covarianzas dos
estimadores da ecuación i multiplicando a submatriz apropiada de V por unha
estimación da varianza da perturbación esa ecuación.

# mshape
Resultado:     matriz
Argumentos:  X (matriz)
            r (enteiro)
            c (enteiro)

Reordena os elementos da matriz X nunha nova matriz que ten r filas e c
columnas. Os elementos lense e gárdanse comezando polo da primeira columna
e fila de X, e seguindo cos das seguintes filas ata acabar cos desa columna,
e logo coas demais columnas. Se X ten menos elementos ca k= rc, estes vanse
repetir de forma cíclica. Noutro caso, se X ten máis elementos, só se
utilizan os primeiros k elementos.

Mira tamén "cols", "rows", "unvech", "vec", "vech".

# msortby
Resultado:     matriz
Argumentos:  X (matriz)
            j (enteiro)

Devolve unha matriz coas mesmas filas da matriz do argumento X reordenadas
de forma crecente de acordo cos elementos da columna j. Esta orde é
estable: as filas que comparten o mesmo valor na columna j non se
intercambian.

# muniform
Resultado:     matriz
Argumentos:  r (enteiro)
            c (enteiro)

Devolve unha matriz feita con números xerados de forma pseudoaleatoria
mediante variables con distribución Uniforme (0,1), e que vai ter r filas e
c columnas. Aviso: O método predilecto para xerar números pseudoaleatorios
con distribución uniforme é o que usa a función "randgen1".

Mira tamén "mnormal", "uniform".

# mweights
Resultado:     matriz
Argumentos:  p (enteiro)
            theta (vector)
            type (enteiro ou cadea)

Devolve un vector de orde p coas ponderacións MIDAS que se aplican aos p
retardos dunha serie de alta frecuencia, baseado no vector theta de
hiperparámetros.

O argumento type identifica o tipo de disposición de parámetros que vai
regular o número k de elementos que se solicitan para theta: 1 = para Almon
exponencial normalizada (k debe de ser cando menos igual a1, habitualmente
2); 2 = para Beta normalizada co retardo final nulo (k = 2); 3 = para Beta
normalizada co retardo final non nulo (k = 3); e 4 = para Almon polinómico
(k debe de ser cando menos igual a 1). Ten en conta que no caso de Beta
normalizada, os dous primeiros elementos de theta deben de ser positivos.

Podes indicar o type como un código enteiro tal e como se amosa máis
abaixo, ou mediante unha das seguintes cadeas de texto (respectivamente):
nealmon, beta0, betan ou almonp. Se utilizas unha cadea de texto, esta
deberá de estar situada entre comiñas. Por exemplo, as dúas seguintes
expresións son equivalentes:

	  W = mweights(8, theta, 2)
	  W = mweights(8, theta, "beta0")

Mira tamén "mgradient", "mlincomb".

# mwrite
Resultado:     enteiro
Argumentos:  X (matriz)
            fname (cadea)
            export (booleano, opcional)

Escribe a matriz do argumento X nun ficheiro co nome fname. Por defecto,
este ficheiro vai ser de texto plano e, na primeira liña, vai conter dous
números enteiros que representan o número de filas e columnas,
respectivamente, separados por un carácter de tabulación. Nas seguintes
filas, os elementos da matriz amósanse en notación científica, separados
por tabulacións (unha liña por fila). Para formatos alternativos, mira
máis abaixo.

Cando xa existe un ficheiro chamado fname, vaise sobrescribir. A execución
da función devolve un enteiro igual a 0 se non se completa con éxito; e
devolve un enteiro que non é cero cando acontece un fallo (por exemplo se
non se pode sobrescribir o ficheiro).

O ficheiro cos resultados vai escribirse no cartafol establecido como
actual, "workdir", agás que a cadea de texto do argumento fname especifique
o cartafol co camiño completo. Non obstante, se indicas un valor non nulo
para o argumento export, o ficheiro cos resultados vai escribirse no
cartafol "dot" do usuario, onde estará accesible por defecto por medio das
funcións para cargar matrices que se ofrecen no contexto da instrución
"foreign". Neste caso, debes de indicar un simple nome de ficheiro para o
segundo argumento, sen a parte que expresa o camiño ao cartafol.

As matrices gardadas mediante a forma que ten por defecto a función mwrite,
poden lerse doadamente con outros programas. Consulta o Guía de usuario de
Gretl (Capítulo 15) para obter máis detalles.

Dúas matizacións, que se exclúen mutuamente, desta función están
dispoñibles como se indica deseguido:

  Se o argumento fname ten a extensión ".gz", entón o ficheiro gárdase
  coa compresión gzip.

  Se o argumento fname ten a extensión ".bin", entón o ficheiro gárdase
  con formato binario. Neste caso os primeiros 19 bytes conteñen os
  caracteres gretl_binary_matrix, os seguintes 8 bytes conteñen dous
  enteiros de 32 bits que proporcionan o número de filas e de columnas, e o
  que resta do ficheiro contén os elementos da matriz ordenados por
  columnas, en formato "little-endian doubles". Cando executas Gretl nun
  sistema "big-endian", os valores binarios convértense a "little-endian"
  ao escribilos, e a "big-endian" aos ler.

Cae na conta de que se vas ler o ficheiro coa matriz, utilizando outro
software alleo, non resulta aconsellable que utilices as opcións gzip nin
binario. Pero se o queres para que o lea Gretl, estes dous formatos
alternativos permiten aforrar espazo; e co formato binario logras unha
lectura máis rápida de matrices grandes. O formato gzip non é
recomendable para matrices moi grandes porque a descompresión pode ser
bastante lenta.

Mira tamén "mread".

# mxtab
Resultado:     matriz
Argumentos:  x (serie ou vector)
            y (serie ou vector)

Devolve unha matriz que inclúe a tabulación cruzada dos valores contidos
en x (por filas) e y (por columnas). Os dous argumentos desta función deben
de ser do mesmo tipo (ambas series ou ambos vectores columna) e, a causa da
utilización típica desta función, asúmese que contén unicamente valores
enteiros.

Mira tamén "values".

# naalen
Resultado:     matriz
Argumentos:  d (serie ou vector)
            cens (serie ou vector, opcional)

Devolve o cálculo do estimador non paramétrico de Nelson-Aalen da función
de risco (Nelson, 1972; Aalen, 1978), dada unha mostra d de datos de
duración, que posiblemente estea acompañada dun rexistro de estado de
censura, cens. A matriz que devolve a función ten tres columnas que
conteñen, respectivamente: os valores únicos ordenados en d, a estimación
da función de risco acumulado que se corresponde cos valores de duración
da columna 1, e a desviación padrón do estimador.

Cando indicas a serie cens, utilízase o valor 0 para sinalar que unha
observación non está censurada, namentres que o valor 1 indica que unha
observación está censurada do lado dereito (é dicir, o período de
observación do individuo en cuestión concluíu antes da duración ou o
período rexistrouse como rematado). Cando non indicas cens, asúmese que
todas as observacións son non censuradas. (Aviso: a semántica de cens pode
estenderse nalgún punto para cubrir outros tipos de censura.)

Mira tamén "kmeier".

# nadarwat
Resultado:     serie
Argumentos:  y (serie)
            x (serie)
            h (escalar)

Devolve unha serie coa estimación non paramétrica da media condicional de
y dado x, de Nadaraya-Watson. A serie que devolve a función, contén os
valores das estimacións non paramétricas de E(y_i|x_i) para cada un dos
elementos non ausentes da serie x.

A función núcleo ("kernel") K ven dada por K = exp(-x^2 / 2h) cando |x| <
T, e igual a cero noutro caso.

O argumento h, que se coñece como o ancho de banda ("bandwidth"), é un
parámetro que determina o usuario cun número real positivo. Habitualmente
este é un número pequeno pois valores máis grandes de h fan que m(x) sexa
máis suave; unha escolla popular é n^-0.2. Podes obter máis detalles no
Guía de usuario de Gretl (Capítulo 36).

O escalar T utilízase para previr problemas numéricos cando se avalía a
función núcleo lonxe de máis do cero, e chámase parámetro "trim".

Este parámetro "trim" pode axustarse establecendo nadarwat_trim como
múltiplo de h. O valor por defecto é 4.

O usuario pode indicar un valor negativo para o ancho de banda. Iso
interprétase como un convencionalismo sintáctico para obter o estimador
que omite unha observación; é dicir, unha variante do estimador que non
utiliza a observación i-ésima para avaliar m(x_i). Isto fai que o
estimador de Nadaraya-Watson sexa numericamente máis robusto, e por iso
recoméndase habitualmente utilizalo cando se calcula coa intención de
facer inferencias. Loxicamente, o ancho de banda que se utiliza en realidade
é o valor absoluto de h.

# nelem
Resultado:     enteiro
Argumento:   L (lista, matriz, paquete ou arranxo)

Devolve un enteiro co número de elementos que hai no argumento; este pode
ser unha lista, unha matriz, un feixe ou un arranxo (pero non unha serie).

# ngetenv
Resultado:     escalar
Argumento:   s (cadea)

Devolve un escalar co valor numérico dunha variable de contexto que ten o
nome do argumento s, se esa variable está definida e se ten un valor
numérico; noutro caso devolve NA. Consulta tamén "getenv".

# nlines
Resultado:     escalar
Argumento:   buf (cadea)

Devolve un escalar coa cantidade de filas completas (é dicir, filas que
rematan co carácter de nova liña) en buf.

Exemplo:

        string web_page = readfile("http://gretl.sourceforge.net/")
        scalar number = nlines(web_page)
        print number

# NMmax
Resultado:     escalar
Argumentos:  &b (referencia a matriz)
            f (chamada a función)
            maxfeval (enteiro, opcional)

Devolve un escalar co resultado dunha maximización numérica feita co
método do simplex sen derivadas de Nelder-Mead. O argumento b debe de
conter os valores iniciais dun conxunto de parámetros, e o argumento f debe
de especificar unha chamada á función que vai calcular o criterio
obxectivo (escalar) que se quere maximizar, dados os valores actuais dos
parámetros, así como calquera outros datos que sexan relevantes. Cando se
completa con éxito a súa execución, NMmax devolve o valor maximizado do
criterio obxectivo, e b contén finalmente os valores dos parámetros que
producen o máximo.

Podes utilizar o terceiro argumento (opcional) para indicar o número
máximo de avaliacións da función; so o omites ou o estableces igual a
cero, o máximo tómase por defecto igual a 2000. Como indicación especial
para esta función, podes poñer un valor negativo para o argumento
maxfeval. Nese caso, tómase o seu valor absoluto e NMmax amosa un fallo se
o mellor valor atopado para a función obxectivo despois de realizar o
máximo número de avaliacións da función, non é un óptimo local. Por
outra parte, neste senso a non converxencia non se trata coma un fallo.

Se o teu obxectivo realmente é acadar un mínimo, podes ben trocar a
función considerando o negativo do criterio, ou ben, alternativamente,
podes invocar a función NMmaxbaixo o alcume NMmin..

Para máis detalles e exemplos, consulta o capítulo sobre métodos
numéricos no Guía de usuario de Gretl (Capítulo 33). Mira tamén
"simann".

# NMmin
Resultado:     escalar

Un alcume de "NMmax". Se invocas a función baixo este nome, execútase
facendo unha minimización.

# nobs
Resultado:     enteiro
Argumento:   y (serie)

Devolve o número de observacións non ausentes da variable y na mostra
actual seleccionada.

# normal
Resultado:     serie
Argumentos:  mu (escalar)
            sigma (escalar)

Devolve unha serie xerada cunha variable pseudoaleatoria gaussiana de media
mu e desviación padrón sigma. Se non indicas ningún argumento, os valores
que se devolven son os dunha variable con distribución de probabilidade
Normal estándar, N(0,1). Os valores prodúcense utilizando o método
Ziggurat (Marsaglia e Tsang, 2000).

Mira tamén "randgen", "mnormal", "muniform".

# normtest
Resultado:     matriz
Argumentos:  y (serie ou vector)
            method (cadea, opcional)

Devolve un vector fila cos resultados de realizar unha proba de Normalidade
sobre y. A función fai por defecto a proba de Doornik-Hansen, pero podes
utilizar o argumento method (opcional) para escoller unha alternativa.
Indica: swilk para executar a proba de Shapiro-Wilk, jbera para realizar a
proba de Jarque-Bera, ou lillie para efectuar a proba de Lilliefors.

Podes indicar o segundo argumento con formato entre comiñas ou sen elas.
Neste último caso, tamén podes indicar unha cadea de texto cuxo valor sexa
o nome dun dos métodos, polo que se vai substituír cando se executa. A
continuación amósanse tres xeitos aceptables de executar a proba de
Shapiro-Wilk:

	  matrix nt = normtest(y, swilk)
	  matrix nt = normtest(y, "swilk")
	  string testtype = "swilk"
	  matrix nt = normtest(y, testtype)

O vector fila que se devolve é de orde 1 x 2; contén o valor do
estatístico de proba solicitado e a probabilidade asociada a ese valor.
Consulta tamén a instrución "normtest".

# npcorr
Resultado:     matriz
Argumentos:  x (serie ou vector)
            y (serie ou vector)
            method (cadea, opcional)

Devolve un vector fila cos cálculos dunha medida de correlación entre x e
y, utilizando un método non paramétrico. Se indicas o terceiro argumento,
este debe de ser kendall (para o método por defecto, o tau de Kendall,
versión b) ou ben spearman (para o rho de Spearman).

O resultado que se devolve é un vector fila con 3 valores que indican: a
medición da correlación, o valor do estatístico de proba da hipótese
nula de incorrelación, e a probabilidade asociada a ese valor. Advirte que,
se o tamaño da mostra é moi pequeno, o estatístico de proba e/ou a
probabilidade pode ser NaN (non é número, ou ausente).

Consulta tamén "corr" para a correlación de Pearson.

# npv
Resultado:     escalar
Argumentos:  x (serie ou vector)
            r (escalar)

Devolve un escalar co Valor Actual Neto de x, considerado este como unha
secuencia de pagos (negativos) e ingresos (positivos), avaliados a unha taxa
de desconto anual que debes de indicar no argumento r como fracción decimal
entre 0 e 1, non como porcentaxe (por exemplo 0.05, e non 5%). O primeiro
valor da serie/vector do primeiro argumento, considérase que está datado
"agora" e non se desconta. Para imitar unha función VAN na que se desconte
o primeiro valor, engade un cero ao principio da serie/vector do primeiro
argumento.

O tipo de frecuencia dos datos que admite esta función pode ser anual,
trimestral, mensual e sen data (este tipo trátase como se fora anual).

Mira tamén "irr".

# NRmax
Resultado:     escalar
Argumentos:  &b (referencia a matriz)
            f (chamada a función)
            g (chamada a función, opcional)
            h (chamada a función, opcional)

Devolve un escalar co resultado dunha maximización numérica feita co
método de Newton-Raphson. O argumento b debe de conter os valores iniciais
do conxunto de parámetros, e o argumento f debe de indicar unha chamada á
función que vai calcular o criterio obxectivo (escalar) que queres
maximizar, dados os valores actuais dos parámetros, así como calquera
outro dato relevante. Se o que queres realmente é minimizar o criterio
obxectivo, esta función debera de devolver o valor negativo do mesmo. Cando
se completa con éxito a súa execución, NRmax devolve o valor maximizado
do criterio obxectivo, e b vai conter os valores dos parámetros que
proporcionan o máximo dese criterio.

O terceiro e cuarto argumentos (opcionais) proporcionan xeitos de indicar,
respectivamente, as derivadas analíticas e unha matriz hessiana analítica
(negativa). As funcións ás que se refiren estes argumentos g e h deben de
ter, como primeiro elemento, unha matriz definida con anterioridade que sexa
do rango correcto para poder conter o vector gradiente ou a matriz hessiana,
indicados en forma de punteiro. Ademais, outro dos seus elementos, debe de
ser o vector de parámetros (en forma de punteiro ou non). Outro tipo de
elementos son opcionais. Se omites calquera dos argumentos opcionais (ou os
dous), utilízase unha aproximación numérica.

Para máis detalles e exemplos, consulta o capítulo sobre métodos
numéricos no Guía de usuario de Gretl (Capítulo 33). Mira tamén
"BFGSmax", "fdjac".

# NRmin
Resultado:     escalar

Un alcume de "NRmax". Se invocas a función baixo este nome, execútase
facendo unha minimización.

# nullspace
Resultado:     matriz
Argumento:   A (matriz)

Devolve unha matriz co cálculo do espazo nulo á dereita correspondente á
matriz A, feito mediante a descomposición en valores singulares: o
resultado é unha matriz B que fai que o produto AB sexa unha matriz nula.
Como excepción, se a matriz A ten rango completo por columnas, o resultado
que se devolve é unha matriz baleira. Por outra banda, se A é de orde m x
n, entón B vai ser n por (n - r), onde r é o rango de A.

Se A non ten rango completo por columnas, entón ao concatenar verticalmente
a matriz A e a matriz trasposta de B, xérase unha matriz con rango
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)

produce...

      ? 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

Mira tamén "rank", "svd".

# numhess
Resultado:     matriz
Argumentos:  b (vector columna)
            fcall (chamada a función)
            d (escalar, opcional)

Calcula unha aproximación numérica á matriz hessiana asociada ao vector
n-dimensional b, e á función obxectivo que se especifique mediante o
argumento fcall. A chamada á función debe de ter o b como primeiro
argumento (ben directamente ou ben en forma de punteiro), seguido de
calquera argumento adicional que poida ser necesario, e debe de devolver
como resultado un escalar. Ao completarse con éxito numhess devolve unha
matriz n x n que contén a hessiana, e que é exactamente simétrica por
construción.

O método utiliza a extrapolación de Richardson, con catro pasos. Podes
usar o terceiro argumento (opcional) para establecer a fracción d do valor
do parámetro que se utiliza para establecer o tamaño da medida inicial.
Cando omites este argumento, por defecto vai ser d = 0.01.

Aquí tes un exemplo do seu uso:

	  matrix H = numhess(theta, myfunc(&theta, X))

Mira tamén "BFGSmax", "fdjac".

# obs
Resultado:     serie

Devolve unha serie de números enteiros consecutivos, establecendo o 1 ao
comezo do conxunto de datos. Ten en conta que o resultado non vai depender
de que teñas escollida unha submostra. Esta función é útil especialmente
con conxuntos de datos de series temporais. Advertencia: Podes escribir t en
vez de obs, co mesmo efecto.

Mira tamén "obsnum".

# obslabel
Resultado:     cadea
Argumento:   t (enteiro)

Devolve o marcador da observación t, onde t é un número enteiro positivo
que representa a esta observación. A operación inversa pódese facer
mediante a función "obsnum".

# obsnum
Resultado:     enteiro
Argumento:   s (cadea)

Devolve o número enteiro que indica a observación que se corresponde coa
cadea do argumento s. Observa que o resultado non vai depender de que teñas
escollida unha submostra. Esta función é útil con conxuntos de datos
temporais. Por exemplo, o seguinte código ...

	  open denmark
	  k = obsnum(1980:1)

... xera k = 25, indicando que o primeiro trimestre de 1980 é a vixésimo
quinta observación da base de datos denmark.

Mira tamén "obs", "obslabel".

# ok
Resultado:     Mira máis abaixo
Argumento:   x (escalar, serie, matriz ou lista)

Cando o argumento x é un escalar, esta función devolve 1 se x non é NA, e
0 noutro caso. Cando x é unha serie, devolve outra serie que toma o valor 1
nas observacións nas que o argumento non ten valores ausentes, e toma o
valor cero nos demais. Se x é unha lista, o resultado é unha serie con 0
nas observacións nas que ao menos unha serie da lista ten un valor ausente,
e 1 noutro caso.

Cando o argumento x é unha matriz, o comportamento é un pouco diferente,
posto que as matrices non poden conter NAs: a función devolve outra matriz
da mesma dimensión que x, co valor 1 nas posicións que se corresponden con
elementos finitos de x, e co valor 0 nas posicións onde os elementos non
son finitos (ou ben infinitos, ou ben "non números", coma no estándar IEEE
754).

Mira tamén "missing", "misszero", "zeromiss". Pero ten en conta que estas
funcións non son aplicables a matrices.

# onenorm
Resultado:     escalar
Argumento:   X (matriz)

Devolve un escalar coa norma 1 da matriz X, é dicir, o máximo dos
resultados de sumar os valores absolutos dos elementos de X por columnas.

Mira tamén "infnorm", "rcond".

# ones
Resultado:     matriz
Argumentos:  r (enteiro)
            c (enteiro)

Devolve unha matriz con r filas e c columnas, cuberta con valores iguais a
1.

Mira tamén "seq", "zeros".

# orthdev
Resultado:     serie
Argumento:   y (serie)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e devolve unha serie co cálculo das desviacións ortogonais adiantadas para
a variable y.

Algunhas veces se utiliza esta transformación en troques da diferenciación
para eliminar os efectos individuais dos datos de panel. Por compatibilidade
coas primeiras diferenzas, as desviacións gárdanse un paso adiante da súa
localización temporal verdadeira (é dicir, o valor na observación t é a
desviación que, expresándoo de maneira estrita, pertence a t - 1). Deste
xeito, pérdese a primeira observación en cada serie temporal, non a
derradeira.

Mira tamén "diff".

# pdf
Resultado:     mesmo tipo que o introducido
Argumentos:  d (cadea)
            ... (Mira máis abaixo)
            x (escalar, serie ou matriz)
Exemplos:   f1 = pdf(N, -2.5)
            f2 = pdf(X, 3, y)
            f3 = pdf(W, forma, escala, y)

Calcula o valor da función de densidade de probabilidade e devolve un
resultado (do mesmo tipo ca o argumento) coa densidade en x da distribución
identificada polo código d. Consulta "cdf" para obter máis detalles acerca
dos argumentos (escalares) esixidos. Esta función pdf acepta as
distribucións: Normal, t de Student, Khi-cadrado, F, Gamma, Exponencial,
Weibull, Erro Xeneralizado, Binomial e Poisson. Cae na conta de que para a
Binomial e a Poisson, o que se calcula de feito é a masa de probabilidade
no punto especificado. Para t de Student, Khi-cadrado e F tamén están
dispoñibles as súas variantes non centrais.

Para a distribución Normal, consulta tamén "dnorm".

# pergm
Resultado:     matriz
Argumentos:  x (serie ou vector)
            bandwidth (escalar, opcional)

Se só se indica a serie ou vector do primeiro argumento, calcula o seu
periodograma na mostra. Se indicas o escalar do segundo argumento, calcula a
estimación do espectro de x cunha xanela de retardos de Bartlett cun ancho
de banda igual a ese escalar, ata un máximo igual á metade do número de
observacións (T/2).

Devolve unha matriz con T/2 filas e dúas columnas: a primeira destas ten a
frecuencia (omega) desde 2pi/T ata pi, e a segunda das columnas contén a
densidade espectral correspondente.

# pexpand
Resultado:     serie
Argumento:   v (vector)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e realiza a operación inversa de "pshrink". É dicir, dado un vector que
ten unha lonxitude igual ao número de elementos da mostra (de panel)
actualmente seleccionada, esta función devolve unha serie na cal cada valor
do argumento repítese T veces, onde T expresa a lonxitude temporal do
panel. Deste xeito, a serie resultante é invariante en relación ao tempo.

# pmax
Resultado:     serie
Argumentos:  y (serie)
            mask (serie, opcional)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e devolve unha serie que contén cada un dos valores máximos da variable y
en cada unidade de corte transversal (repetíndoo nos períodos de tempo de
cada unha destas).

Cando indicas o segundo argumento (opcional), vanse ignorar aquelas
observacións onde o valor de mask sexa igual a cero.

Mira tamén "pmin", "pmean", "pnobs", "psd", "pxsum", "pshrink", "psum".

# pmean
Resultado:     serie
Argumentos:  y (serie)
            mask (serie, opcional)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e devolve unha serie que contén cada unha das medias temporais da variable
y en cada unidade de corte transversal (repetindo cada valor nos períodos
temporais de cada unha destas). As observacións ausentes ignóranse no
cálculo das medias.

Cando indicas o segundo argumento (opcional), vanse ignorar aquelas
observacións onde o valor de mask sexa igual a cero.

Mira tamén "pmax", "pmin", "pnobs", "psd", "pxsum", "pshrink", "psum".

# pmin
Resultado:     serie
Argumentos:  y (serie)
            mask (serie, opcional)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e devolve unha serie que contén cada un dos valores mínimos da variable y
en cada unidade de corte transversal (repetindo cada valor nos períodos
temporais de cada unha destas).

Cando indicas o segundo argumento (opcional), vanse ignorar aquelas
observacións onde o valor de mask sexa igual a cero.

Mira tamén "pmax", "pmean", "pnobs", "psd", "pshrink", "psum".

# pnobs
Resultado:     serie
Argumentos:  y (serie)
            mask (serie, opcional)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e devolve unha serie que contén o número de observacións válidas da
variable y en cada unidade de corte transversal (repetíndoo nos períodos
temporais de cada unha destas).

Cando indicas o segundo argumento (opcional), vanse ignorar aquelas
observacións onde o valor de mask sexa igual a cero.

Mira tamén "pmax", "pmin", "pmean", "psd", "pshrink", "psum".

# polroots
Resultado:     matriz
Argumento:   a (vector)

Devolve unha matriz coas raíces dun polinomio. Se o polinomio é de grao p,
o vector a debe de conter p + 1 coeficientes en orde ascendente; é dicir,
comezando coa constante e finalizando co coeficiente de x^p.

Se todas as raíces son reais, vanse devolver nun vector columna de
dimensión p; noutro caso devólvese unha matriz de orde p x 2, coas partes
reais na primeira columna e as partes imaxinarias na segunda.

# polyfit
Resultado:     serie
Argumentos:  y (serie)
            q (enteiro)

Devolve unha serie, axustando unha tendencia polinómica de orde q á serie
do argumento y, utilizando o método de polinomios ortogonais. A serie que
se xera contén os valores axustados.

# princomp
Resultado:     matriz
Argumentos:  X (matriz)
            p (enteiro)
            covmat (booleano, opcional)

Sexa X unha matriz de orde T x k, que contén T observacións sobre k
variables. O argumento p debe de ser un número enteiro positivo menor que
ou igual a k. Esta función devolve unha matriz P, de orde T x p, que
contén as p primeiras compoñentes principais de X.

O terceiro argumento (opcional) opera coma un conmutador booleano: se non é
cero, as compoñentes principais calcúlanse en base á matriz de
varianzas-covarianzas das columnas de X (por defecto utilízase a matriz de
correlacións).

Os elementos da matriz P que se devolve, calcúlanse como a suma desde i ata
k de Z_ti veces v_ji, onde Z_ti representa o valor estandarizado (ou
simplemente o valor centrado, se utilizas a matriz de covarianzas) da
variable i na observación t, e v_ji representa o j-ésimo autovector da
matriz de correlacións (ou a matriz de covarianzas) entre as X_is, cos
autovectores ordenados de acordo aos valores decrecentes dos autovalores
correspondentes.

Mira tamén "eigensym".

# prodc
Resultado:     vector fila
Argumento:   X (matriz)

Devolve un vector fila co produto dos elementos das columnas de X. Mira
tamén "prodr", "meanc", "sdc", "sumc".

# prodr
Resultado:     vector columna
Argumento:   X (matriz)

Devolve un vector columna co produto dos elementos das filas de X. Mira
tamén "prodc", "meanr", "sumr".

# psd
Resultado:     serie
Argumentos:  y (serie)
            mask (serie, opcional)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e devolve unha serie que contén a desviación padrón da variable y na
mostra en cada unidade de corte transversal (repetindo cada valor nos
períodos temporais de cada unha destas). O denominador que se utiliza é o
tamaño da mostra en cada unidade menos 1, agás que só haxa 1 única
observación válida para unha unidade dada (pois neste caso devólvese 0)
ou que non haxa ningunha (neste caso devólvese NA).

Cando indicas o segundo argumento (opcional), vanse ignorar aquelas
observacións onde o valor de mask sexa igual a cero.

Nota: Esta función permite comprobar se unha variable calquera (por
exemplo, X) é invariante ao longo do tempo, por medio da condición
max(psd(X)) == 0.

Mira tamén "pmax", "pmin", "pmean", "pnobs", "pshrink", "psum".

# psdroot
Resultado:     matriz cadrada
Argumento:   A (matriz simétrica)

Devolve a matriz cadrada que resulta de aplicarlle á matriz simétrica A do
argumento, unha variante xeneralizada da descomposición de Cholesky. A
matriz do argumento debe de ser semidefinida positiva (aínda que pode ser
singular) pero, se non é cadrada, amósase unha mensaxe de fallo. A
simetría asúmese e non se comproba; só se le o triángulo inferior de A.
O resultado é unha matriz triangular inferior, L, que cumpre A = LL'. Os
elementos indeterminados da solución establécense iguais a cero.

Para o caso no que a matriz A é definida positiva, consulta "cholesky".

# pshrink
Resultado:     matriz
Argumento:   y (serie)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e devolve un vector que contén cada unha das primeiras observacións
válidas da serie y en cada unidade de corte transversal no panel, ao longo
do rango da mostra actual. Se a serie ten algunha unidade que sen
observacións válidas, esa unidade ignórase.

Esta función te proporciona un xeito de compactar as series que te van
devolver algunhas funcións tales como "pmax" e "pmean", nas que se repite
un mesmo valor nos diferentes períodos de tempo dunha mesma unidade de
corte transversal.

Consulta "pexpand" para a operación inversa.

# psum
Resultado:     serie
Argumentos:  y (serie)
            mask (serie, opcional)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e devolve unha serie na que cada valor é a suma da variable y nos distintos
períodos temporais de cada unidade de corte transversal. En cada unha
destas, a suma así calculada se repite para cada período temporal. As
observacións ausentes ignóranse no cálculo das sumas.

Cando indicas o segundo argumento (opcional), vanse ignorar aquelas
observacións onde o valor de mask sexa igual a cero.

Mira tamén "pmax", "pmean", "pmin", "pnobs", "psd", "pxsum", "pshrink".

# pvalue
Resultado:     mesmo tipo que o introducido
Argumentos:  c (carácter)
            ... (Mira máis abaixo)
            x (escalar, serie ou matriz)
Exemplos:   p1 = pvalue(z, 2.2)
            p2 = pvalue(X, 3, 5.67)
            p2 = pvalue(F, 3, 30, 5.67)

Calcula valores P de probabilidade e devolve un resultado (do mesmo tipo ca
o argumento) coa probabilidade P(X > x), onde a distribución de
probabilidade de X indícase coa letra c. Entre os argumentos d e p, podes
necesitar algún argumento adicional escalar para especificar os parámetros
da distribución de que se trate. Para máis detalles, consulta "cdf". As
distribucións soportadas pola función pvalue son: Normal estándar, t,
Khi-cadrado, F, Gamma, Binomial, Poisson, Exponencial, Weibull e Erro
Xeneralizado.

Mira tamén "critical", "invcdf", "urcpval", "imhof".

# pxnobs
Resultado:     serie
Argumentos:  y (serie)
            mask (serie, opcional)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de panel,
e devolve unha serie que contén o número de observacións válidas de y en
cada período de tempo (o valor calculado, repítese en cada unha das
unidades de corte transversal).

Cando indicas o segundo argumento (opcional), vanse ignorar aquelas
observacións onde o valor de mask sexa igual a cero.

Cae na conta de que esta función opera na outra dimensión do panel,
diferente á da función "pnobs".

# pxsum
Resultado:     serie
Argumentos:  y (serie)
            mask (serie, opcional)

Aplícase tan só se o conxunto de datos actual ten estrutura de panel, e
devolve unha serie na que cada valor é a suma de y nas distintas unidades
de corte transversal de cada período temporal. As sumas así calculadas
repítense en cada unidade de corte transversal.

Cando indicas o segundo argumento (opcional), vanse ignorar aquelas
observacións onde o valor de mask sexa igual a cero.

Cae na conta de que esta función opera na outra dimensión do panel,
diferente á da función "psum".

# qform
Resultado:     matriz
Argumentos:  x (matriz)
            A (matriz simétrica)

Devolve unha matriz co resultado de calcular a forma cuadrática Y = xAx'.
Se a matriz simétrica A do argumento, é de tipo xenérico, cando utilizas
esta función en vez da típica multiplicación de matrices, garantes unha
maior rapidez e mellor precisión. Porén, no caso especial de que A sexa
unha matriz identidade, a simple expresión x'x resulta moito mellor ca
qform(x',I(rows(x)).

Se x e A non son matrices conformables, ou se A non é simétrica, a
función devolve un fallo.

# qlrpval
Resultado:     escalar
Argumentos:  X2 (escalar)
            df (enteiro)
            p1 (escalar)
            p2 (escalar)

Devolve un escalar coa probabilidade asociada (P) ao valor do estatístico
para facer a proba LR de Quandt (ou sup-Wald) de cambio estrutural nun punto
descoñecido (consulta "qlrtest"), segundo Bruce Hansen (1997).

O primeiro argumento, X2, indica o valor do estatístico de proba de Wald
máximo (en formato khi-cadrado), e o segundo df indica os seus graos de
liberdade. O terceiro e o cuarto argumentos, representan os puntos de comezo
e de remate do rango central de observacións sobre o que se van calcular os
sucesivos estatísticos de Wald das probas, e debes expresalos como
fraccións decimais en relación ao rango total de estimación. Por exemplo,
se queres adoptar o enfoque estándar do recorte do 15 por cento, debes de
establecer p1 igual a 0.15 e p2 igual a 0.85.

Mira tamén "pvalue", "urcpval".

# qnorm
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) cos cuantís dunha Normal
estándar que se corresponden con cada valor do argumento. Se x non está
entre 0 e 1, devólvese NA. Mira tamén "cnorm", "dnorm".

# qrdecomp
Resultado:     matriz
Argumentos:  X (matriz)
            &R (referencia a matriz, ou null)

Devolve unha matriz co cálculo da descomposición QR dunha matriz X de orde
m x n, é dicir, X = QR onde Q é unha matriz m x n ortogonal e R é unha
matriz n x n triangular superior. A matriz Q devólvese directamente,
mentres que podes obter R mediante o segundo argumento (opcional).

Mira tamén "eigengen", "eigensym", "svd".

# quadtable
Resultado:     matriz
Argumentos:  n (enteiro)
            type (enteiro, opcional)
            a (escalar, opcional)
            b (escalar, opcional)

Devolve unha matriz n x 2 para utilizar coa cuadratura Gaussiana (en
integración numérica). A primeira columna contén os nodos ou abscisas, e
a segunda as ponderacións.

O primeiro argumento especifica o número de puntos (filas) que se van
calcular. O segundo argumento codifica o tipo de cuadratura: utiliza 1 para
a Gauss-Hermite (a establecida por defecto); 2 para a Gauss-Legendre; ou 3
para a Gauss-Laguerre. O sentido dos parámetros a e b (opcionais) depende
do tipo (type) seleccionado, como se explica deseguido.

A cuadratura Gaussiana é un método para aproximar numericamente a integral
definida de algunha función que te interese. Supón que a función se
representa mediante o produto f(x)W(x). Os distintos tipos de cuadratura
difiren na especificación da compoñente W(x): no caso da Hermite isto é
igual a exp(-x^2); no caso da Laguerre é igual a exp(-x); e no caso da
Legendre simplemente é W(x) = 1.

Para cada especificación de W, pode calcularse un conxunto de nodos, x_i, e
un conxunto de ponderacións, w_i, de tal xeito que a suma desde i=1 ata n
de w_i f(x_i) vaise aproximar á integral desexada. Para isto vaise utilizar
o método de Golub e Welsch (1969).

Cando se selecciona o tipo de Gauss-Legendre, podes utilizar os argumentos
opcionais a e b para controlar os límites inferior e superior da
integración, sendo neste caso os valores por defecto o -1 e o 1. (Na
cuadratura de Hermite, os límites están fixados no menos e máis infinito;
mentres que no caso da cuadratura de Laguerre, están fixados no 0 e no
infinito.)

No caso de Hermite, a e b xogan papeis diferentes: poden utilizarse para
substituír a forma por defecto de W(x) pola distribución Normal de
probabilidade con media a e desviación padrón b (coa que está
estreitamente emparentada). Por exemplo, se indicas os valores de 0 e 1 para
estes parámetros, respectivamente, vas provocar que W(x) sexa a función de
densidade de probabilidade Normal estándar, o que é equivalente a
multiplicar os nodos por defecto pola raíz cadrada de dous e dividir as
ponderacións pola raíz cadrada de pi.

# quantile
Resultado:     escalar ou matriz
Argumentos:  y (serie ou matriz)
            p (escalar entre 0 e 1)

Se y é unha serie, devolve un escalar que representa o cuantil p da mesma.
Por exemplo, cando p = 0.5, devólvese a mediana.

Se y é unha matriz, devolve un vector fila que contén os p cuantís das
diferentes columnas de y; é dicir, cada unha das súas columnas trátase
como una serie.

Amais, para unha matriz y admítese unha forma alternativa do segundo
argumento: podes indicar p coma un vector. Nese caso, o valor que se te
devolve é unha matriz de orde m x n, na que m indica o número de elementos
de p e n indica o número de columnas de y.

# randgen
Resultado:     serie
Argumentos:  d (cadea)
            p1 (escalar ou serie)
            p2 (escalar ou serie, 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)

Devolve unha serie calculada cun xerador universal de números aleatorios. O
argumento d é unha cadea de texto (que xeralmente está formada por un só
carácter) que permite especificar o tipo de distribución de probabilidade
da que se extraen os pseudonúmeros. Os argumentos de p1 ata p3 especifican
os parámetros da distribución escollida, e o número destes parámetros
depende desa distribución. Para outras distribucións diferentes á
Beta-Binomial, os parámetros p1 e (caso de ser aplicable) p2 podes
indicalos en formato de escalar ou de serie. Cando os utilizas en formato
escalar, a serie que resulta procede de distribucións identicamente
distribuídas.Cando utilizas series para os argumentos p1 ou p2, a serie
resultante procede de distribucións condicionadas ao valor dos parámetros
en cada observación. No caso da Beta-Binomial todos os parámetros deben de
ser escalares.

A continuación indícanse detalles máis específicos: o código de texto
para cada tipo de distribución móstrase entre parénteses, seguido da
interpretación do argumento p1 e, cando é aplicable, da interpretación de
p2 e p3.

  Uniforme (continua) (u ou U): mínimo, máximo

  Uniforme (discreta) (i): mínimo, máximo

  Normal (z, n ou N): media, desviación padrón

  t de Student (t): graos de liberdade

  Khi-cadrado (c, x ou X): graos de liberdade

  F de Snedecor (f ou F): graos de liberdade (num.), graos de liberdade
  (den.)

  Gamma (g ou G): forma, escala

  Binomial (b ou B): probabilidade, cantidade de ensaios

  Poisson (p ou P): media

  Exponencial (exp): escala

  Weibull (w ou W): forma, escala

  Erro Xeneralizado (E): forma

  Beta (beta): forma1, forma2

  Beta-Binomial (bb): ensaios, forma1, forma2

Mira tamén "normal", "uniform", "mrandgen", "randgen1".

# randgen1
Resultado:     escalar
Argumentos:  d (carácter)
            p1 (escalar)
            p2 (escalar, condicional)
Exemplos:   scalar x = randgen1(z, 0, 1)
            scalar g = randgen1(g, 3, 2.5)

Funciona do mesmo xeito que "randgen" agás polo feito de que devolve un
escalar en troques dunha serie.

O primeiro exemplo de enriba devolve un valor extraído da distribución
Normal estándar, mentres que segundo devolve un valor extraído da
distribución Gamma cun parámetro de forma igual a 3 e de escala a 2.5.

Mira tamén "mrandgen".

# randint
Resultado:     enteiro
Argumentos:  min (enteiro)
            max (enteiro)

Devolve un enteiro pseudoaleatorio no intervalo pechado [min, max]. Mira
tamén "randgen".

# rank
Resultado:     enteiro
Argumento:   X (matriz)

Devolve un enteiro co rango da matriz X, calculado numericamente mediante a
descomposición en valores singulares. Mira tamén "svd".

# ranking
Resultado:     mesmo tipo que o introducido
Argumento:   y (serie ou vector)

Devolve unha serie ou vector coas posicións xerárquicas dos valores de y.
A observación i ten unha posición na xerarquía que ven determinada polo
número de elementos que son menores ca y_i, máis a metade do número de
elementos que son iguais a y_i. (Intuitivamente, podes imaxinalo como a
xerarquía nun torneo de xadrez, onde cada vitoria supón conceder un punto
ao gañador e cada empate supón conceder medio punto). Engádese un 1 de
forma que o número máis pequeno para unha posición é 1, e non 0.

Mira tamén "sort", "sortby".

# rcond
Resultado:     escalar
Argumento:   A (matriz cadrada)

Devolve un escalar co número de condición recíproco da matriz cadrada A a
respecto da norma 1. En moitos casos, este mide de forma máis axeitada ca o
determinante, a sensibilidade de A ás operacións numéricas tales como a
inversión.

O valor calcúlase como o inverso (ou recíproco) do resultado de
multiplicar a norma 1 da matriz cadrada A pola norma 1 da matriz inversa de
A.

Mira tamén "det", "ldet", "onenorm".

# readfile
Resultado:     cadea
Argumentos:  fname (cadea)
            codeset (cadea, opcional)

Se existe un ficheiro co nome do argumento fname, e pode lerse, a función
devolve unha cadea de texto que inclúe o contido dese ficheiro; noutro caso
amosa un fallo. Se fname non indica unha especificación da ruta completa ao
ficheiro, vaise procurar en distintas localizacións "probables", comezando
pola establecida actualmente, "workdir".

Se fname comeza cun identificador dun protocolo de internet que sexa
admisible (http://, ftp:// ou https://), actívase unha orde a libcurl para
que descargue o recurso. Para outras operacións de descarga máis
complicadas, consulta tamén "curl".

Cando o texto que se quere ler non está codificado en UTF-8, Gretl vai
tratar de volver a codificalo desde o tipo actual de codificación local (se
este non é UTF-8) ou desde ISO-8859-15 noutro caso. Se este sinxelo
funcionamento por defecto non cumpre as túas necesidades, podes usar o
segundo argumento (opcional) para especificar un tipo de codificación. Por
exemplo, se queres ler texto que está no tipo de páxina de código
Microsoft 1251, e este non é o teu tipo de código local, deberás de
indicar "cp1251" como segundo argumento.

Exemplos:

        string web_page = readfile("http://gretl.sourceforge.net/")
        print web_page

        string current_settings = readfile("@dotdir/.gretl2rc")
        print current_settings

Consulta tamén as funcións "sscanf" e "getline".

# regsub
Resultado:     cadea
Argumentos:  s (cadea)
            match (cadea)
            repl (cadea)

Devolve unha cadea de texto cunha copia de s onde todos os casos nos que
ocorre do padrón match, substitúense por repl. Os dous argumentos match e
repl interprétanse como expresións regulares de estilo Perl.

Consulta tamén a función "strsub" para a substitución simple de cadeas de
texto.

# remove
Resultado:     enteiro
Argumento:   fname (cadea)

Elimina o ficheiro do argumento fname no caso de que este exista e que o
usuario o poda gardar. Esta función devolve un enteiro igual a 0 no caso de
que a operación teña éxito, e un valor non nulo se o ficheiro non existe
ou non se pode eliminar.

Cando fname contén o camiño completo ata o ficheiro, Gretl tratará de
eliminalo, e devolverá un fallo se ese ficheiro non existe ou non pode
eliminarse por algún motivo (por exemplo, por non ter suficientes
privilexios para poder facelo). Cando fname non contén o camiño completo,
entón asúmese que o ficheiro ao que se refire, está no cartafol de
traballo establecido ("workdir"). Se o ficheiro non existe ou non pode
gardarse, non se vai procurar en ningún outro cartafol.

# replace
Resultado:     mesmo tipo que o introducido
Argumentos:  x (serie ou matriz)
            find (escalar ou vector)
            subst (escalar ou vector)

Devolve un resultado (do tipo de) x trocando os seus elementos que sexan
iguais ao elemento i-ésimo de find polo concordante de subst.

Cando o segundo argumento (find) é un escalar, o terceiro argumento (subst)
tamén debe de ser un escalar. Cando ambos son vectores, deben de ter o
mesmo número de elementos. Pero cando find é un vector e subst é un
escalar, entón todas as coincidencias de aquel substitúense en x con
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

produce...

          a (2 x 3)

          1   2   3
          3   4   5

          b (2 x 3)

          -1    2   -8
          -8    0    5

# resample
Resultado:     mesmo tipo que o introducido
Argumentos:  x (serie ou matriz)
            blocksize (enteiro, opcional)

A descrición inicial desta función refírese ao casos con datos de corte
transversal ou con series de tempo; mira máis abaixo para os casos con
datos de panel.

Devolve o resultado (do tipo do argumento) que se obtén facendo unha
mostraxe por repetición de x con substitución. Se o argumento é unha
serie, cada valor y_t da serie que se devolve, obtense de entre todos os
valores de x_t que teñen a mesma probabilidade. Cando o argumento é unha
matriz, cada fila da matriz que se devolve, obtense das filas de x que
teñen a mesma probabilidade.

O argumento blocksize (opcional) representa o tamaño do bloque para facer a
mostraxe por repetición movendo bloques. Cando se indica este argumento,
deberá de ser un enteiro positivo maior ou igual a 2. Como consecuencia, o
resultado vaise compoñer por selección aleatoria con substitución, de
entre todas as posibles secuencias contiguas de lonxitude blocksize do
argumento. (No caso de que o argumento sexa unha matriz, isto significa
filas contiguas.) Se a lonxitude dos datos non é un número enteiro que
sexa múltiplo do tamaño do bloque, o derradeiro bloque seleccionado
trúncase para que se axuste.

Cando o argumento x é unha serie e o conxunto de datos ten un formato de
panel, non se admite facer a mostraxe por repetición movendo bloques. A
forma básica de facer este tipo de mostraxe está admitida, pero ten a súa
propia interpretación: faise a mostraxe por repetición dos datos "por
individuo". Supón que tes un panel no que se observan 100 individuos ao
longo de 5 períodos. Entón, a serie que se devolve tamén vai estar
composta por 100 bloques de 5 observacións: cada bloque vai obterse con
igual probabilidade das 100 series temporais individuais, conservándose a
orde das series temporais.

# round
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado, do tipo do argumento, que o arredonda ao enteiro máis
próximo. Ten en conta que se x está xusto entre dous enteiros, o
arredondamento faise "afastándose de cero" de modo que, por exemplo, 2.5
arredóndase a 3, pero round(-3.5) devolve -4. Esta convención é común en
software de follas de cálculo, mais outro tipo de software pode xerar
resultados diferentes. Mira tamén "ceil", "floor", "int".

# rownames
Resultado:     enteiro
Argumentos:  M (matriz)
            S (arranxo de cadeas ou lista)

Permite engadir nomes ás filas dunha matriz M de orde m x n. Cando o
argumento S se refire a unha lista, os nomes tómanse das series da lista
(que deberá de ter m elementos). Cando S é un arranxo de cadeas de texto,
deberá de ter m compoñentes. Para manter a compatibilidade con versións
anteriores de Gretl, tamén podes utilizar unha única cadea de texto como
segundo argumento; neste caso esta deberá de ter m subcadeas de texto
separadas por espazos.

Devolve o valor enteiro 0 se as filas se nomean con éxito, e un valor non
nulo en caso de fallo. Consulta tamén "colnames".

Exemplo:

	  matrix M = {1, 2; 2, 1; 4, 1}
	  strings S = array(3)
	  S[1] = "Fila1"
	  S[2] = "Fila2"
	  S[3] = "Fila3"
	  rownames(M, S)
	  print M

# rows
Resultado:     enteiro
Argumento:   X (matriz)

Devolve un enteiro co número de filas da matriz X. Mira tamén "cols",
"mshape", "unvech", "vec", "vech".

# sd
Resultado:     escalar ou serie
Argumento:   x (serie ou lista)

Se x é unha serie, a función devolve un escalar coa desviación padrón na
mostra, descartando as observacións ausentes.

Se x é unha lista, a función devolve unha serie y tal que y_t representa a
desviación padrón na mostra dos valores das variables da lista, na
observación t; ou NA se existe algún valor ausente para a observación t.

Mira tamén "var".

# sdc
Resultado:     vector fila
Argumentos:  X (matriz)
            df (escalar, opcional)

Devolve un vector fila coas desviacións padrón das columnas da matriz X.
Se df é positivo, utilízase como divisor para as varianzas das columnas,
noutro caso o divisor é igual ao número de filas que ten X (é dicir, nese
caso non se aplica a corrección polos graos de liberdade). Mira tamén
"meanc", "sumc".

# sdiff
Resultado:     mesmo tipo que o introducido
Argumento:   y (serie ou lista)

Devolve un resultado co cálculo das diferenzas estacionais: y(t) - y(t-k),
onde k indica a periodicidade do conxunto actual de datos (consulta "$pd").
Os valores iniciais defínense como NA.

Cando se devolve unha lista, cada variable individual desta noméase de
forma automática seguindo o padrón sd_varname, onde varname indica o nome
da serie orixinal. A parte orixinal do nome vai tronzarse cando así resulte
necesario, e mesmo poderá axustarse para garantir que sexa único dentro do
conxunto de nomes que así se vaian construír.

Mira tamén "diff", "ldiff".

# seasonals
Resultado:     lista
Argumentos:  baseline (enteiro, opcional)
            center (booleano, opcional)

Aplícase tan só se o conxunto de datos actual ten unha estrutura de series
temporais con periodicidade maior ca 1. Devolve unha lista con variables
ficticias que representan cada período ou estación, e que se nomean como
S1, S2, etc.

Utiliza o argumento baseline (opcional) para excluír da lista á variable
ficticia que representa un dos períodos. Por exemplo, se lle asignas un
valor igual a 1 tendo un conxunto de datos trimestrais, obtés unha lista
que só ten as variables ficticias dos trimestres 2, 3 e 4. Se omites este
argumento ou é igual a 0, xéranse variables ficticias para todos os
períodos; e se non é cero, deberá ser un enteiro comprendido entre 1 e a
periodicidade dos datos.

O argumento center, se non é nulo, indica que as variables ficticias van
centrarse; é dicir, os seus valores van calcularse restándolle as medias
na poboación. Por exemplo, con datos trimestrais, as variables ficticias
estacionais centradas van ter valores iguais a -0.25 e 0.75 en vez de 0 e 1.

# selifc
Resultado:     matriz
Argumentos:  A (matriz)
            b (vector fila)

Devolve unha matriz tras seleccionar só aquelas columnas de A nas que o
elemento correspondente de b non é nulo. O b debe ser un vector fila co
mesmo número de columnas que A.

Mira tamén "selifr".

# selifr
Resultado:     matriz
Argumentos:  A (matriz)
            b (vector columna)

Devolve unha matriz tras seleccionar só aquelas filas de A nas que o
elemento correspondente de b non é nulo. O b debe ser un vector columna co
mesmo número de filas que A.

Mira tamén "selifc", "trimr".

# seq
Resultado:     vector fila
Argumentos:  a (escalar)
            b (escalar)
            k (escalar, opcional)

Con só dous argumentos, devolve un vector fila coa secuencia crecente (de 1
en 1) desde a ata b, se o primeiro argumento é menor ca o segundo; ou coa
secuencia decrecente (de 1 en 1) se o primeiro argumento é maior ca o
segundo.

Se indicas o terceiro argumento k (opcional), a función vai devolver un
vector fila coa secuencia iniciada en a e ampliada (ou diminuída no caso
inverso de que a sexa maior ca b), en k unidades a cada paso. A secuencia
remata no maior valor posible que sexa menor ou igual a b (ou no menor valor
posible que sexa maior ou igual a b, no caso inverso). O argumento k debe de
ser positivo.

Mira tamén "ones", "zeros".

# setnote
Resultado:     enteiro
Argumentos:  b (paquete)
            key (cadea)
            note (cadea)

Insire unha nota descritiva para un obxecto que se identifica por key,
dentro dun feixe b. Vaise amosar esa nota cando se utilice a instrución
print co feixe. Esta función devolve un enteiro igual a 0 no caso de
executarse con éxito, e un valor non nulo no caso de fallo (por exemplo, se
non existe ningún obxecto key no feixe b).

# simann
Resultado:     escalar
Argumentos:  &b (referencia a matriz)
            f (chamada a función)
            maxit (enteiro, opcional)

Pon en práctica o recocemento simulado, que pode ser útil para mellorar a
determinación do punto de partida dun problema de optimización numérica.

Indicando o primeiro argumento, establécese o valor inicial dun vector de
parámetros; e indicando o segundo argumento, se especifica unha chamada a
unha función que devolve o valor escalar da función obxectivo a maximizar.
O terceiro argumento (opcional) especifica o número máximo de iteracións
(que por defecto é de 1024). Cando se completa con éxito, a función
simann devolve un escalar co valor final da función obxectivo a maximizar,
e b contén o vector de parámetros asociado.

Para ter máis detalles e un exemplo, consulta o capítulo sobre métodos
numéricos no Guía de usuario de Gretl (Capítulo 33). Mira tamén
"BFGSmax", "NRmax".

# sin
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co seno de x. Mira tamén "cos",
"tan", "atan".

# sinh
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co seno hiperbólico de x.

Mira tamén "asinh", "cosh", "tanh".

# skewness
Resultado:     escalar
Argumento:   x (serie)

Devolve un escalar co valor do coeficiente de asimetría da serie x,
descartando calquera observación ausente.

# sleep
Resultado:     escalar
Argumento:   ns (enteiro)

Esta función non ten ningún uso directo en Econometría, mais pode ser de
utilidade para comprobar métodos de computación en paralelo. Simplemente
provoca que se "durma" a liña de cómputo actual (é dicir, que se pare)
durante ns segundos. Ao "espertar", a función devolve o escalar 0.

# smplspan
Resultado:     escalar
Argumentos:  startobs (cadea)
            endobs (cadea)
            pd (enteiro)

Devolve o número de observacións que hai contando desde startobs ata
endobs (ambas incluídas), para datos de series temporais que teñen unha
frecuencia pd.

Deberías de indicar os dous primeiros argumentos no formato que prefire
Gretl para datos de tipo anual, trimestral ou mensual (por exemplo, 1970,
1970:1 ou 1970:01 para cada unha desas frecuencias, respectivamente) ou como
datas no formato ISO 8601, YYYY-MM-DD.

O argumento pd debe de ser ben 1, 4 ou 12 (datos anuais, trimestrais ou
mensuais), ben unha das frecuencias diarias (5, 6, 7), ou ben 52 (semanal).
Se pd é igual a 1, 4 ou 12, entón as datas ISO 8601 acéptanse para os
dous primeiros argumentos se indican o comezo do período en cuestión. Por
exemplo, 2015-04-01 admítese en troques de 2015:2 para representar o
segundo trimestre de 2015.

Se xa tes un conxunto de datos con frecuencia pd preparado, e cun rango
suficiente de observacións, entón podes imitar doadamente o comportamento
desta función utilizando a función "obsnum". A vantaxe de smplspan
consiste en que podes calcular o número de observacións sen necesidade de
ter preparado un conxunto apropiado de datos (nin ningún conxunto de
datos). Deseguido, un exemplo:

	  scalar T = smplspan("2010-01-01", "2015-12-31", 5)
	  nulldata T
	  setobs 7 2010-01-01

Isto xera

	  ? scalar T = smplspan("2010-01-01", "2015-12-31", 5)
	  Xerouse o escalar T = 1565
	  ? nulldata T
	  Periodicidade: 1, máx. obs: 1565
	  Rango de observacións: 1 ata 1565
	  ? setobs 5 2010-01-01
	  Rango completo de datos: 2010-01-01 - 2015-12-31 (n = 1565)

Despois do anterior, podes ter confianza en que a derradeira observación do
conxunto de datos que se vai xerar por medio de "nulldata" vai ser
2015-12-31. Cae na conta de que o número 1565 sería máis ben complicado
calculalo doutro xeito.

# sort
Resultado:     mesmo tipo que o introducido
Argumento:   x (serie ou vector)

Devolve un resultado do mesmo tipo ca x cos seus valores ordenados de forma
ascendente, descartando as observacións con valores ausentes cando x é
unha serie. Mira tamén "dsort", "values". Para matrices, en especial,
consulta "msortby".

# sortby
Resultado:     serie
Argumentos:  y1 (serie)
            y2 (serie)

Devolve unha serie que contén os elementos de y2 ordenados de acordo cos
valores crecentes do primeiro argumento y1. Mira tamén "sort", "ranking".

# sprintf
Resultado:     cadea
Argumentos:  format (cadea)
            ... (... (Mira máis abaixo))

Devolve unha cadea de texto ("string") que se constrúe representando os
valores dos argumentos (indicados polos puntos de arriba) que acompañan á
instrución, baixo o control do argumento format. Ten a intención de darte
gran flexibilidade para crear cadeas de texto. Utiliza o format para indicar
o xeito preciso no que queres que se presenten os argumentos.

En xeral, o argumento format debe de ser unha expresión que se corresponde
con unha cadea de texto, pero nos máis dos casos só vai ser unha cadea de
texto literal (unha secuencia alfanumérica contornada entre comiñas).
Algunhas secuencias de caracteres de formato teñen un significado especial:
aquelas que comezan co símbolo (%) interprétanse como "comodíns" para os
elementos que contén a lista de argumentos. Amais, caracteres especiais
(por exemplo, o de nova liña) represéntanse por medio dunha combinación
de símbolos que comeza cunha barra diagonal inversa.

Por exemplo, o código de abaixo...

	  scalar x = sqrt(5)
	  string claim = sprintf("sqrt(%d) é (aproximadamente) %6.4f.\n", 5, x)
	  print claim

vai producir...

	  sqrt(5) é (aproximadamente) 2.2361.

onde %d indica que se quere un número enteiro nese preciso lugar da saída
que se vai presentar, dado que esa é a expresión co símbolo "por cento"
que está máis á esquerda, polo que se emparella co primeiro argumento, é
dicir 5. A segunda secuencia especial é %6.4f, e representa un valor con 4
díxitos despois do separador decimal e con 6 díxitos de largo como
mínimo. O número desas secuencias debe de coincidir coa cantidade de
argumentos que acompañan á cadea de texto para o formato.

Consulta a páxina de axuda da instrución "printf" para obter máis
detalles en relación coa sintaxe que podes utilizar nas cadeas de texto
para o formato.

# sqrt
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado, do mesmo tipo ca x, coa raíz cadrada positiva deste.
Xera NA para valores negativos deste.

Advirte que, se o argumento é unha matriz, realízase a operación para
cada elemento e, posto que esta non pode conter valores NA, a función xera
un fallo se a matriz ten algún valor negativo. Para a "raíz cadrada
matricial" mira "cholesky".

# square
Resultado:     lista
Argumentos:  L (lista)
            cross-products (booleano, opcional)

Devolve unha lista que contén os cadrados das variables da lista L, cos
seus elementos nomeados de acordo co seguinte padrón :sq_varname. Cando
indicas o segundo argumento (opcional) e ten un valor non nulo, a lista
tamén vai incluír os produtos cruzados dos elementos da lista L, que se
nomearán de acordo co formato do padrón var1_var2. De ser necesario, o
nome das series dos argumentos vai tronzarse e mesmo axustarse o nome do
resultado final, para evitar a duplicación de nomes na lista que se
devolve.

# sscanf
Resultado:     enteiro
Argumentos:  src (cadea)
            format (cadea)
            ... (... (Mira máis abaixo))

Le valores indicados polo argumento src baixo o control do argumento format
e asigna estes valores a un ou máis dos argumentos seguintes, indicados
polos puntos de arriba. Devolve un enteiro co número de valores que se
asignan. Esta función é unha versión simplificada da función sscanf da
linguaxe C de programación.

Como argumento src podes usar unha cadea de texto literal contornada entre
comiñas, ou ben o nome dunha cadea de texto que definiras previamente. O
argumento format indícase de xeito similar á cadea do argumento "format"
en "printf" (mira máis abaixo); nesta última función, args debe ser unha
lista de variables definidas antes, separadas por comas que son os
obxectivos da conversión de src. (Para os afeitos a C: podedes fixar
previamente os nomes das variables numéricas con & pero non se esixe.)

O texto literal no argumento format compárase con src. Os elementos que
especifican a conversión comezan co carácter %, e as conversións que
están admitidas inclúen: %f, %g ou %lf para números de punto flotante; %d
para números enteiros; %s para cadeas de texto; e %m para matrices. Podes
inserir un enteiro positivo despois do símbolo de porcentaxe que establece
o número máximo de caracteres que se van ler para a conversión indicada
(ou o número máximo de filas no caso da conversión dunha matriz). Como
forma alternativa, podes inserir un carácter literal de asterisco, *, logo
do símbolo de porcentaxe para eliminar a conversión (saltándose así
calquera carácter que de outro xeito poderían terse convertido para o tipo
indicado). Por exemplo, a expresión %3d converte os seguintes 3 caracteres
de source nun enteiro, en caso de que sexa posible; e a expresión %*g
permite saltarse tantos caracteres de source como os que poderían
converterse nun número de punto flotante simple.

A conversión para matrices funciona así: o escáner le unha liña do
argumento e conta a cantidade de campos numéricos (separados por espazos ou
por tabulacións). Deste xeito defínese o número de columnas da matriz.
Por defecto, o proceso de lectura continúa entón con tantas liñas (filas)
como conteñan o mesmo número de columnas, pero o número máximo de filas
que se van ler pode limitarse tal como se describe arriba.

Ademais da conversión %s para cadeas de texto, tamén está dispoñible
unha versión simplificada do formato C %N[chars]. Neste formato N
representa o número máximo de caracteres que se van ler e chars expresa un
conxunto de caracteres que sexan admisibles, contornados entre corchetes: o
proceso de lectura remata cando se acada N ou cando se atopa un carácter
que non está en chars. Podes trocar o funcionamento de charsindicando o
circunflexo ^ como primeiro carácter; nese caso, o proceso de lectura
remata cando se atopa un carácter que está indicado no conxunto. (A
diferenza do que acontece en C, o guión non xoga ningún papel especial no
conxunto chars.)

Se a cadea de texto da orixe non coincide (exactamente) co formato, o
número de conversións pode quedarse curta a respecto do número de
argumentos indicados. Isto non é por si mesmo un fallo no que atinxe a
Gretl. Así e todo, poderías querer comprobar o número de conversións que
se completaron; isto indícase no valor que se devolve.

A continuación tes varios exemplos:

	  scalar x
	  scalar y
	  sscanf("123456", "%3d%3d", x, y)

	  sprintf S, "1 2 3 4\n5 6 7 8"
	  S
	  matrix m
	  sscanf(S, "%m", m)
	  print m

# sst
Resultado:     escalar
Argumento:   y (serie)

Devolve un escalar coa suma dos cadrados das desviacións respecto á media,
das observacións non ausentes da serie y. Mira tamén "var".

# stringify
Resultado:     enteiro
Argumentos:  y (serie)
            S (arranxo de cadeas)

Proporciona un xeito de definir valores de cadea de texto para a serie y.
Para que isto funcione, deben de cumprirse dúas condicións: a serie
obxectivo non debe de ter outra cousa que non sexan valores enteiros
positivos (ningún deles menor ca 1), e o arranxo S debe de ter polo menos n
elementos, sendo n o maior valor de y. Amais, cada elemento de S debe de ter
un formato UTF-8 válido. Mira tamén "strvals".

O valor que devolve esta función é cero no caso de completarse con éxito,
ou un código de fallo positivo no caso de fallar.

# strlen
Resultado:     enteiro
Argumento:   s (cadea)

Devolve un número enteiro coa cantidade de caracteres que ten a cadea de
texto s. Ten en conta que iso non é necesariamente igual ao número de
bytes, se algúns caracteres están fóra do intervalo de impresión ASCII.

Exemplo:

        string s = "Regresión"
        scalar number = strlen(s)
        print number

# strncmp
Resultado:     enteiro
Argumentos:  s1 (cadea)
            s2 (cadea)
            n (enteiro, opcional)

Compara as dúas cadeas de texto dos argumentos e devolve un enteiro que é
menor, igual ou maior ca 0 cando s1 é (respectivamente) menor, igual ou
maior que s2, ata os n primeiros caracteres. Cando se omite n, a
comparación continúa ata onde resulte posible.

Cae na conta de que, se só queres comprobar se dúas cadeas de texto son
iguais, podes facelo sen necesidade de utilizar esta función, como coa
indicación if (s1 == s2)....

# strsplit
Resultado:     cadea ou arranxo de cadeas
Argumentos:  s (cadea)
            i (enteiro, opcional)

Sen un segundo argumento, devolve un arranxo de cadeas de texto, e que
resulta ao separar o contido de s conforme aos espazos en branco que ten.

Cando se proporciona un segundo argumento, devolve o elemento i da cadea de
texto s do argumento, numerado considerando os espazos de separación para
elo. O índice i está en base 1 e, indica un fallo cando i sexa menor ca 1.
No caso de que o argumento s non conteña espazos e i sexa igual a 1, a
función devolve unha copia completa da cadea de texto do argumento; pola
contra, se i excede o número de elementos separados por espazos, devólvese
unha cadea de texto baleira.

Exemplos:

        string Cesta = "Plátano Mazá Yaca Laranxa"

        strings Froitas = strsplit(Cesta)
        eval Froitas[1]
        eval Froitas[2]
        eval Froitas[3]
        eval Froitas[4]

        string Preferida = strsplit(Cesta, 3)
        eval Preferida

# strstr
Resultado:     cadea
Argumentos:  s1 (cadea)
            s2 (cadea)

Procura en s1 a cadea s2. No caso de atopar a cadea de texto, devolve outra
cadea cunha copia da parte de s1 que comeza con s2; noutro caso, devolve
unha cadea de texto baleira.

Exemplo:

        string s1 = "Gretl é un programa de Econometría"
        string s2 = strstr(s1, "un")
        print s2

# strstrip
Resultado:     cadea
Argumento:   s (cadea)

Devolve unha cadea de texto cunha copia de s na que se eliminaron os espazos
en branco do inicio e do final.

Exemplo:

        string s1 = "    Moito espazo en branco.  "
        string s2 = strstrip(s1)
        print s1 s2

# strsub
Resultado:     cadea
Argumentos:  s (cadea)
            find (cadea)
            subst (cadea)

Devolve unha cadea de texto cunha copia de s na que se substituíu toda a
cadea find por subst. Consulta tamén "regsub" para outras substitucións
máis complexas mediante expresións regulares.

Exemplo:

        string s1 =  "Hola, Gretl!"
        string s2 = strsub(s1, "Gretl", "Hansl")
        print s2

# strvals
Resultado:     arranxo de cadeas
Argumento:   y (serie)

Cando a serie y se compón de cadeas de texto que expresan valores, esta
función devolve un arranxo que contén todos eses valores, ordenados
numericamente comezando polo 1. Cando y non se compón de cadeas de texto
que expresan valores, devólvese un arranxo de cadeas de texto baleiras.
Mira tamén "stringify".

# substr
Resultado:     cadea
Argumentos:  s (cadea)
            start (enteiro)
            end (enteiro)

Devolve unha subcadea do argumento s, comezando no carácter indicado polo
enteiro positivo de inicio e rematando no indicado por fin, ambos
incluídos.

Por exemplo, o código de abaixo

        string s1 = "Hola, Gretl!"
        string s2 = substr(s1, 7, 11)
        string s3 = substr("Hola, Gretl!", 7, 11)
        print s2
        print s3

proporciona:

      ? print s2
      Gretl
      ? print s3
      Gretl

Debes de darte de conta de que, nalgúns casos, poderías estar desexando
intercambiar claridade por concisión, e utilizar operadores de redución e
incremento, como en

        string s1 = "Hola, Gretl!"
        string s2 = s1[7:11]
        string s3 = s1 + 6
        print s2
        print s3

o que te proporcionaría

      ? print s2
      Gretl
      ? print s3
      Gretl!

# sum
Resultado:     escalar ou serie
Argumento:   x (serie, matriz ou lista)

Cando x é unha serie, devolve un escalar co resultado de sumar as
observacións non ausentes do argumento x. Consulta tamén "sumall".

Cando x é unha matriz, devolve un escalar co resultado de sumar os
elementos da matriz.

Cando x é unha lista de variables, a función devolve unha serie y na que
cada valor y_t indica a suma dos valores das variables da lista na
observación t, ou NA se algún deses valores está ausente en t.

# sumall
Resultado:     escalar
Argumento:   x (serie)

Devolve un escalar co resultado de sumar as observacións da serie x na
mostra seleccionada, ou NA se existe algún valor ausente. Utiliza "sum" se
queres obter a suma descartando os valores ausentes.

# sumc
Resultado:     vector fila
Argumento:   X (matriz)

Devolve un vector fila coa suma das columnas de X. Mira tamén "meanc",
"sumr".

# sumr
Resultado:     vector columna
Argumento:   X (matriz)

Devolve un vector columna coa suma das filas de X. Mira tamén "meanr",
"sumc".

# svd
Resultado:     vector fila
Argumentos:  X (matriz)
            &U (referencia a matriz, ou null)
            &V (referencia a matriz, ou null)

Devolve un vector fila co resultado de descompoñer a matriz X en valores
singulares.

Os valores singulares devólvense nun vector fila. Podes obter o vector
singular esquerdo U e/ou dereito V indicando valores non nulos nos
argumentos 2 e 3, respectivamente. Para calquera matriz A, o código...

	  s = svd(A, &U, &V)
	  B = (U .* s) * V

... debera proporcionar unha matriz B idéntica a A (agás pequenas
diferenzas debida á precisión de cálculo).

Mira tamén "eigengen", "eigensym", "qrdecomp".

# tan
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) coa tanxente de x. Mira tamén
"atan", "cos", "sin".

# tanh
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) coa tanxente hiperbólica de x.

Mira tamén "atanh", "cosh", "sinh".

# toepsolv
Resultado:     vector columna
Argumentos:  c (vector)
            r (vector)
            b (vector)

Devolve un vector columna coa solución dun sistema Toeplitz de ecuacións
lineais, é dicir Tx = b onde T é unha matriz cadrada cuxo elemento T_i,j
é igual a c_i-j cando i>=j, e igual a r_j-i cando i<=j. Ten en conta que os
primeiros elementos dos dous vectores c e r deben de ser iguais, pois noutro
caso se devolve un fallo. Cando se completa con éxito, a execución desta
función permite obter o vector x.

O algoritmo que se utiliza aquí aproveita a especial estrutura da matriz T,
que o fai moito máis eficiente ca outros algoritmos non especializados,
particularmente para problemas moi longos. Advertencia: Nalgúns casos a
función podería suxerir falsamente un fallo na singularidade da matriz T
cando realmente non é singular; de calquera xeito, este problema non
poderá xurdir cando a matriz T sexa definida positiva.

# tolower
Resultado:     cadea
Argumento:   s (cadea)

Devolve unha cadea de texto que é unha copia de s, na que todas as letras
en maiúsculas convertéronse en minúsculas.

Exemplos:

        string s1 = "Hola, Gretl!"
        string s2 = tolower(s1)
        print s2

        string s3 = tolower("Hola, Gretl!")
        print s3

# toupper
Resultado:     cadea
Argumento:   s (cadea)

Devolve unha cadea de texto que é unha copia de s, na que todas as letras
en minúsculas convertéronse en maiúsculas.

Exemplos:

        string s1 = "Hola, Gretl!"
        string s2 = toupper(s1)
        print s2

        string s3 = toupper("Hola, Gretl!")
        print s3

# tr
Resultado:     escalar
Argumento:   A (matriz cadrada)

Devolve un escalar coa traza dunha matriz cadrada A, é dicir, a suma dos
elementos da súa diagonal. Mira tamén "diag".

# transp
Resultado:     matriz
Argumento:   X (matriz)

Devolve unha matriz que é a trasposta de X. Aviso: Esta función utilízase
raramente. Para traspor unha matriz, en xeral podes usar simplemente o
operador para trasposición: X'.

# trimr
Resultado:     matriz
Argumentos:  X (matriz)
            ttop (enteiro)
            tbot (enteiro)

Devolve unha matriz que é unha copia da matriz X na que se eliminaron as
ttop filas superiores e as tbot filas inferiores. Os dous últimos
argumentos non deben de ser negativos e a súa suma debe de ser menor ca o
total de filas de X.

Mira tamén "selifr".

# typeof
Resultado:     enteiro
Argumento:   name (cadea)

Devolve un código de tipo numérico cando name é unha cadea de texto que
identifica un obxecto actualmente definido: 1 para un escalar, 2 para unha
serie, 3 para unha matriz, 4 para unha cadea de texto, 5 para un feixe, 6
para un arranxo e 7 para unha lista; noutro caso devolve 0. Para obter a
cadea de texto que concorda co valor que se devolve, podes usar a función
"typestr".

Tamén podes utilizar esta función para obter que tipo de elemento é un
compoñente dun feixe ou dun arranxo. Por exemplo...

	  matrices M = array(1)
	  eval typestr(typeof(M))
	  eval typestr(typeof(M[1]))

... no que o primeiro resultado da función eval é un "arranxo" e o segundo
é unha "matriz".

# typestr
Resultado:     cadea
Argumento:   typecode (enteiro)

Devolve unha cadea de texto co nome do tipo de dato de Gretl que se
corresponde co argumento typecode. Podes utilizalo xuntamente coas funcións
"typeof" e "inbundle". O cadea de texto que se devolve pode ser unha das
seguintes: "scalar", "series", "matrix", "string", "bundle", "array",
"list", ou "null".

# uniform
Resultado:     serie
Argumentos:  a (escalar)
            b (escalar)

Devolve unha serie que se xera cunha variable pseudoaleatoria uniforme que
toma valores dentro do intervalo ( a, b) ou, se non indicas eses argumentos,
no intervalo (0,1). O algoritmo que se utiliza por defecto é o
"SIMD-oriented Fast Mersenne Twister" desenvolvido por Saito e Matsumoto
(2008).

Mira tamén "randgen", "normal", "mnormal", "muniform".

# uniq
Resultado:     vector columna
Argumento:   x (serie ou vector)

Devolve un vector que contén os distintos elementos do argumento x sen
ningunha orde especial, senón na que están en x. Consulta "values" para a
variante desta función que devolve os valores ordenados.

# unvech
Resultado:     matriz cadrada
Argumento:   v (vector)

Devolve a matriz simétrica de orde n x n que se obtén reordenando os
elementos do vector v en forma de matriz triangular inferior, e copiando os
das posicións simétricas. O número de elementos de v debe de ser un
enteiro triangular, ou sexa, un número k tal que exista un enteiro n que
teña a seguinte propiedade: k = n(n+1)/2. Esta función é a inversa de
"vech".

Mira tamén "mshape", "vech".

# upper
Resultado:     matriz cadrada
Argumento:   A (matriz cadrada)

Devolve unha matriz triangular superior de orde n x n. Os elementos da
diagonal e de arriba desta, son iguais aos elementos que se corresponden en
A; os demais son iguais a cero.

Mira tamén "lower".

# urcpval
Resultado:     escalar
Argumentos:  tau (escalar)
            n (enteiro)
            niv (enteiro)
            itv (enteiro)

Devolve un escalar coa probabilidade asociada (P) ao valor do estatístico
para facer a proba de raíces unitarias de Dickey-Fuller ou a proba de
cointegración de Engle-Granger, conforme James MacKinnon (1996).

Os argumentos exprésanse deste xeito: tau indica o valor do estatístico de
proba que corresponda; n sinala o número de observacións (ou 0 se o que
queres é un resultado asintótico);niv denota o número de variables
potencialmente cointegradas, se comprobas a cointegración (ou 1 se fas unha
proba univariante de raíces unitarias); e itv é un código que especifica
o tipo modelo (1 = sen constante, 2 = con constante, 3 = con constante máis
tendencia linear, 4 = con constante máis tendencia linear e cadrada).

Ten en conta que debes de darlle un valor de 0 a n para obter un resultado
asintótico, se a regresión auxiliar para a proba é "ampliada" con
retardos na variable dependente.

Mira tamén "pvalue", "qlrpval".

# values
Resultado:     vector columna
Argumento:   x (serie ou vector)

Devolve un vector que contén os distintos elementos do argumento x
ordenados de forma ascendente. Se queres descartar a parte decimal antes de
aplicar esta función, utiliza a expresión values(int(x)).

Mira tamén "uniq", "dsort", "sort".

# var
Resultado:     escalar ou serie
Argumento:   x (serie ou lista)

Cando x é unha serie, devolve un escalar coa súa varianza na mostra,
descartando calquera observación ausente.

Cando x é unha lista, devolve unha serie y na que cada valor y_t indica a
varianza na mostra dos valores das variables da lista na observación t, ou
NA se algún deses valores está ausente en t.

En cada un deses casos, a suma dos cadrados das desviacións con respecto á
media divídese por (n - 1) cando n > 1. Noutro caso, indícase que a
varianza é igual a cero se n = 1, ou é igual a NA se n = 0.

Mira tamén "sd".

# varname
Resultado:     cadea
Argumento:   v (enteiro ou lista)

Cando se indica un número enteiro como argumento, a función devolve unha
cadea de texto co nome da variable que ten un número ID igual a v, ou xera
un fallo se esa variable non existe.

Cando se indica unha lista como argumento, devolve unha cadea de texto que
contén os nomes das variables da lista, separados por comas. Se indicas
unha lista que está baleira, devólvese unha cadea de texto baleira. En
troques, podes utilizar "varnames" para obter un arranxo de cadeas de texto
.

Exemplo:

        open broiler.gdt
        string s = varname(7)
        print s

# varnames
Resultado:     arranxo de cadeas
Argumento:   L (lista)

Devolve un arranxo de cadeas de texto que contén os nomes das variables da
lista L. Se a lista que indicas está baleira, devólvese un arranxo
baleiro.

Exemplo:

        open keane.gdt
        list L = year wage status
        strings S = varnames(L)
        eval S[1]
        eval S[2]
        eval S[3]

# varnum
Resultado:     enteiro
Argumento:   varname (cadea)

Devolve un número enteiro co código ID da variable que ten o nome do
argumento varname, ou NA se esa variable non existe.

# varsimul
Resultado:     matriz
Argumentos:  A (matriz)
            U (matriz)
            y0 (matriz)

Devolve unha matriz ao simular un VAR de orde p e n variables, é dicir y(t)
= A1 y(t-1) + ... + Ap y(t-p) + u(t). A matriz A de coeficientes fórmase
agrupando horizontalmente as matrices A_i; é de orde n x np, con unha fila
por cada ecuación. Esta se corresponde coas primeiras n filas da matriz
$compan que proporcionan as instrucións var e vecm de Gretl.

Os vectores u_t están incluídos (como filas) na matriz U (T x n). Os
valores iniciais están en y0 (p x n).

Cando o VAR contén algún termo determinista e/ou regresores esóxenos,
podes manexalos envolvéndoos na matriz U: neste caso cada fila de U pasa a
ser entón u(t) = B'x(t) + e(t).

A matriz que resulta ten T + p filas e n columnas; contén os p valores
iniciais das variables endóxenas, ademais de T valores simulados.

Mira tamén "$compan", "var", "vecm".

# vec
Resultado:     vector columna
Argumento:   X (matriz)

Devolve un vector columna, encastelando as columnas de X. Mira tamén
"mshape", "unvech", "vech".

# vech
Resultado:     vector columna
Argumento:   A (matriz cadrada)

Devolve nun vector columna cos elementos de A que están na súa diagonal e
enriba dela. Normalmente esa función utilízase con matrices simétricas;
neste caso esa operación pode reverterse a través da función "unvech".
Mira tamén "vec".

# weekday
Resultado:     mesmo tipo que o introducido
Argumentos:  year (escalar ou serie)
            month (escalar ou serie)
            day (escalar ou serie)

Devolve o día da semana (domingo = 0, luns = 1, etc.) da data especificada
polos tres argumentos, ou NA se a data non é correcta. Ten en conta que os
tres argumentos deben de ser do mesmo tipo; ou sexa, deben de ser todos de
tipo escalar (enteiro) ou todos de tipo serie.

# wmean
Resultado:     serie
Argumentos:  Y (lista)
            W (lista)

Devolve unha serie y calculada de forma que cada y_t indica a media
ponderada dos valores (na observación t) das variables presentes na lista
Y, coas respectivas ponderacións sinaladas polos valores das variables que
forman a lista W en cada t. As ponderacións poden así variar no tempo. As
listas de variables Y e W deben de ter o mesmo tamaño, e as ponderacións
deben de ser non negativas.

Mira tamén "wsd", "wvar".

# wsd
Resultado:     serie
Argumentos:  Y (lista)
            W (lista)

Devolve unha serie y calculada de forma que cada y_t indica a desviación
padrón ponderada na mostra, dos valores (na observación t) das variables
presentes na lista Y, coas respectivas ponderacións sinaladas polos valores
das variables da lista W en cada t. As ponderacións poden así variar no
tempo. As listas de variables Y e W deben de ter o mesmo tamaño, e as
ponderacións deben de ser non negativas.

Mira tamén "wmean", "wvar".

# wvar
Resultado:     serie
Argumentos:  X (lista)
            W (lista)

Devolve unha serie y calculada de forma que cada y_t indica a varianza
ponderada na mostra, dos valores (na observación t) das variables presentes
na lista Y, coas respectivas ponderacións sinaladas polos valores das
variables que forman a lista W en cada t. As ponderacións poden así variar
no tempo. As listas de variables Y e W deben de ter o mesmo tamaño, e as
ponderacións deben de ser non negativas.

Mira tamén "wmean", "wsd".

# xmax
Resultado:     escalar
Argumentos:  x (escalar)
            y (escalar)

Devolve un escalar co maior valor que resulta de comparar x e y. Se algún
dos valores está ausente, devólvese NA.

Mira tamén "xmin", "max", "min".

# xmin
Resultado:     escalar
Argumentos:  x (escalar)
            y (escalar)

Devolve un escalar co menor valor que resulta de comparar x e y. Se algún
dos valores está ausente, devólvese NA.

Mira tamén "xmax", "max", "min".

# xmlget
Resultado:     cadea
Argumentos:  buf (cadea)
            path (cadea ou arranxo de cadeas)

O argumento buf debe de ser un búfer XML, tal como pode recuperarse dun
lugar web adecuado mediante a función "curl" (or lerse dun ficheiro
mediante a función "readfile"), e o argumento path debe de ser ben unha
especificación XPath sinxela ou un arranxo delas.

Esta función devolve unha cadea de texto que representa os datos atopados
no búfer XML na ruta especificada. Se hai múltiples nodos que coincidan
coa expresión da ruta, as unidades de datos se presentan unha por cada
liña da cadea que se devolve. Cando indicas un arranxo de rutas como
segundo argumento, a cadea que se devolve ten a forma dun búfer separado
con comas, cuxa columna i contén as coincidencias da ruta i. Neste caso, se
unha cadea obtida do búfer XML contén algún espazo ou coma, contórnase
entre comiñas.

Podes atopar unha boa introdución ao uso e á sintaxe de XPath en
https://www.w3schools.com/xml/xml_xpath.asp. O programa de soporte
(back-end) para xmlget o proporciona o módulo xpath de libxml2, que admite
XPath 1.0 pero non XPath 2.0.

Mira tamén "jsonget", "readfile".

# zeromiss
Resultado:     mesmo tipo que o introducido
Argumento:   x (escalar ou serie)

Devolve un resultado (do tipo do argumento) trocando os ceros en NAs. Se x
é unha serie, troca cada elemento. Mira tamén "missing", "misszero", "ok".

# zeros
Resultado:     matriz
Argumentos:  r (enteiro)
            c (enteiro)

Devolve unha matriz nula con r filas e c columnas. Mira tamén "ones",
"seq".