File: gretl_cli_fnref.gl

package info (click to toggle)
gretl 2022c-1
links: PTS, VCS
area: main
in suites: bookworm
size: 59,552 kB
sloc: ansic: 409,074; sh: 4,449; makefile: 3,222; cpp: 2,777; xml: 599; perl: 364
file content (8582 lines) | stat: -rw-r--r-- 329,957 bytes
## 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 Manual de usuario de Gretl (Capítulo 28).

# $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 Manual de usuario de Gretl (Capítulo 28).

# $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:   nome (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 de executarse tras estimar un modelo, e devolve a cadea cos caracteres
da instrución utilizada (exemplo: ols ou probit).

# $compan
Resultado:     matriz

Debe de 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 nese momento: 0 = sen datos; 1 = datos de corte transversal; 2 =
datos de series temporais; 3 = datos de panel.

# $depvar
Resultado:     cadea

Debe de 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 consiste nun 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 de 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 de 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 das perturbacións 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
Manual de usuario de Gretl (Capítulo 34) (tamén "$diagpval").

# $dotdir
Resultado:     cadea

Este accesorio devolve unha cadea de texto coa ruta onde GRETL garda
ficheiros temporalmente, por exemplo cando usa a función "mwrite" cun
terceiro argumento distinto de cero.

# $dw
Resultado:     escalar

Devolve (se é posible) un escalar co valor do estatístico de Durbin-Watson
para probar autocorrelación de primeiro nivel no derradeiro modelo
estimado.

# $dwpval
Resultado:     escalar

Se pode calcularse, devolve un escalar co valor da función de distribución
acumulada (CDF) de Durbin-Watson, avaliada no valor do estatístico de DW
para o derradeiro modelo estimado; para isto úsase o procedemento de
cálculo Imhof. Este é o valor p (probabilidade asociada) para unha proba
dunha cola na que a hipótese alternativa é que existe autocorrelación
positiva de primeiro nivel. Se queres o valor p para unha proba de dúas
colas, colle 2P cando DW < 2, ou 2(1 - P) cando DW > 2, onde P é o valor
que devolve este accesorio.

Debido á limitada precisión da aritmética dixital, 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
sexa 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 de 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 que, 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 de 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 de 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 de 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 de 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.

Para unha variante máis flexible desta funcionalidade, consulta a función
"fevd".

# $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 de 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 de executarse logo da instrución garch, e devolve unha serie coas
varianzas condicionais estimadas.

# $hausman
Resultado:     vector fila

Debe de 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 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 Manual de usuario de Gretl (Capítulo 28).

# $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 de 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 de 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 de 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 guión baixo 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 vixente, 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.

# $mapfile
Resultado:     cadea

Devolve unha cadea de texto co nome do ficheiro que se debe abrir para obter
os polígonos do mapa, cando antes se cargaron datos dun ficheiro GeoJSON ou
dun ficheiro ESRI de forma; noutro caso, devolve unha cadea baleira. Isto
está deseñado para utilizarse coa función "geoplot".

# $mnlprobs
Resultado:     matriz

Debe de 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:     feixe

Debe de 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, sen
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

# $mpirank
Resultado:     enteiro

Cando se prepara GRETL con soporte MPI, e o programa está funcionando en
modo MPI, devolve a "xerarquía" en base 0 ou número ID do proceso vixente.
Doutro xeito, devolve -1.

# $mpisize
Resultado:     enteiro

Cando se prepara GRETL con soporte MPI, e o programa está funcionando en
modo MPI, devolve o número de procesos MPI que están funcionando nese
momento. Doutro xeito, devolve 0.

# $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 vixente. Relacionado: "$tmax".

No caso de datos de panel, o valor que se devolve é o número de
observacións combinadas (o número de unidades de sección cruzada
multiplicado polo número de períodos de tempo). Se queres saber o número
de unidades tempo dun panel, utiliza "$pd". E o número de unidades de
sección cruzada incluídas pode obterse mediante $nobs dividido por $pd.

# $now
Resultado:     vector

Devolve un vector con 2 elementos: o primeiro indica o número de segundos
transcorridos dende o 01-01-1970 00:00:00 +0000 (UTC, ou Tempo Universal
Coordinado), o que se utiliza amplamente no mundo da informática para
representar o tempo vixente; e o segundo indica a data vixente en formato
"básico" ISO 8601, YYYYMMDD. Podes utilizar a función "strftime" para
procesar o primeiro elemento, e a función "epochday" para procesar o
segundo elemento.

# $nvars
Resultado:     enteiro

Devolve un número enteiro co número de series incluídas no conxunto
vixente de datos (contando coa constante). Posto que const está sempre
presente en calquera conxunto de datos, a obtención do valor 0 indica que
non hai conxunto de datos. Cae na conta de que ao usar este accesorio dentro
dunha función, o número vixente de series accesibles ben pode caer por
debaixo do indicado por $nvars.

# $obsdate
Resultado:     serie

Pode executarse cando o conxunto vixente de datos 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

Devolve unha serie que contén a compoñente maior (de menor frecuencia) de
cada observación. Isto quere dicir o ano para series de tempo anuais,
trimestrais, mensuais, semanais ou diarias; o día para datos horarios; ou o
individuo no caso dos datos de panel. Se os datos son de sección cruzada, a
serie que se devolve é simplemente o índice enteiro das observacións.

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

# $obsmicro
Resultado:     serie

Pode executarse cando as observacións do conxunto de vixente datos 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 vixente de datos 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".

# $panelpd
Resultado:     enteiro

Específico para datos de panel, devolve un enteiro coa periodicidade
temporal (por exemplo: 4 para datos trimestrais). Cando non estableces a
periodicidade no conxunto de datos de panel activo, devolve 1 de xeito
similar a "$pd" para datos de tipo atemporal ou sen data. Se o conxunto de
datos non é de panel, devólvese NA.

Mira tamén "$pd", "$datatype", "setobs".

# $parnames
Resultado:     arranxo de cadeas

Logo da estimación dun modelo uniecuacional, devolve un arranxo de cadeas
de texto que conteñen os nomes dos parámetros do modelo. O número de
nomes coincide co número de elementos que ten o vector "$coeff".

Para os modelos especificados mediante unha lista de regresores, o resultado
vai ser o mesmo que o de

	  varnames($xlist)

(consulta a función"varnames") pero a función $parnames é máis xeral;
pois tamén funciona para os modelos que non teñen unha lista de regresores
("nls", "mle", "gmm").

# $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.

Mira tamén "$panelpd".

# $pi
Resultado:     escalar

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

# $pkgdir
Resultado:     cadea

Utilidade especial para que utilicen os autores de paquetes de función.
Devolve unha cadea de texto baleira agás que se estea executando unha
función empaquetada, en cuxo caso devolve a ruta completa (dependendo da
plataforma) a onde está instalado o paquete. Por exemplo, o valor devolto
podería ser...

	  /usr/share/gretl/functions/foo

no caso de que este sexa o cartafol no que estea localizado foo.gfn. Isto
permite que o autor dun paquete de función poda acceder a recursos tales
como ficheiros de matrices, que teña incluídos no seu paquete.

# $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 Manual de usuario de Gretl (Capítulo 10) 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 de executarse logo da instrución "qlrtest" (que permite facer a proba
QLR para o cambio 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.

# $result
Resultado:     matriz ou feixe

Proporciona información reservada, a continuación dalgunhas instrucións
que non teñen accesorios específicos. As instrucións en cuestión
inclúen "bds", "bkw" "corr", "fractint", "freq", "hurst", "leverage",
"summary", "vif" e "xtab" (en cuxos casos, o resultado é unha matriz),
ademais de "pkg" (en cuxo caso, gárdase opcionalmente un feixe).

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

Sen argumentos, este accesorio devolve o coeficiente de autocorrelación de
primeiro nivel 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 o 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 de 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
vixente non utilizadas na estimación (posiblemente debido a valores
ausentes), e NA nas observacións fóra da mostra vixente seleccionada.

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
	  series sdum = $sample
	  smpl sdum --dummy

# $sargan
Resultado:     vector fila

Debe de 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.

# $seed
Resultado:     escalar

Devolve un escalar co valor da semente do xerador de números aleatorios de
GRETL. Se estableces a semente por ti mesmo, non tes necesidade deste
accesorio; pero pode resultar interesante cando a semente se establece
automaticamente (baseándose no momento no que comezou a execución do
programa).

# $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:   nome (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 de 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 indicativo dos
segundos de CPU dende o acceso previo.

Cando unha función definida polo usuario está en execución, ao usar a
instrución set stopwatch e o accesorio $stopwatch, estes resultan
específicos para esa función -- é dicir, a medición do tempo dentro
dunha función non interrompe calquera medición "global" que poda estarse
facendo nun guión principal.

# $sysA
Resultado:     matriz

Debe de 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 de 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 de 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 do sistema. Consulta a instrución
"system".

# $sysinfo
Resultado:     feixe

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 (Interface de Paso
  de Mensaxes), e 0 noutro caso.

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

  ncores: número enteiro que indica o número de núcleos físicos de
  procesador dispoñibles.

  nproc: número enteiro que indica o número de procesadores dispoñibles,
  e que será maior que ncores se está habilitado o Hyper-threading.

  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 á suma do número de
  procesadores ou "slots" ao longo de todas as 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, macos,
  windows ou outro. Cae na conta de que as versións de GRETL previas á
  '2021e' proporcionan a cadea osx para o sistema operativo de Mac; polo
  tanto, unha expresión de comprobación para Mac independente da versión
  é instring($sysinfo.os, "os").

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

  mem: un vector bidimensional que contén a memoria física total, e a
  memoria libre ou dispoñible, expresadas en MB. Esta información pode que
  non estea dispoñible en todos os sistemas, pero debera estalo en Windows,
  macOS e Linux.

  foreign: un sub-feixe que contén indicadores 0/1 para amosar a presencia
  no sistema, de cada un dos programas "externos" que admite GRETL baixo as
  claves julia, octave, ox, python, Rbin, Rlib e stata. As dúas claves que
  corresponden a R representan respectivamente, o executable de R e a
  biblioteca compartida.

Fíxate en que podes acceder a elementos individuais do feixe mediante a
notación do "punto", 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

# $system
Resultado:     feixe

Debe de seguir á estimación dun sistema de ecuacións, feita coa
instrución "system", con "var" ou con "vecm"; e devolve un feixe que
contén moitos apartados de datos que se refiren ao sistema. Inclúense
todos os accesorios importantes e habituais do sistema, que se nomean
mediante símbolos chave que son idénticos aos nomes habituais dos
accesorios, menos o símbolo de dólar inicial. Así, por exemplo, os erros
aparecen baixo a chave uhat e os coeficientes baixo coeff. (Como excepcións
están as chaves A, B, e Gamma, que se corresponden cos accesorios
habituales sysA, sysB, e sysGamma.) As chaves para obter información
adicional agárdase que deberan explicarse suficientemente por si mesmas.
Para comprobar o que tes á túa disposición, podes obter unha copia do
feixe e representar o seu contido, como en

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

Podes pasar un feixe obtido deste xeito como argumento final (opcional) das
funcións "fevd" e "irf".

# $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 vixente seleccionada.

# $t2
Resultado:     enteiro

Devolve un enteiro positivo co número que indexa a derradeira observación
da mostra vixente 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 Manual de usuario de Gretl (Capítulo 10) 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 "$pvalue".

# $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 "$nobs", 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
adiantados 1 paso; logo da estimación dun probit, contén os erros
xeneralizados.

Cando o "modelo" vixente en cuestión é un sistema de ecuacións (un VAR,
un VECM ou un sistema de ecuacións simultáneas), o $uhat 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í de forma sucesiva.

# $vcv
Resultado:     matriz ou escalar
Argumentos:  nome1 (nome de coeficiente, opcional)
            nome2 (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 nome1 e nome2. 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 de 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 de 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 Manual de
usuario de Gretl (Capítulo 32).

# $windows
Resultado:     enteiro

Devolve un número enteiro co valor 1 se GRETL está executándose en
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".

# $workdir
Resultado:     cadea

Este accesorio devolve unha cadea de texto coa ruta desde a que le e na que
escribe GRETL por defecto. Ofrécese unha discusión máis cumprida no
manual de Instrucións, na referencia "workdir". Cae na conta de que o
usuario pode determinar esta cadea por medio da instrución "set".

# $xlist
Resultado:     lista

Se o último modelo estimado era uniecuacional, este accesorio vai devolver
unha lista cos seus regresores. Se o último modelo era un sistema de
ecuacións, devolve unha lista "global" coas variables esóxenas (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), excepción
feita dos termos determinísticos habituais (a constante, a tendencia e os
elementos estacionais).

# $xtxinv
Resultado:     matriz

Debe de executarse unicamente logo da estimación dun VAR ou VECM, e devolve
a matriz X'X^-1, onde X é a matriz habitual cos regresores utilizados en
cada ecuación. Pese a que este accesorio está dispoñible para un VECM
estimado con unha restrición imposta en α (a matriz de "cargas"), debe de
terse en conta que nese caso non todos os coeficientes dos regresores
varían libremente.

# $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.

## Built-in strings
# $dotdir
Resultado:     cadea

Proporciona unha cadea de texto coa ruta completa ao directorio que usa
GRETL para os ficheiros temporais. Para usala en modo de substitución para
cadeas de texto, antepón o símbolo arroba (@dotdir).

# $gnuplot
Resultado:     cadea

Proporciona unha cadea de texto coa ruta ata o executable 'gnuplot'. Para
usala en modo de substitución para cadeas, antepón o símbolo arroba
(@gnuplot).

# $gretldir
Resultado:     cadea

Proporciona unha cadea de texto coa ruta completa ao directorio de
instalación de GRETL. Para usala en modo de substitución para cadeas de
texto, antepón o símbolo arroba (@gretldir).

# $tramo
Resultado:     cadea

Proporciona unha cadea de texto coa ruta ata o executable 'tramo'. Para
usala en modo de substitución para cadeas, antepón o símbolo arroba
(@tramo).

# $tramodir
Resultado:     cadea

Proporciona unha cadea de texto coa ruta ata o directorio de datos de
'tramo'. Para usala en modo de substitución para cadeas, antepón o
símbolo arroba (@tramodir).

# $x12a
Resultado:     cadea

Proporciona unha cadea de texto coa ruta ata o executable 'x-12-arima'. Para
usala en modo de substitución para cadeas, antepón o símbolo arroba
(@x12a).

# $x12adir
Resultado:     cadea

Proporciona unha cadea de texto coa ruta ata o directorio de datos de
'x-12-arima'. Para usala en modo de substitución para cadeas, antepón o
símbolo arroba (@x12adir).

## 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 de
x; é dicir, proporciona o arco cuxo coseno é x (o argumento debe de 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 de ser maior ca 1, pois pola
contra a función devolverá NA. Mira tamén "cosh".

# aggregate
Resultado:     matriz
Argumentos:  x (serie ou lista)
            segunvar (serie ou lista)
            nomefunc (cadea, opcional)

Na forma máis simple de uso desta función, x establécese igual a null,
segunvar é unha serie individual e o terceiro argumento omítese (ou
establécese igual a cero). Neste caso, devólvese unha matriz con dúas
columnas que contén: os distintos valores de segunvar ordenados de forma
crecente na primeira columna, e o número de observacións nas que segunvar
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).

De xeito máis xeral, se segunvar é 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. Cae na conta de que
podes sempre atopar a columna de reconto na posición nelem(segunvar) + 1.

Especificar unha función de agregación

Cando indicas o terceiro argumento, entón x non debe ser null, e as m
columnas máis á dereita van conter os valores do estatístico especificado
por nomefunc para cada unha das variables en x. (Deste xeito, m iguálase a
1 cando x é unha única serie, e iguálase a nelem(x) cando x é unha
lista.) O estatístico indicado calcúlase nas submostras respectivas que
estean definidas mediante as combinacións indicadas en segunvar (en orde
ascendente); estas combinacións amósanse na(s) primeira(s) n columna(s) da
matriz que se devolve.

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

As seguintes opcións de nomefunc 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 segunvar.

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. Nas dúas
primeiras columnas exprésanse as 6 distintas combinacións dos valores de
'xenero' 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 segunvar é unha lista de variables, algunhas combinacións
dos valores de segunvar 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 (é 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 segunvar, 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
Argumentos:  s (cadea)
            pordefecto (cadea, opcional)

Se s é o nome dun parámetro cara a unha función definida previamente polo
usuario, devolve unha cadea de texto co nome do argumento correspondente (se
este ten un nome a nivel da chamada). Cando o argumento é anónimo,
devólvese unha cadea baleira agás que indiques o argumento opcional
pordefecto, en cuxo caso utilízase o seu valor como alternativa.

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

Esta é a función "xeradora" básica dunha nova variable de tipo arranxo
("array"). Ao usar esta función é necesario que especifiques un tipo (en
forma plural) para o arranxo: strings, matrices, bundles, lists ou arrays.
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 de x;
é dicir, proporciona o arco cuxo seno é x (o argumento debe de 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".

# assert
Resultado:     escalar
Argumento:   expr (escalar)

Esta función está dirixida a comprobar e depurar código HANSL. O seu
argumento deberá ser unha expresión cuxo valor sexa un escalar. O valor
que devolve esta función é ou ben 1 cando o valor do argumento expr non é
cero ("verdadeiro" booleano ou "éxito"), ou ben 0 se o valor do argumento
é cero ("falso" booleano ou "fallo").

Por defecto, non hai outras consecuencias de que falle unha chamada a
assert, máis que o feito de que o valor que se devolve é cero. Porén,
podes utilizar a instrución "set" para facer que o fallo dunha afirmación
teña máis consecuencias. Hai tres niveis:

	  # Amosar unha mensaxe de aviso, mais continuar coa execución
	  set assert warn
	  # Amosar unha mensaxe de aviso e deter a execución dun guión
	  set assert stop
	  # Amosar unha mensaxe a 'stderr' e deter o programa
	  set assert fatal

Na maioría dos casos stop é suficiente para deter a execución dun guión,
pero en certos casos especiais (como dentro dunha función invocada desde un
bloque de instrucións tal como en "mle"), pode resultar necesario utilizar
a opción fatal para acadar unha indicación clara da afirmación que falla.
Porén, observa que neste caso a mensaxe vai dirixirse á saída de
resultados do erro padrón.

Podes restablecer o funcionamento por defecto mediante

	  set assert off

A xeito de exemplo sinxelo: Se en certo punto dun guión HANSL, un escalar x
debera ser non negativo, o seguinte código amosará un erro se este non é
o caso:

	  set assert stop
	  assert(x >= 0)

# 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 "tan", "atan2".

# atan2
Resultado:     mesmo tipo que o introducido
Argumentos:  y (escalar, serie ou matriz)
            x (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co valor principal da arco
tanxente de y/x, utilizando os signos dos dous argumentos indicados para
determinar o cuadrante do resultado. O valor que se devolve está en
radiáns, dentro do rango [-pi, pi].

Se os dous argumentos son de tipos difirentes, o tipo do resultado é o
mesmo que o do "maior" dos dous, donde a xerarquía é matriz > serie >
escalar. Por exemplo, se y é un escalar, e x é un vector de dimensión n
(ou viceversa), o resultado é un vector de dimensión n. Cae na conta de
que os argumentos dunha matriz deben de ser vectores; e de que, se ningún
argumento é un escalar, os dous argumentos deben de ser da mesma longura.

Mira tamén "tan", "tanh".

# 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 inicial en branco) 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.

# bcheck
Resultado:     escalar
Argumentos:  obxectivo (referencia a feixe)
            entrada (feixe)
            teclas-requiridas (arranxo de cadeas, opcional)

Principalmente pensada para que a utilicen os autores de paquetes de
funcións. Este é o contexto no que bcheck pode ser útil: tes unha
función que admite un argumento de tipo feixe mediante o que o solicitante
pode facer varias eleccións. Algúns elementos do feixe poden ter valores
predeterminados -- polo que o solicitante non está obrigado a facer unha
elección explícita -- anque poden necesitarse outros elementos. Queres
determinar se o argumento que obtés, é correcto.

Para utilizar bcheck, constrúes un modelo de feixe que conteña tódalas
chaves admitidas, con valores que exemplifiquen o tipo asociado a cada
chave, e pásalo en forma de punteiro como obxectivo. Para o segundo
argumento, entrada, pasas o feixe que obtés do solicitante. Entón, esta
función comproba o seguinte:

  Contén a entrada algunha chave que non estea presente no obxectivo? En
  tal caso, bcheck devolve un valor non nulo, indicando que a entrada é
  incorrecta.

  Contén a entrada, baixo algunha das chaves indicadas, un obxecto cuxo
  tipo non coincida co do obxectivo? En tal caso, devólvese un valor non
  nulo.

  Se algúns elementos do obxectivo requiren unha entrada do solicitante
  (polo que o valor que indicas non é realmente o predeterminado, senón
  só un marcador de posición para indicar o tipo requirido), debes de
  indicar un terceiro argumento a bcheck: un arranxo de cadeas de texto que
  conteña as chaves para as que non é opcional a entrada. Entón, o valor
  devolto será non nulo se falta algún dos elementos requiridos de
  entrada.

Se non se detectan fallos neses puntos, calquera valor indicado en entrada
cópiase a obxectivo (é dicir, os predeterminados substitúense por
eleccións correctas na parte do solicitante). Cando se detecten fallos,
vaise presentar unha mensaxe que vai indicar qué é o que está mal na
entrada.

Para ofrecer un exemplo sinxelo, supón que o teu feixe de argumentos da
función admite unha matriz X (requirida), un escalar z con valor 0 por
defecto, e unha cadea s co valor "presentar" predeterminado. Entón, o
seguinte fragmento de código sería axeitado para comprobar un feixe de
nome uservals proporcionado polo solicitante:

	  bundle target = _(X={}, z=0, s="presentar")
	  strings req = defarray("X")
	  err = bcheck(&target, uservals, req)
	  if err
	     # reaccionar adecuadamente
	  else
	     # continuar utilizando os valores no obxectivo
	  endif

# bessel
Resultado:     mesmo tipo que o introducido
Argumentos:  tipo (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 da
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 de 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 vectorial 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
vixentes 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, indicado 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 Manual de usuario de Gretl
(Capítulo 37). 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)
            limites (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 vectorial b debe de conter os valores
iniciais dun conxunto de parámetros, o argumento limites 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 vixentes 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 limites, e b contén finalmente os
valores dos parámetros que maximizan o criterio.

A matriz limites 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 limites = {2, 0, $huge}

O cuarto argumento (opcional) establece unha maneira de proporcionar
derivadas analíticas (noutro caso, o gradiente calcúlase 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, indicado 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 Manual de usuario de Gretl
(Capítulo 37). 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.

# bincoeff
Resultado:     mesmo tipo que o introducido
Argumentos:  n (escalar, serie ou matriz)
            k (escalar, serie ou matriz)

Devolve un resultado (do tipo do argumento) co coeficiente binomial. Este
indica o número de xeitos nos que k elementos se poden escoller (sen
repetición) de entre n elementos, independentemente de como estean
ordenados. Isto tamén equivale ao coeficiente do elemento (k+1)-ésimo na
expansión polinómica da potencia dun binomio (1+x)^n.

Para argumentos enteiros o resultado é n!/k!(n-k)!. Pero esta función
tamén acepta argumentos non enteiros, e nese caso a fórmula de arriba se
xeneraliza como Gamma(n+1)/(Gamma(k+1) × Gamma(n-k+1)).

Cando k > n ou k < 0, non hai unha resposta válida polo que se amosa un
fallo.

Se os dous argumentos son de diferente tipo, o resultado será do tipo do
"maior" dos dous (sendo o criterio de ordenación matriz > serie > escalar).
Por exemplo, se n é un escalar, e k é un vector de dimensión r (ou
viceversa), o resultado é un vector de dimensión r. Ten en conta que os
argumentos matriciais deberán ser vectores. Tamén que, se ningún
argumento é un escalar, os dous deberán ser da mesma longura.

Consulta tamén "gammafun" e "lngamma".

# 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 de
considerarse como unha estimación da compoñente de tendencia, máis ca da
compoñente do ciclo. Mira tamén "bwfilt", "hpfilt".

# bkw
Resultado:     matriz
Argumentos:  V (matriz)
            nomespar (arranxo de cadeas, opcional)
            detallado (booleano, opcional)

Executa probas BKW de diagnose de multicolinearidade (consulta Belsley, Kuh
e Welsch (1980)) dada unha matriz de covarianzas das estimacións dos
parámetros, V. O segundo argumento (opcional), pode ser un arranxo de
cadeas de texto ou unha cadea que conteña nomes separados por comas, e se
usa para etiquetar as columnas que amosan as proporcións de varianza; o
número de nomes debe de coincidir coa dimensión de V. Despois de estimar
un modelo en GRETL, podes obter argumentos adecuados para indicar nesta
función mediante os accesorios "$vcv" e "$parnames".

Por defecto, esta función traballa silandeiramente, devolvendo tan só a
táboa BKW en forma de matriz, pero se indicas como terceiro argumento un
valor non nulo, a táboa preséntase xunto con algunhas análises.

Tamén dispós desta funcionalidade con formato de instrución mediante
"bkw", e vaise referir automaticamente ao derradeiro modelo, sen requirir
ningún argumento.

# boxcox
Resultado:     mesmo tipo que o introducido
Argumentos:  y (serie ou matriz)
            d (escalar)

Devolve o resultado da transformación de Box-Cox con parámetro d dunha
serie positiva y (ou das columnas dunha matriz y).

O resultado é (y^d - 1)/d para d distinto de cero, ou log(y) para d = 0.

# bread
Resultado:     feixe
Argumentos:  nomeficheiro (cadea)
            importar (booleano, opcional)

Devolve a lectura dun feixe (bundle) desde un ficheiro especificado polo
argumento nomeficheiro. Por defecto, asúmese que o feixe está representado
en XML; e que se lle aplicou a compresión gzip se nomeficheiro ten
extensión .gz. Pero se a extensión é .json ou .geojson, asúmese que o
contido é de tipo JSON.

No caso XML, o ficheiro 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, os ficheiros que se len axeitadamente por medio de
bread xéranse mediante a función asociada "bwrite".

Se o nome do ficheiro non contén a especificación completa do camiño ao
cartafol onde está, entón vai procurarse en varias localizacións
"probables", comezando no "workdir" vixente. Porén, cando se proporciona un
valor non nulo para o argumento opcional importar, o ficheiro vai procurarse
no cartafol "punto" do usuario. Neste caso, o argumento nomeficheiro deberá
ser un nome simple de ficheiro, sen a inclusión do camiño ao cartafol.

Se ocorre algún fallo (por exemplo, se o ficheiro está mal formatado ou é
inaccesible), devólvese o fallo por medio do accesorio "$error".

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

# brename
Resultado:     escalar
Argumentos:  B (feixe)
            vellachave (cadea)
            novachave (cadea)

Se o feixe B contén un elemento que teña a chave vellachave, esa súa
chave trócase a novachave; doutro xeito, amósase un fallo. A función
devolve un 0 cando se fai correctamente o cambio de nome.

Trocar a chave dun elemento dun feixe non é unha tarefa habitual, mais pode
xurdirte esa necesidade no contexto de funcións que operan con feixes, e
brename resulta ser unha ferramenta eficiente para ese traballo. Exemplo:

	  # Establecer un feixe que contén unha matriz grande
	  bundle b
	  b.X = mnormal(1000, 1000)
	  if 0
	      # 'Trocar a chave manualmente'
	      Xcopy = b.X
	      delete b.X
	      b.Y = Xcopy
	      delete Xcopy
	  else
	      # fronte a 'Trocala de forma eficiente'
	      brename(b, "X", "Y")
	  endif

O primeiro método esixe que se copie esa gran matriz dúas veces: primeiro
fóra do feixe, e logo de novo dentro del baixo unha chave diferente. O
método eficiente troca a chave directamente.

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

Devolve unha serie co que resulta ao 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 ca 180. 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
Manual de usuario de Gretl (Capítulo 30). Mira tamén "bkfilt", "hpfilt".

# bwrite
Resultado:     enteiro
Argumentos:  B (feixe)
            nomeficheiro (cadea)
            exportar (booleano, opcional)

Escribe o feixe (bundle) B nun ficheiro, serializado en XML; ou como JSON,
se nomeficheiro ten extensión .json ou .geojson. Consulta "bread" para ter
unha descrición do formato cando se usa XML. Se xa existe un ficheiro
denominado nomeficheiro, vaise sobrescribir. Esta función devolve o valor
nominal 0 no caso de que conclúa con éxito; se fracasa a escritura se
amosa un fallo.

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

Dispós da opción de compresión gzip, pero unicamente no caso de que o
resultado sexa de tipo XML. Isto vaise aplicar se nomeficheiro ten a
extensión .gz.

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

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

Devolve unha matriz real de dimensión m x n que contén o "argumento"
complexo de cada elemento da matriz complexa C de dimensión m x n. O
argumento do número complexo z = x + yi tamén pode calcularse mediante
atan2(y, x).

Mira tamén "abs", "cmod", "atan2".

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

Centra as columnas da matriz X a respecto das súas medias. Se o segundo
argumento (opcional) ten un valor non nulo, entón os valores centrados
divídense ademais polas desviacións padrón de cada columna (que se
caculan utilizando n - 1 como divisor, no que n é o número de filas de X).

Cae na conta de que "stdize" proporciona unha funcionalidade máis flexible.

# 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 (mais
observa que a distribución Normal ten a súa propia función, por
conveniencia, "cnorm"):

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

  Normal bivariante (D): coeficiente de correlación

  Loxística (lgt ou s): sen máis argumentos

  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

  Beta (beta): 2 parámetros de forma

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

  Poisson (p ou P): media

  Exponencial (exp): escala

  Weibull (w ou W): forma, escala

  Laplace (l ou L): media; 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)

Esta é unha función herdada, anterior ao soporte orixinal de GRETL para
matrices complexas.

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 e 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 de A. Cando A sexa unha matriz real,
deberá ser simétrica e definida positiva; nese caso, o resultado será
unha matriz triangular inferior L que verificará A = LL'. Cando A sexa
complexa, deberá ser Hermitiana e definida positiva; e o resultado será
unha matriz complexa triangular inferior de xeito que A = LL^H. En caso
contrario, a función devolverá un fallo.

Para o caso real, consulta tamén "psdroot" e "Lsolve".

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

Non se recomenda seguir utilizando esta función; en troques, utiliza
"tdisagg".

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 factorx veces o seu número de filas.
Tamén se asume que cada valor de baixa frecuencia debe tratarse como a
media de factorx valores de alta frecuencia.

O valor de factorx debe ser igual a 3 para expandir datos trimestrais a
mensuais, 4 para facelo de anuais a trimestrais, ou 12 de anuais a mensuais.
Podes usar o terceiro argumento (opcional) para prover unha matriz de
covariables cun obxectivo de maior frecuencia.

Os regresores que se utilizan por defecto son unha constante e unha
tendencia. 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 factorx veces o número de filas de Y.

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

Devolve unha matriz real de dimensión m x n que contén o módulo complexo
de cada elemento da matriz complexa C de dimensión m x n. O módulo do
número complexo z = x + yi é igual á raíz cadrada de x^2 + y^2.

Mira tamén "abs", "carg".

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

Esta é unha función herdada, anterior ao soporte orixinal de GRETL para
matrices complexas.

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".

# cnameget
Resultado:     cadea ou arranxo de cadeas
Argumentos:  M (matriz)
            col (enteiro, opcional)

Se indicas o argumento col, devolve unha cadea de texto 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.

Se non indicas o segundo argumento, devolve un arranxo de cadeas de texto
que contén os nomes das columnas de M, ou un arranxo baleiro se M non ten
asignados nomes de columnas.

Exemplo:

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

Mira tamén "cnameset".

# cnameset
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. Como segundo argumento tamén se acepta unha única cadea de
texto; nese caso, esta cadea precisa ter k subcadeas separadas por espazos.

Devolve o valor nominal 0 se as columnas son nomeadas con éxito; no caso de
que non funcione, amósase un fallo. Consulta tamén "rnameset".

Exemplo:

	  matrix M = {1, 2; 2, 1; 4, 1}
	  strings S = array(2)
	  S[1] = "Col1"
	  S[2] = "Col2"
	  cnameset(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".

# commute
Resultado:     matriz
Argumentos:  A (matriz)
            m (enteiro)
            n (enteiro, opcional)
            post (enteiro, opcional)
            add_id (enteiro, opcional)

Devolve o resultado de premultiplicar a matriz A pola matriz K_m,n de
conmutación (isto é máis eficiente que a propia multiplicación
explícita). Asúmese que cada columna de A procede dunha operación de
vectorización sobre unha matriz m x n. En particular,

	  commute(vec(B), rows(B), cols(B))

proporciona vec(B'). Co obxecto de calcular a matriz de conmutación
apropiada, aplica simplemente a función a unha matriz identidade co tamaño
axeitado. Por exemplo:

	  K_32 = commute(I(6), 3, 2)

Por defecto, o argumento opcional n está establecido que sexa igual a m.
Cando o argumento opcional post non é cero, lévase a cabo a
multiplicación posterior en troques da multiplicación anterior; e a
opción Booleana add_id vai premultiplicar a matriz A por I + K_m,n en
troques de K_m,n.

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

Devolve unha matriz complexa, na que tómase A para ofrecer a parte real e B
para a parte imaxinaria. Se A é de dimensión m x n e B é un escalar, o
resultado é unha matriz m x n cunha parte imaxinaria constante (e de xeito
similar no caso recíproco, mais cunha parte real constante). Se ambos
argumentos son matrices, deben de ter as mesmas dimensións. Se omites o
segundo argumento, a parte imaxinaria establécese por defecto como cero.
Mira tamén "cswitch".

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

Devolve unha matriz complexa de dimensión m x n que contén o conxugado
complexo de cada elemento da matriz complexa C de dimensión m x n. O
conxugado dun número complexo z = x + yi é igual a x - yi.

Mira tamén "carg", "abs".

# contains
Resultado:     mesmo tipo que o introducido
Argumentos:  x (escalar, serie ou matriz)
            S (matriz)

Proporciona un medio de determinar se un obxecto numérico x está contido
nalgún dos elementos dunha matriz S (que cumpre o papel dun conxunto).

O valor que se devolve é un obxecto do mesmo tamaño que x que contén
valores de 1 nas posicións onde o valor x coincide con algún elemento de
S, e ceros nas demais. Por exemplo, o código

	  matrix A = mshape(seq(1,9), 3, 3)
	  matrix C = contains(A, {1, 5, 9})

produce

	  A (3 x 3)

	  1   4   7
	  2   5   8
	  3   6   9

	  C (3 x 3)

	  1   0   0
	  0   1   0
	  0   0   1

Esta función pode ser particularmente útil cando x é unha serie que
contén unha codificación moi refinada para unha característica
cualitativa, e queres reducir isto a un número de categorías menor. Podes
meter en S un conxunto de valores a consolidar, e obter unha variable
ficticia co valor 1 para as observacións que coinciden con este conxunto, e
o valor 0 para as demais.

Posto que S funciona como un conxunto, debera ser un vector sen valores
repetidos para ter unha maior eficiencia; porén, acéptase unha matriz
calquera.

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

Devolve unha matriz co cálculo da convolución bidimensional (2D) de dúas
matrices A e B. Se A é de orde r x c, e B é de orde m x n, entón a matriz
que se devolve vai ter r+m-1 filas e c+n-1 columnas.

Mira tamén "fft", "filter".

# cquad
Resultado:     matriz
Argumento:   Z (matriz)

Dada unha matriz complexa Z de orde m x n, esta instrución devolve unha
matriz real de orde m x n que contén as "cuadranzas" de cada un dos
elementos de Z. A cuadranza dun número complexo z = a + bi se define como
a^2 + b^2. Polo tanto, é igual ao cadrado do módulo de z, e tamén é
igual a z multiplicado polo seu conxugado complexo; pero o cálculo directo
que realiza cquad é considerablemente máis rápido que calquera das outras
propostas alternativas.

# 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 dende 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 matriz con p filas e 2k columnas, na
que 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 dende +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 seleccionada en vigor.

# 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
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 de 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

  Laplace (l ou L): media; escala

  Erro Xeneralizado (E): forma

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

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

Reinterpreta unha matriz real como se contivese valores complexos, ou
viceversa. A acción concreta depende de xeito (que deberá ter un valor de
1, 2, 3 ou 4), como se explica deseguido:

Xeito 1: O argumento A debe ser unha matriz real cun número par de
columnas. A función devolve unha matriz coa metade das columnas, con
valores complexos formados utilizando as columnas impares de A para as
partes reais, e as columnas pares para as partes imaxinarias.

Xeito 2: Permite facer a operación inversa á do xeito 1. O argumento A
debe ser unha matriz complexa, e o resultado que se devolve é unha matriz
real que terá o dobre de columnas que as de A.

Xeito 3: O argumento A debe ser unha matriz real cun número par de filas. A
función devolve unha matriz coa metade das filas, con valores complexos
formados utilizando as filas impares de A para as partes reais, e as filas
pares para as partes imaxinarias.

Xeito 4: Permite facer a operación inversa á do xeito 3. O argumento A
debe ser unha matriz complexa, e o resultado que se devolve é unha matriz
real que terá o dobre de filas que as de A.

Mira tamén "complex".

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

Devolve unha matriz complexa de dimensión n x m que contén a trasposta
conxugada da matriz complexa C de dimensión m x n. O operador '
(traspoñer) fai tamén a transposición conxugada de matrices complexas.
Podes utilizar a función "transp" con matrices complexas, pero iso vai
realizar a transposición "directa" (non a conxugada).

# 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 vixente
seleccionada. Cando x é unha matriz, os seus elementos acumúlanse por
columnas.

Mira tamén "diff".

# curl
Resultado:     enteiro
Argumento:   &b (referencia a feixe)

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 do
resultado.

Ao completarse a solicitude, o texto recibido do servidor engádese ao feixe
coa chave "output".

A función vai fallar se hai unha equivocación ao formular a solicitude
(por exemplo, se non existe unha 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 da US Bureau of Labor Statistics, que require o envío dunha
consulta JSON. Observa o uso de 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)
	          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:  d1 (enteiro)
            d2 (enteiro)
            duracsemana (enteiro)

Devolve un número enteiro co número de días (relevantes) entre os días
de época d1 e d2, ambos incluídos, considerando a duración de semana
indicada polo argumento duracsemana. 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:     feixe
Argumento:   ... (Mira máis abaixo)

Te permite a carga inicial dunha variable de tipo feixe extensamente,
proporcionando cero ou máis parellas co formato chave, elemento. 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 para 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 definir 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ías facer mediante

	  bundle b = null

Variantes de sintaxe

Dispós de dúas formas alternativas de sintaxe para definir feixes. En
ambos casos, a palabra chave defbundle substitúese por un carácter de
barra baixa. Na primeira variante, os elementos separados por comas teñen a
forma chave=valor, onde a chave se entende que debe ser unha cadea de texto
literal e non require que a poñas entre comiñas. Este é un exemplo:

	  bundle b = _(x=5, strval="Algunha cadea", m=I(3))

Esta forma resulta particularmente conveniente para producir un feixe
anónimo improvisadamente como argumento dunha función, como en

	  b = regls(ys, LX, _(lfrac=0.35, stdize=0))

onde a función regls ten un argumento opcional de tipo feixe que contén
varios parámetros.

A segunda variante está pensada para o caso no que queiras empaquetar
varios obxectos xa existentes nun feixe: simplemente indica os seus nomes
sen comiñas:

	  bundle b = _(x, y, z)

Neste caso, o obxecto x se copia nun feixe coa chave "x". De xeito similar
faise tanto para y como para z.

Estas formas alternativas implican teclear menos que na versión cumprida de
defbundle(), e probablemente moitas veces son máis convenientes, pero ten
en conta que son menos flexibles. Só na versión cumprida podes manexar as
chaves indicándoas como variables de cadea de texto en troques de cadeas
literais.

# 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, unha serie xa definida (indicada
polo seu nome ou o número enteiro ID), unha lista xa definida, ou unha
expresión que se corresponda cunha lista (incluíndo un vector que poda
interpretarse como un conxunto de números ID de series).

Un aspecto a ter en conta é que esta función simplemente encadea os seus
argumentos para producir a lista que devolve. Cando se pretende que o valor
que devolva non conteñ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)
            opcions (feixe, opcional)

A intención principal desta función é xerar unha versión
desestacionalizada da serie x (mensual ou trimestral) de entrada, utilizando
para elo X-13ARIMA-SEATS; isto estará dispoñible unicamente se está
instalado X-13ARIMA-SEATS. Cando omites o feixe necesario para o segundo
argumento (opcional), o axuste estacional faise incluíndo tódalas opcións
de X-13ARIMA establecidas nos seus valores por defecto (procedemento
completamente automático). Cando indicas o feixe de opcions, se podería
incluír calquera das seguintes especificacións para as opcións.

  verbose: Que presentar? 0 = nada (por defecto); 1 = confirmación das
  opcións que están seleccionadas; 2 = confirmación das opcións máis o
  resultado de X-13ARIMA.

  seats: 1 para utilizar o algoritmo SEATS en troques do algoritmo
  predeterminado X11 para o axuste estacional, ou 0.

  airline: 1 para utilizar a especificación "airline" (0,1,1)(0,1,1) de
  modelos ARIMA en troques da selección de modelos automática
  predeterminada, ou 0.

  arima: Pode utilizarse para impoñer unha especificación ARIMA escollida,
  en formato dun vector de 6 elementos que conteña números enteiros baixos
  e non negativos. Estes se indican coa simboloxía (p,d,q,P,D,Q) da
  notación tradicional das series de tempo: os primeiros tres termos
  representan as ordes AR, de Integración e MA non estacionais; e os tres
  derradeiros indican as contrapartidas estacionais. Cando se indican tanto
  a opción airline como a arima, ten prioridade a arima.

  outliers: Permite a detección e corrección de valores atípicos
  (eleccións de 1 ata 7), ou 0 (o predeterminado) para omitir esta
  característica. Os tres tipos de valores atípicos dispoñibles cos seus
  códigos numéricos son: 1 = valor atípico aditivo (ao), 2 = paso de
  nivel (ls), 4 = cambio temporal (tc). Para combinar as opcións podes
  engadir códigos, por exemplo: 1 + 2 + 4 = 7 para activar as tres a un
  tempo. Cae na conta de que a elección 3 = 1 + 2 (ao con ls) é a
  predeterminada en X-13ARIMA-SEATS, e se selecciona mediante o cadriño de
  valores atípicos na xanela de diálogo de GRETL para o axuste estacional
  por medio de X13.

  critical: Un escalar positivo co valor crítico para definir os valores
  atípicos, sendo automático o predeterminado que se fai en función do
  tamaño da mostra. Relevante só cando indicas a opción outliers.

  logtrans: Debería pasarse a serie de entrada a logaritmos? 0 = non, 1 =
  si, 2 = selección automática (por defecto). Cae na conta de que non se
  recomenda que indiques unha serie de entrada xa en logaritmos; se queres
  que se utilice o logaritmo, indica o nivel "de base" pero especificando
  despois logtrans=1.

  trading_days: Deberían incluírse os días de operación? 0 = no, 1 = si,
  2 = automático (o predeterminado).

  working_days: Unha versión máis simple de trading_days cunha única
  distinción entre días da semana e fins de semana, en vez dos efectos dos
  días particulares. 0 = no (o predeterminado), 1 = si, 2 = automático.
  Utiliza só unha das dúas opcións, trading_days ou working_days.

  easter: 1 para permitir o efecto da Pascua, como complemento a
  trading_days ou a working_days, ou 0 (o predeterminado).

  output: Unha cadea de texto para escoller o tipo de serie do resultado:
  "sa" para desestacionalizado (o predeterminado), "trend" para a tendencia
  estimada, ou "irreg" para a compoñente irregular.

  save_spc: Indicador booleano, 0 por defecto; mira abaixo.

Resultados ampliados

Nalgúns casos poderías querer obter os tres resultados dispoñibles do
X-13ARIMA mediante unha única chamada a deseas. Isto se admite do seguinte
xeito. Pasa o feixe opcions en formato de punteiro, e indica a cadea de
texto "all" baixo a chave output. O valor directo que se devolve entón é a
serie axustada estacionalmente, mais cando se completa con éxito opcions
vai conter unha matriz denominada results con tres columnas: axustada
estacionalmente, tendencia e irregular. A continuación tes un exemplo (no
que se descarta o valor do resultado directo).

	  bundle b = _(output="all")
	  deseas(y, &b)
	  series y_dseas = b.results[,1]
	  series y_trend = b.results[,2]
	  series y_irreg = b.results[,3]

Gardando a especificación de X-13ARIMA

Podes utilizar o indicador save_spc para gardar o contido do ficheiro de
entrada X-13ARIMA que escribe GRETL. O feixe coas opcións debe pasarse en
formato de punteiro, e a especificación (como cadea de texto) pode atoparse
baixo a chave x13a_spc. O seguinte código ilustra como se garda esta nun
ficheiro baixo o nome especif.spc no directorio de traballo do usuario. (Cae
na conta de que a extensión .spc é requirida polo X-13ARIMA.)

	  bundle b = _(save_spc=1)
	  deseas(y, &b)
	  outfile especif.spc
	     print b.x13a_spc
	  end outfile

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

Devolve un escalar co valor do determinante de A, calculado mediante a
descomposición LU. Se o que realmente queres é o logaritmo natural do
determinante, debes en troques invocar "ldet". Mira tamén "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.

Mira tamén "lngamma", "trigamma".

# distance
Resultado:     matriz
Argumentos:  X (matriz)
            metrica (cadea, opcional)
            Y (matriz, opcional)

Calcula as distancias entre puntos sobre unha métrica que pode ser
euclidean (a predeterminada), manhattan, hamming, chebyshev, cosine ou
mahalanobis. Podes indicar a cadea de texto que identifica á métrica,
tronzándoa de xeito que non resulte ambigua. As outras métricas
adicionais, de correlación e a euclídea tipificada se admiten mediante
transformacións simples das anteriores (mira máis abaixo).

Cada fila da matriz X (que é m x n) trátase como un punto dun espazo
n-dimensional; nun contexto econométrico, isto probablemente represente
unha única observación que abranga os valores de n variables.

Casos típicos

Esta sección se aplica a tódaslas métricas, agás á distancia de
Mahalanobis, para a que a sintaxe é lixeiramente diferente (mira máis
abaixo).

Se non indicas Y, o valor que se devolve é un vector columna de longura m(m
- 1)/2 que abrangue o subconxunto non redundante de tódalas distancias por
parellas entre os m puntos (as filas de X). Entón, dado un vector deste
tipo que teña por nome d, podes xerar a matriz simétrica completa coas
distancias entre os puntos (con ceros na diagonal principal, naturalmente)
por medio de

	  D = unvech(d, 0)

posto que d é semellante ao vector columna resultante de aplicar a función
vech sobre D, sen os elementos da diagonal principal. O segundo argumento
(opcional) de "unvech" indica que debe encherse a diagonal con ceros.

Se indicas Y, debe ser unha matriz p x n na que cada unha das súas filas se
trata novamente como un punto no espazo n-dimensional. Neste caso, o valor
que se devolve é unha matriz m x p cuxo elemento i,j contén a distancia
que hai entre a fila i da matriz X e a fila j da matriz Y.

Para obter as distancias desde un punto de referencia dado (por exemplo, o
centroide) ata cada un dos n puntos de datos, indica Y como unha única
fila.

Definicións das métricas admitidas

  euclidean: a raíz cadrada da suma dos desvíos elevados ao cadrado, en
  cada unha das dimensións.

  manhattan: a suma dos valores absolutos dos desvíos, en cada unha das
  dimensións.

  hamming: a proporción das dimensións nas que os desvíos non son nulos
  (acoutada entón por 0 e 1).

  chebyshev: o maior dos valores absolutos dos desvíos en calquera das
  dimensións.

  cosine: 1 menos o coseno do ángulo que se forma entre os "puntos",
  considerados como vectores.

Distancia de Mahalanobis

As distancias de Mahalanobis defínense como distancias euclídeas, entre os
puntos considerados (filas da matriz X) e un centroide dado, escaladas
mediante a inversa dunha matriz de covarianzas. No caso máis sinxelo, o
centroide está constituído polas medias na mostra das variables (columnas
de X) e a matriz de covarianzas está formada polas covarianzas entre elas
na mostra.

Isto pódese obter indicando como segundo argumento a cadea de texto
"mahalanobis" ou calquera abreviatura non ambigua, como en

	  dmahal = distance(X, "mahal")

Neste caso, o terceiro argumento Y non se admite, e o valor que se devolve
é un vector columna de longura m coas distancias de Mahalanobis desde o
centroide de X (é dicir, a súa media na mostra). Na práctica, a matriz do
resultado neste caso é a mesma que obtés ao executar a instrución "mahal"
sobre unha listaxe de series que se correspondan coas columnas da matriz X.

Para obter as distancias de Mahalanobis usando un centroide distinto, mu,
e/ou a inversa da matriz de covarianzas, ICV, podes utilizar a seguinte
sintaxe:

	  dmahal = distance(X*cholesky(ICV), "euc", mu)

Outras métricas

Podes obter as distancias euclídeas tipificadas e as de correlacións do
seguinte xeito:

	  # Euclídea tipificada
	  dseu = distance(stdize(X), "eu")
	  # Correlación (baseada no coseno)
	  dcor = distance(stdize(X', -1)', "cos")

# 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á suxeito 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)
	  Substituíuse a lista Y
	  ? list print Y
	  foo bar foobar

# dsort
Resultado:     mesmo tipo que o introducido
Argumento:   x (serie, vector ou arranxo de cadeas)

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 de 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 de tratarse como
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: Dnomevariable_i onde nomevariable 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. Con esta convención, observa que o 10 de abril é
4,1; de aí que 4,2 represente o día 20 de abril e non o día 2 de abril
(que é 4,02). Exemplo:

	  scalar e = easterday(2014)
	  scalar m = floor(e)
	  scalar d = round(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 en 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.

# eigen
Resultado:     matriz
Argumentos:  A (matriz cadrada)
            &V (referencia a matriz, ou null)
            &W (referencia a matriz, ou null)

Calcula os autovalores (e opcionalmente os autovectores dereitos e/ou
esquerdos) da matriz A de dimensión n x n, que pode ser real ou complexa.
Os autovalores devólvense nun vector columna complexo. Para obter a norma
dos autovalores podes utilizar a función "abs", que admite argumentos
complexos.

Se queres recuperar os autovectores dereitos (como no caso dunha matriz
complexa de dimensión n x n), indica o nome dunha matriz xa existente,
precedido por & para indicar a "dirección" da matriz en cuestión, como
segundo argumento. Doutro xeito, podes omitir este argumento.

Para recuperar os autovectores esquerdos (de novo, como nunha matriz
complexa), indica a dirección dunha matriz como terceiro argumento. Cae na
conta de que, se queres os autovectores esquerdos pero non os dereitos,
debes usar a palabra chave null como marcador para o segundo argumento.

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

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

Esta é unha función herdada, anterior ao soporte orixinal de GRETL para
matrices complexas. Non debes usala nos novos guións que escribas en
linguaxe HANSL. Utiliza "eigen" en troques.

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 "eigen", agás que o argumento A debe
de ser simétrico (polo que, neste caso, pódense acurtar os cálculos), e
os autovalores devólvense en orde ascendente. Se desexas obter os
autovalores en orde descendente (e ter os autovectores reordenados en
consecuencia), podes facer o seguinte:

	  matrix U
	  e = eigensym(A, &U)
	  Tmp = msortby((-e' | U)',1)'
	  e = -Tmp[1,]'
	  U = Tmp[2:,]
	  # Agora os autovalores de maior a menor
	  print e U

Aviso: Se o que te interesa é a descomposición espectral dunha matriz da
forma X'X, é preferible calcular o argumento 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 ofrece maior eficiencia dende o punto de
vista do cómputo, e garante que o resultado vai ser exactamente simétrico.

# 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 de 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:  ano (escalar ou serie)
            mes (escalar ou serie)
            día (escalar ou serie)

Devolve un escalar ou unha serie, co número do día especificado polo ano,
mes e día, nesa orde, na época actual. O número do día é igual a 1 para
o día 1 de xaneiro do ano 1 despois de Cristo, no calendario Gregoriano
proléptico, e a 733786 para a data 01-01-2010. 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 ano, mes e día se presupón que se
están indicando de acordo co calendario Gregoriano, mais se o ano ten un
valor negativo, a interpretación muda á do calendario Xuliano.

Tamén admítese unha petición alternativa: se indicas un único argumento,
vaise considerar que é unha data (ou unha serie de datas) en formato
numérico ISO 8601 "básico", YYYYMMDD. Deste xeito, as seguintes dúas
peticións producen o mesmo resultado, en concreto 700115.

	  eval epochday(1917, 11, 7)
	  eval epochday(19171107)

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 a errno,
que debe de ser un número enteiro. Consulta tamén "$error".

# errorif
Resultado:     escalar
Argumentos:  condicion (booleano)
            mensaxe (cadea)

Esta función só se aplica no contexto dunha función definida polo
usuario, ou dentro dun bloque "mpi". Se a condicion se valora como non nula,
iso implica que a execución da función vixente remate coa presentación
dunha mensaxe condicionada a que se produza un fallo; entón o argumento
mensaxe vaise presentar como parte da mensaxe de fallo que se amosa ao
chamar á función en cuestión.

O valor que se devolve con esta función (1) é simplemente nominal.

# exists
Resultado:     enteiro
Argumento:   nome (cadea)

Devolve un escalar non nulo se nome é 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 tipo do argumento) con e^x. Cae na conta de que con
argumento matricial, 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)
            U2 (booleano, opcional)

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 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  Media dos erros
	  2  Raíz do erro cadrado medio
	  3  Media dos valores absolutos dos erros
	  4  Media dos erros relativos, en porcentaxe
	  5  Media dos valores absolutos dos erros relativos, en porcentaxe
	  6  U de Theil (U1 ou U2)
	  7  Proporción de nesgo, UM
	  8  Proporción de regresión, UR
	  9  Proporción de perturbación, UD

A variante do U de Theil que se presenta por defecto depende da natureza dos
datos: cando se sabe que son series de tempo, amósase o U2; noutro caso,
prodúcese o U1. Pero podes forzar esta elección mediante o derradeiro
argumento opcional: indica un valor non nulo para forzar o U2, ou un valor
de cero para forzar o U1.

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

# fdjac
Resultado:     matriz
Argumentos:  b (vector columna)
            chamaf (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 chamaf. Ao apelar a esta función debes de utilizar b como
primeiro argumento da mesma (ben directamente ou en forma de punteiro),
seguido de calquera argumento adicional que poda necesitarse; e como
resultado debérase 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, mifunc(&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 conciliación entre
precisión e velocidade. Podes elixir entre os distintos métodos mediante a
instrución "set": especifica o valor 0, 1 ou 2 para a variable
fdjac_quality. O valor por defecto é 0.

Para máis detalles e exemplos, consulta o Manual de usuario de Gretl
(Capítulo 37).

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

# feval
Resultado:     Mira máis abaixo
Argumentos:  nomefuncion (cadea)
            ... (Mira máis abaixo)

Fundamentalmente útil para os creadores de funcións. O primeiro argumento
debe de ser o nome dunha función; os argumentos restantes se pasarán á
función especificada. Isto permite tratar á propia función identificada
mediante nomefuncion como unha variable en si mesma. O valor que se devolve
é calquera cousa que produza a función indicada, dados os argumentos
especificados.

O exemplo de abaixo, ilustra algúns dos seus posibles usos.

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

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

	  # Chamada a unha función integrada de 1 argumento
	  x = feval(S[1], 2.5)
	  # Chamada a unha función definida polo usuario
	  x = feval(S[2], 5, 0.5)
	  # Chamada a unha función integrada de 2 argumentos
	  func = "zeros"
	  m = feval(func, 5-2, sqrt(4))
	  print m
	  # Chamada a unha función integrada de 3 argumentos
	  x = feval("monthlen", 12, 1980, 5)

Existe unha feble semellanza entre a función feval e "genseries": ámbalas
dúas funcións volven variable a un elemento sintáctico que habitualmente
se fixa ao tempo no que se redacta un guión.

# fevd
Resultado:     matriz
Argumentos:  efecto (enteiro)
            motivo (enteiro)
            sys (feixe, opcional)

Esta función proporciona unha alternativa máis flexible ca o accesorio
"$fevd" para obter unha matriz de descomposición da varianza do erro de
predición (FEVD), logo de estimar un VAR ou un VECM. Se falta o argumento
final (opcional), só está dispoñible cando o último modelo estimado foi
un VAR ou un VECM. Como alternativa, podes gardar nun feixe a información
sobre estes tipos de sistemas, mediante o accesorio "$system", e
posteriormente pasarlle a función fevd.

Os argumentos da función, efecto e motivo, teñen a forma de índices
enteiros positivos das variables endóxenas do sistema, tomando o 0 para
representar "todas". O seguinte fragmento de código, ilustra o seu uso. No
primeiro exemplo, a matriz fe1 contén as partes da FEVD para y1 debidas a
cada parte de y1, y2 e y3 (polo tanto, as filas suman 1 en total). No
segundo, fe2 contén a contribución de y2 á varianza do erro de predición
das tres variables (entón, as filas non suman 1 en total). No terceiro
caso, o que se devolve é un vector columna que amosa a "parte propia" da
FEVD de y1.

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

O número de períodos (filas) sobre os que se traza a descomposición,
determínase automaticamente en base á frecuencia dos datos, pero podes
ignorar isto mediante o argumento horizon da instrución "set", como en set
horizon 10.

Mira tamén "irf".

# fft
Resultado:     matriz
Argumento:   X (matriz)

Devolve unha matriz co resultado da transformación discreta de Fourier. A
matriz X do argumento pode ser real ou complexa. O resultado é unha matriz
complexa que ten a mesma dimensión ca X.

Se fora necesario calcular a transformación de Fourier sobre varios
vectores co mesmo número de elementos, é máis eficiente agrupalos nunha
matriz, en troques de executar fft para cada vector por separado. Mira
tamén "ffti".

# ffti
Resultado:     matriz
Argumento:   X (matriz)

Devolve unha matriz con n columnas, co resultado da transformación inversa
de Fourier discreta. Asúmese que a matriz X consta de n vectores columna
complexos.

Cando necesites aplicar a transformación inversa de Fourier sobre varios
vectores co mesmo número de elementos, resulta 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)
            x0 (escalar ou vector, 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 iso implicará que q=0.
Cando é un vector con q+1 elementos, vai conter os coeficientes dende 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 dende 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. De forma similar, podes usar o argumento
opcional x0 para especificar un ou máis valores de x anteriores ao comezo
da mostra (información só relevante cando q > 0). Doutro xeito, asúmese
que os valores de x anteriores ao comezo da mostra son 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
Argumentos:  y (serie)
            namostra (booleano, opcional)

Devolve o número enteiro positivo que indexa a primeira observación non
ausente da serie y. Por defecto, analízase todo o rango da mostra, de xeito
que, se está activa algunha forma de submostraxe, o valor que se devolve
pode ser menor ca o valor devolto polo accesorio "$t1". Pero se indicas un
valor non nulo en namostra, só vai terse en conta o rango da mostra
vixente. Mira tamén "lastobs".

# fixname
Resultado:     cadea
Argumentos:  nomesobrio (cadea)
            underscore (booleano, opcional)

En principio, esta función está ideada para utilizarse en conxunto coa
instrución "join". Devolve unha cadea co resultado da conversión de
nomesobrio nun identificador válido de GRETL; debe iniciarse cunha letra,
debe de conter só letras ASCII, díxitos e/ou guión baixo, e non debe de
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 guión baixo (agás que o carácter
anterior transcrito sexa un guión baixo, pois entón elimínase o espazo),
e omite os outros tipos de caracteres "ilegais".

Se estás convencido de que a entrada non é demasiado longa (entón
susceptible de ser tronzada), podes querer substituír secuencias de un ou
máis caracteres ilícitos mediante un guión baixo (en troques de só
eliminalos) pois isto podería xerar un identificador máis lexible. Para
acadar este efecto, proporciona un valor non nulo para o segundo argumento
(opcional). Mais isto non é recomendable no contexto da instrución "join",
posto que o nome "fixado" automaticamente non vai utilizar guións baixos
deste xeito.

# flatten
Resultado:     Mira máis abaixo
Argumentos:  A (arranxo de matrices ou cadeas)
            alt (booleano, opcional)

"Achanza" ben un arranxo de matrices nunha única matriz, ou ben un arranxo
de cadeas de texto nunha única cadea.

Os argumentos indícanse entre parénteses. Con matrices, por defecto,
concaténanse horizontalmente as matrices de A; pero cando indicas un valor
non nulo para alt, a concatenación faise verticalmente. En calquera caso,
amósase un fallo se as matrices non son conformables para realizar esta
operación. Consulta "msplitby" para a operación inversa.

No caso de cadeas de texto, o resultado por defecto mantén as cadeas de A,
ordenadas unha en cada liña. Se indicas un valor numérico non nulo para
alt, as cadeas sepáranse mediante espazos en troques de novas liñas; pero
tamén se admite un uso alternativo de alt: podes indicar unha cadea de
texto específica para utilizar como separador.

# 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 serie y.

Observa que, en teoría, a diferenciación fraccionaria supón un filtro
infinitamente longo. 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.

# fzero
Resultado:     escalar
Argumentos:  fcall (chamada a función)
            inicio (escalar ou vector, opcional)
            toler (escalar, opcional)

Trata de atopar unha raíz simple dunha función continua f (normalmente non
linear) -- é dicir, un valor da variable escalar x que fai que f(x) = 0. O
argumento fcall debe de proporcionar unha chamada á función en
cuestión;fcall pode incluír un número arbitrario de argumentos, pero o
primeiro debe de ser un escalar que represente o papel de x. Cando se
complete a función con éxito, vaise devolver o valor da raíz.

O método utilizado é o de Ridders (1979). Isto require un intervalo
inicial {x_0, x_1} tal que ambos os dous valores x pertenzan ao dominio da
función, e que os respectivos valores da función sexan de signo contrario.
Probablemente, vas obter mellores resultados se es capaz de proporcionar,
mediante o segundo argumento, un vector bidimensional que conteña puntos
finais axeitados para o intervalo. Se isto falla, podes proporcionar un
único valor escalar, e fzero tratará de atopar unha parella. Se omites o
segundo argumento, o valor de x_0 se inicia cun pequeno número positivo, e
logo vaise procurar un valor axeitado para x_1.

Podes usar o argumento toler (opcional) para axustar a máxima diferenza
absoluta que resulte aceptable entre f(x) e cero, sendo esta igual a 1.0e-14
por defecto.

Por defecto, esta función traballa silandeiramente, pero podes amosar a
evolución do método iterativo executando a instrución "set max_verbose
on" antes de chamar a fzero.

Deseguido indícanse algúns exemplos sinxelos:

	  # Aproximar 'pi' atopando o valor que anula a
	  # función sin() no intervalo de 2.8 a 3.2
	  x = fzero(sin(x), {2.8, 3.2})
	  printf "\nx = %.12f vs pi = %.12f\n\n", x, $pi

	  # Aproximar a 'constante Omega' comezando en x = 0.5
	  function scalar f(scalar x)
	      return log(x) + x
	  end function
	  x = fzero(f(x), 0.5)
	  printf "x = %.12f f(x) = %.15f\n", x, f(x)

# gammafun
Resultado:     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.

Consulta tamén "bincoeff" e "lngamma".

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

Proporciónalle ao guionista un procedemento adecuado para 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:

	  nulldata 10
	  list Normais = null
	  scalar n = 3
	  loop i = 1 .. n
	      Normais += genseries(sprintf("norm%d", i), normal())
	  endloop

Ao rematar a execución, a lista Normais vai conter as series norm1, norm2 e
norm3.

A aqueles que atopedes útil a función genseries, pode que vos interese
explorar a función "feval".

# geoplot
Resultado:     nada
Argumentos:  ficheiromap (cadea)
            carga (serie, opcional)
            opcions (feixe, opcional)

Solicita a produción dun mapa, cando se dispón de datos xeográficos
axeitados. Na maioría dos casos o argumento mapfile debe proporcionarse
como "$mapfile", o que indica un accesorio co que se vai recuperar o nome do
ficheiro que sexa relevante, de tipo GeoJSON ou de tipo ESRI de forma. O
argumento opcional carga utilízase para indicar o nome dunha serie coa que
se colorean as rexións do mapa. E o argumento final de tipo feixe (bundle)
te permite que podas establecer numerosas opcións.

Podes consultar geoplot.pdf coa documentación sobre a función, para obter
detalles e exemplos completos. Aí se explican todos os axustes que se poden
configurar mediante o argumento opcions.

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

Devolve información sobre a serie especificada, que podes indicala mediante
o seu nome ou o seu número ID. O feixe 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 comprobar 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 feixe, mesmo cando o feixe é "anónimo" (non gardado co seu
propio nome).

# getkeys
Resultado:     arranxo de cadeas
Argumento:   b (feixe)

Devolve un arranxo das cadeas de texto que conteñen as chaves que
identifican o contido de b. Se o feixe está baleiro, devólvese un arranxo
baleiro.

# getline
Resultado:     escalar
Argumentos:  orixe (cadea)
            &destino (referencia a cadea)

Esta función le filas consecutivas de orixe, que debe de ser unha cadea de
texto xa definida. Con cada chamada á función escríbese unha liña de
texto en destino (que tamén debe de ser unha cadea de texto, indicada en
formato de punteiro) 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 orixe xa se leron.

A continuación preséntase un exemplo no que 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 orixe
está xa esgotado. Se non desexas esgotalo todo, podes facer unha chamada
normal a getline, seguida dunha nova chamada de "limpeza", trocando o
argumento destino por null (ou deixalo en branco), co que se reinicia a
lectura de orixe, 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 orixe non se altera con esa función; só
cambia destino.

# 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, no que 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
analíticas 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 m seguintes 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
Argumentos:  A (matriz)
            tol (escalar, opcional)

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

O resultado desta operación depende do número de valores singulares da
matriz A que numericamente se consideran iguais a 0. Podes usar o parámetro
opcional tol para retocar este aspecto. Se consideran os valores singulares
iguais a 0 cando son menores que m × tol × s, onde m é o maior valor de
entre r e c, e sendo s o que expresa o valor singular máis grande. Cando
omites o segundo argumento, establécese que tol sexa igual ao épsilon da
máquina (consulta "$macheps"). Nalgúns casos, podes desexar establecer que
tol sexa un valor máis grande (p.e. 1.0e-9) co obxecto de evitar que se
sobreestime o rango da matriz A (o que podería dar lugar a resultados
numericamente inestables).

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 b do 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 xanela de valores.

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

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 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)
            desfasam (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 podes axustar isto por medio do argumento opcional desfasam, 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, opcional)

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. Se
omites Y, aplícase a sintaxe "curta" (mira abaixo).

Se X é unha matriz r x k e Y é unha matriz r x m, o resultado vai ser unha
matriz con r filas e con k x m columnas.

Esta operación chámase "produto directo horizontal" de acordo coa forma na
que se pon en funcionamento, e se 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, ou produto "de división de
caras" (face-splitting) na literatura sobre o procesamento de sinais.

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

Sintaxe curta

Cando X e Y son a mesma matriz, entón cada fila do resultado representa a
vectorización dunha matriz simétrica. Nestes casos, podes omitir o segundo
argumento; porén, a matriz que se vai devolver conterá unicamente as
columnas non redundantes e, en consecuencia, vai ter k(k+1)/2 columnas. Por
exemplo,

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

xera

	  1    2    3    4    6    9 
	  16   20   24   25   30   36 

Cae na conta de que a i-ésima fila de C é vech(a_i a_i'), onde a_i é a
i-ésima fila de A.

Cando utilices a sintaxe curta con matrices complexas, o segundo argumento
que se suporá implícito vai ser o conxugado do primeiro, de xeito que
fará que cada fila do resultado sexa a vectorización simétrica dunha
matriz Hermitiana.

# hfdiff
Resultado:     lista
Argumentos:  hfvars (lista)
            multiplicador (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)
            multiplicador (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:  retardomin (enteiro)
            retardomax (enteiro)
            hfvars (lista)

Dada unha "MIDAS list", hfvars, a función devolve outra lista cos retardos
de alta frecuencia desde retardomin ata retardomax. Debes utilizar valores
positivos para indicar os retardos, e negativos para indicar os adiantos.
Por exemplo, se retardomin é -3, e retardomax é 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)
            prefixo (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 vixente de datos. 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 vixente.

Os nomes das series da lista que se devolve, constrúense a partir do
prefixo 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 repite o de algún obxecto xa existente,
amósase un fallo.

# hpfilt
Resultado:     serie
Argumentos:  y (serie)
            lambda (escalar, opcional)
            unha-parte (booleano, 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).

Por defecto, o filtro é o da habitual versión de dúas partes (pasado e
futuro), pero se indicas o terceiro argumento (opcional) mediante un valor
non nulo, calcúlase a variante dunha soa parte (sen ollada cara adiante) do
xeito no que se indica en Stock e Watson (1999).

O uso máis habitual do filtro HP é para a eliminación da tendencia, pero
se estás interesado na propia tendencia, é doado de obtela mediante
subtracción, como no exemplo seguinte:

	  series hptrend = y - hfilt(y)

Mira tamén "bkfilt", "bwfilt".

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

Devolve o valor da función hiperxeométrica de Gauss para o argumento real
x.

Cando x é un escalar, o valor que se devolve vai ser un escalar; doutro
xeito, vai ser unha matriz coa mesma dimensión ca x.

# I
Resultado:     matriz
Argumentos:  n (enteiro)
            m (enteiro, opcional)

Se omites m, devolve unha matriz identidade de orde n. Doutro xeito, devolve
unha matriz n x m que contén uns na diagonal principal e ceros no resto da
matriz.

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

Devolve unha matriz real coa mesma dimensión que C, que contén a parte
imaxinaria da matriz do argumento. Consulta tamén "Re".

# 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 (feixe)
            chave (cadea)

Comproba se o feixe ('bundle') b contén un elemento co nome chave. 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, 6 para un arranxo e 7 para unha
lista. 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 sabes 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; no caso de que non exista, devolve
un 0."

# instring
Resultado:     enteiro
Argumentos:  s1 (cadea)
            s2 (cadea)
            ign_mayus (booleano, opcional)

Este é un booleano relativo de "strstr": devolve 1 se s1 contén s2, e 0
noutro caso. Deste xeito, a expresión condicional

	  if instring("gatada", "gata")

é equivalente loxicamente (pero máis eficiente) ca

	  if strlen(strstr("gatada", "gata")) > 0

Se o argumento opcional ign_mayus non é cero, a procura non é sensible a
maiúsculas e minúsculas. Por exemplo:

	  instring("Gatada", "gata")

devolve 0, pero

	  instring("Gatada", "gata", 1)

devolve 1.

# instrings
Resultado:     matriz
Argumentos:  S (arranxo de cadeas)
            cotexo (cadea)

Comproba se os elementos do arranxo de cadeas de texto S son iguais a
cotexo. Devolve un vector columna de longura igual ao número de
coincidencias que se producen, e que contén a posición que ocupa cada
coincidencia dentro do arranxo (ou ben unha matriz baldeira en caso de non
haber coincidencias).

Exemplo:

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

# 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 "round", "ceil".

# interpol
Resultado:     serie
Argumento:   x (serie)

Devolve unha serie na que os valores ausentes de x se imputan mediante
interpolación linear, tanto para datos de series temporais como para a
dimensión temporal dun conxunto de datos de panel. Pero non se fai
extrapolación; os valores ausentes substitúense unicamente se están
precedidos e seguidos á vez de observacións válidas.

# 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 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 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 Manual de usuario de Gretl (Capítulo 17).

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

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

Calcula a inversa da función de distribución acumulativa. Para unha
distribución continua devolve un resultado (do tipo do argumento) co valor
de x que cumpre P(X <= x) = u, con u dentro do intervalo entre 0 e 1. Para
unha distribución discreta (Binomial ou Poisson), devolve o valor máis
pequeno de x para o que se cumpre P(X <= x) >= u.

A distribución de X especifícase por medio da letra d. Entre os argumentos
d e u, 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

  Laplace (l ou L): media, 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

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. Para matrices moi grandes, esta función é lixeiramente máis
rápida ca "inv" posto que con ela non se comproba se a matriz é
simétrica. Por esta razón, a 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:  efecto (enteiro)
            choque (enteiro)
            alfa (escalar entre 0 e 1, opcional)
            sys (feixe, opcional)

Proporciona unha matriz coas funcións estimadas de resposta ao impulso que
corresponden a un VAR ou un VECM, trazadas sobre un determinado horizonte de
predición. Sen o argumento final (opcional), esta función serve só cando
o último modelo estimado foi un VAR ou un VECM. Como alternativa, podes
gardar a información sobre un deses sistemas como feixe, mediante o
accesorio "$system", e posteriormente aplicarlle a función irf.

Os argumentos efecto e choque son índices, con formato de números
enteiros, das variables endóxenas do sistema; e se usa 0 para indicar
"todas". As respostas (expresadas nas unidades da variable efecto) o son
ante unha innovación de unha desviación padrón na variable choque. Cando
lle das un valor positivo que sexa axeitado a alfa, as estimacións inclúen
un intervalo de confianza de 1 - α (deste xeito, por exemplo, indica 0.1 se
queres obter un intervalo do 90 por cen).

O seguinte anaco de código ilustra o seu uso. No primeiro exemplo, a matriz
ir1 contén as respostas de y1 ante as innovacións en cada unha das y1, y2
e y3 (son estimacións por punto xa que se omite alfa). No segundo exemplo,
ir2 contén as respostas de todas as variables de efecto a unha innovación
en y2, con intervalos de confianza do 90 por cen. Neste caso, a matriz que
se devolve terá 9 columnas: cada vía de resposta ocupa 3 columnas
contiguas que indican a estimación por punto, o límite inferior e o
límite superior. O derradeiro exemplo produce unha matriz con 27 columnas:
3 columnas para cada resposta ante cada variable de efecto, multiplicadas
por cada unha das tres variables de choque.

	  var 4 y1 y2 y3
	  matrix ir1 = irf(1, 0)
	  matrix ir2 = irf(0, 2, 0.1)
	  matrix ir3 = irf(0, 0, 0.1)

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.

Cando se presentan os intervalos de confianza, estes xéranse mediante a
técnica de mostraxe repetida 'bootstrapping' dos erros orixinais. Asúmese
que o nivel de retardo do VAR ou do VECM xa é suficiente como para eliminar
a autocorrelación dos erros. Por defecto, o número de repeticións da
mostraxe 'bootstrap' é de 1999, pero podes axustar isto mediante a
instrución "set", como en

	  set boot_iters 2999

Mira tamén "fevd", "vma".

# 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 (positivos). Mira tamén
"npv".

# iscomplex
Resultado:     escalar
Argumento:   nome (cadea)

Comproba se nome é o identificador dunha matriz complexa. O valor que se
devolve é algún dos seguintes:

NA: nome non identifica a unha matriz.

0: nome identifica unha matriz real, na súa totalidade formada por números
normais de punto flotante ("dobres", na terminoloxía de C).

1: nome identifica unha matriz "en principio" complexa, formada por números
que teñen tanto unha parte real como outra imaxinaria, pero nos que as
partes imaxinarias son nulas.

2: a matriz en cuestión contén, cando menos, un valor "autenticamente"
complexo, con unha parte imaxinaria que non é nula.

# isconst
Resultado:     enteiro
Argumentos:  y (serie ou vector)
            codigo-panel (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 vixente 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
vixente de datos é un panel. Neste caso, un valor de codigo-panel 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:   nome (cadea)

Se nome é 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 nome 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 a 1 (ou ausentes),
devolve un enteiro co reconto 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 nas que os elementos que lles corresponden da matriz de entrada
son NaN, e 0 nas demais posicións.

# isoconv
Resultado:     enteiro
Argumentos:  data (serie)
            &ano (referencia a serie)
            &mes (referencia a serie)
            &día (referencia a serie, opcional)

Dada a serie data 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 datas
contén valores axeitados de 8 díxitos, sería:

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

Esta función devolve o valor nominal 0 no caso de completarse con éxito;
no caso de que non funcione, amósase un fallo.

# isocountry
Resultado:     mesmo tipo que o introducido
Argumentos:  orixe (cadea ou arranxo de cadeas)
            resultado (enteiro, opcional)

Esta función está relacionada coas catro notacións para países que
están incluídas no estándar ISO 3166; en concreto

1. Nome de país

2. Código alfa-2 (dúas letras maiúsculas)

3. Código alfa-3 (tres letras maiúsculas)

4. Código numérico (3 díxitos)

Cando indicas un país con algunha desas formas, o resultado é a súa
representación na forma (da 1 á 4) que escollas mediante o argumento
opcional resultado. Se omites ese argumento, a conversión por defecto faise
do xeito seguinte: cando o argumento orixe é un nome dun país, o resultado
é o código de 2 letras do país; noutro caso, o resultado é o nome do
país. Debaixo ilústranse varias solicitudes válidas con formato
interactivo.

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

Cando orixe ten a forma 4 (código numérico), isto pode indicarse mediante
unha cadea de texto ou un arranxo de cadeas (por exemplo, "032" para
Argentina) ou con formato numérico. No derradeiro caso, orixe pode
indicarse como unha serie ou como un vector, pero vaise amosar un fallo se
algún dos números está fóra do rango de 0 a 999.

En todos os casos (mesmo cando escollas o formato 4 de resultados)
devólvese unha cadea de texto ou un arranxo de cadeas; se necesitas os
valores numéricos, podes obtelos usando a función "atof". Cando orixe non
coincide con ningunha entrada da táboa ISO 3166, o resultado é unha cadea
baleira, e nese caso amósase unha advertencia.

# isodate
Resultado:     Mira máis abaixo
Argumentos:  ed (escalar ou serie)
            como-cadea (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 calendario
Gregoriano proléptico). 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 como-cadea
(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".

# isoweek
Resultado:     Mira máis abaixo
Argumentos:  ano (escalar ou serie)
            mes (escalar ou serie)
            día (escalar ou serie)

Devolve o número de semana (en formato ISO 8601) que se corresponde coa(s)
data(s) especificada(s) polos tres argumentos, ou NA se a data non é
válida. Cae na conta de que os tres argumentos deben de ser todos do mesmo
tipo, ben escalares (enteiros) ou ben series.

As semanas en formato ISO numéranse de 01 a 53. Os máis dos anos teñen 52
semanas, pero unha media de 71 de 400 anos teñen 53 semanas. A semana 01,
segundo a definición ISO 8601, é a semana que contén o primeiro xoves do
ano no calendario Gregoriano. Para obter unha explicación completa,
consulta https://en.wikipedia.org/wiki/ISO_week_date.

Admítese tamén unha solicitude alternativa: cando se indica un único
argumento, considérase que é unha data (ou unha serie de datas) en formato
numérico "básico" ISO 8601, YYYYMMDD. Deste xeito, as seguintes dúas
solicitudes xeran o mesmo resultado, concretamente 13.

	  eval isoweek(2022, 4, 1)
	  eval isoweek(20220401)

# 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)
            ruta (cadea)
            nler (referencia a escalar, opcional)

Como argumento buf deberás utilizar un búfer JSON, tal como pode
recuperarse dun sitio web adecuado por medio da función "curl"; e como
argumento ruta 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 búfer 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 para os segundos, "C" local). Se o obxecto ao que se refire a ruta
é un arranxo, os seus elementos imprímense na cadea de texto devolta, un
por cada fila.

Por defecto, amósase un fallo se ruta non coincide no búfer JSON; pero
este comportamento modifícase se indicas o terceiro argumento (opcional)
pois, neste caso, o argumento recupera un reconto das coincidencias,
devolvéndose unha cadea baleira se non hai ningunha. Chamada de exemplo:

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

Agora ben, aínda vaise amosar un fallo no caso de facer unha solicitude mal
configurada.

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
https://wiki.gnome.org/Projects/JsonGlib 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]

# jsongetb
Resultado:     feixe
Argumentos:  buf (cadea)
            ruta (cadea, opcional)

Como argumento buf deberás utilizar un búfer JSON, tal como pode
recuperarse dun sitio web adecuado por medio da función "curl". A
especificación e o efecto do argumento opcional ruta descríbese máis
abaixo.

O que se devolve é un feixe (bundle) cuxa estrutura basicamente reflicte a
da entrada: os obxectos JSON tórnanse feixes de GRETL, e os arranxos JSON
tórnanse arranxos de GRETL; cada un deles pode conter cadeas de texto,
feixes ou arranxos. Os nodos de "valor" JSON tórnanse compoñentes de
feixes ou elementos de arranxos; no último caso, os valores numéricos se
converten en cadeas de texto utilizando sprintf. Cae na conta de que, aínda
que a especificación JSON permite arranxos de tipo mixto, estes non se
poden manexar mediante jsongetb dado que os arranxos de GRETL deben ser de
tipo único.

Podes usar o argumento ruta para limitar os elementos JSON incluídos no
feixe que se devolve. Ten en conta que isto non é un "JsonPath" tal como se
describe na axuda para "jsonget"; isto é unha sinxela composición suxeita
á seguinte especificación:

  ruta é unha formación de elementos separados por unha barra, onde esta
  barra ("/") indica o desprazamento a un nivel "máis baixo" na árbore
  JSON representada por buf. Permítese unha barra inicial pero non é
  necesaria, pois implicitamente a ruta sempre comeza na raíz. Non debes de
  incluír caracteres estraños para espazos en branco.

  Cada elemento que se separa con unha barra debe de ter unha das seguintes
  formas: (a) un nome unicamente, en cuxo caso só se vai incluír un
  elemento JSON cuxo nome coincida no nivel estrutural indicado; ou (b) "*"
  (asterisco), en cuxo caso vanse incluír todos aqueles elementos do nivel
  indicado; ou (c) un arranxo de nomes separados con comas e contornados
  entre chaves ("{" e "}"), en cuxo caso só se van incluír os elementos
  JSON cuxos nomes coincidan con un dos nomes indicados.

Consulta tamén a función orientada a cadeas "jsonget"; pois, dependendo da
túa intención, unha destas funcións pódeche ser de máis axuda que a
outra.

# juldate
Resultado:     Mira máis abaixo
Argumentos:  ed (escalar ou serie)
            como-cadea (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 calendario
Gregoriano proléptico). 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 co dia na
época actual.

Cando ed é unicamente un escalar, e o segundo argumento como-cadea
(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, lista ou matriz)
            escala (escalar, opcional)
            control (booleano, opcional)

Calcula unha estimación (ou un conxunto de estimacións) da densidade
kernel para o argumento x, que pode ser unha serie única, unha lista ou
unha matriz con máis dunha columna. A matriz que se devolve ten k + 1
columnas, sendo k o número de elementos (series ou columnas) de x. A
primeira columna inclúe un conxunto de abscisas equidistantes, e o resto
das columnas inclúen a densidade (ou densidades) estimada correspondente a
cada unha delas.

O parámetro escala (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 se indica abaixo. Cae na conta de que a columna que contén as abscisas
debe ir ao final para representar a gráfica.

	  matrix d = kdensity(x)
	  # Se x ten un único elemento
	  gnuplot 2 1 --matrix=d --with-lines --fit=none
	  # Se x ten dous elementos
	  gnuplot 2 3 1 --matrix=d --with-lines --fit=none

# kdsmooth
Resultado:     enteiro
Argumentos:  &Mod (referencia a feixe)
            MSE (booleano, opcional)

Realiza o suavizado das perturbacións dun feixe de Kalman, configurado
previamente mediante a instrución "ksetup"; e devolve o enteiro 0 cando se
completa con éxito, ou un número non nulo cando se atopan problemas
numéricos. E deberías comprobar o valor que se devolve, antes de facer uso
dos resultados.

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 polas desviacións padrón
incondicionais das perturbacións suavizadas, que habitualmente se utilizan
para calcular os denominados erros auxiliares. Mais, en 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 Manual de usuario de Gretl (Capítulo
36).

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

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

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 adiantados un paso 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 Manual de usuario de Gretl (Capítulo
36).

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)
            tendenc (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 de indicar o número de observacións, e o argumento
tendenc 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:     feixe
Argumentos:  Y (serie, matriz ou lista)
            Z (escalar ou matriz)
            T (escalar ou matriz)
            Q (escalar ou matriz)
            R (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) = Za(t) + u(t)

na que Var(u) = R, e coa ecuación de transición de estado

  a(t+1) = T a(t) + v(t)

na que Var(v) = 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 Manual de
usuario de Gretl (Capítulo 36).

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

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

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

Para obter máis detalles, consulta o Manual de usuario de Gretl (Capítulo
36).

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

# ksmooth
Resultado:     enteiro
Argumento:   &Mod (referencia a feixe)

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 número non nulo cando se atopan problemas numéricos. E
deberías comprobar o valor que se devolve, antes de facer uso dos
resultados.

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
Manual de usuario de Gretl (Capítulo 36).

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)
            xretardo (booleano, opcional)

Cando o primeiro argumento é un escalar, xera os retardos do 1 ao p da
serie y. 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. Neste caso, un uso habitual 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éanse automaticamente as
variables xeradas co padrón nomevar_i, no que nomevar 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
devólvense 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 xretardo é
non nulo, 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
Argumentos:  y (serie)
            namostra (booleano, opcional)

Devolve o número enteiro positivo que indexa a última observación non
ausente da serie y. Por defecto, analízase todo o rango da mostra, de xeito
que, se está activa algunha forma de submostraxe, o valor que se devolve
pode ser maior ca o valor devolto polo accesorio "$t2". Pero se indicas un
valor non nulo en namostra, só vai terse en conta o rango da mostra
vixente. 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. Cae na conta de que isto é máis eficiente que
invocar "det" e tomar o logaritmo do resultado. Alén diso, nalgúns casos
ldet é capaz de devolver un resultado válido mesmo cando o determinante de
A é numericamente "infinito" (excedendo o número máximo de dobre
precisión da librería de C). Mira tamén "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, no que 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 de
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 na que
calquera valor ausente substitúese por valores interpolados, e na que 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 seleccionada nese
momento. 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
autocorrelación. 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 logaritmo da función Gamma
de x.

Consulta tamén "bincoeff" e "gammafun".

# loess
Resultado:     serie
Argumentos:  y (serie)
            x (serie)
            d (enteiro, opcional)
            q (escalar, opcional)
            robusta (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 robusta, 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 Manual de
usuario de Gretl (Capítulo 40) 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, no que 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.

Observa que, no caso de que o argumento sexa unha matriz, a función opera
elemento a elemento. Para a función logarítmica matricial, consulta
"mlog".

# 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 FDA
loxística deste; é dicir, 1/(1+e^-x). Se x é unha matriz, a función
aplícase a cada elemento.

# lpsolve
Resultado:     feixe
Argumento:   specs (feixe)

Soluciona un problema de programación linear, utilizando a biblioteca
lpsolve. Consulta gretl-lpsolve.pdf para obter máis detalles e exemplos de
utilización.

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

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

Mira tamén "upper".

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

Devolve unha matriz coas varianzas e covarianzas de longo prazo das columnas
da matriz A. Primeiro, aos datos se lles resta a media, agás que se asigne
un cero ao segundo argumento (opcional). Podes escoller o tipo de kernel e o
parámetro de tronzado do retardo (o tamaño da xanela), antes de chamar a
esta función mediante as opcións relacionadas co HAC que ofrece a
instrución "set", tales como hac_kernel, hac_lag, ou hac_prewhiten.
Consulta tamén a sección sobre datos de series de tempo e matrices de
covarianzas HAC no Manual de usuario de Gretl (Capítulo 22).

Mira tamén "lrvar".

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

Devolve un escalar coa varianza de longo prazo do argumento y, calculada
usando un núcleo ("kernel") de Bartlett con tamaño de xanela igual a k. Se
omites o segundo argumento (ou lle asignas un valor negativo), o tamaño da
xanela establécese por defecto igual á parte enteira da raíz cúbica do
tamaño da mostra.

Para o cálculo da varianza, a serie y se centra con respecto ao parámetro
opcional mu; e cando este se omite ou é NA, utilízase a media mostral.

Para unha contrapartida multivariante, consulta "lrcovar".

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

Resolve x en Ax = b, onde L é o factor de Cholesky triangular inferior da
matriz definida positiva A, que cumpre LL' = A. Podes obter un axeitado
factor L utilizando a función "cholesky" con A como argumento.

Os seguintes dous cálculos deberan de producir o mesmo resultado
(dependendo da precisión da máquina), pero a primeira variante permite
volver a utilizar un factor de Cholesky calculado previamente, e polo tanto
debera de ser substancialmente máis rápido se estás solucionando de xeito
repetido para unha mesma A, e distintos valores de b. O aumento da
velocidade será maior, canto maior sexa a dimensión de columnas de A.

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

# mat2list
Resultado:     lista
Argumentos:  X (matriz)
            prefixo (cadea, opcional)

Esta é unha función conveniente para elaborar unha lista de series
utilizando as columnas dunha matriz axeitada como entrada. A dimensión das
filas de X debe ser igual ben á longura do conxunto de datos vixente, ou
ben ao número de observacións do rango da mostra vixente.

As series da lista que se devolve noméanse do seguinte xeito. Primeiro,
cando se proporciona o argumento opcional prefixo, a serie creada da columna
i de X noméase engadindo i á cadea de texto proporcionada, como en
prefixo1, prefixo2, etcétera. Pola contra, se a matriz X ten un conxunto de
nomes das columnas (consulta "cnameset"), utilízanse eses nomes.
Finalmente, se non se cumpre ningunha das condicións anteriores, os nomes
son columna1, column2, etcétera.

Aquí tes un exemplo ilustrativo do seu uso:

	  matrix X = mnormal($nobs, 8)
	  list L = mat2list(X, "xnorm")
	  # ou alternativamente, se non necesitas crear a propia X
	  list L = mat2list(mnormal($nobs, 8), "xnorm")

Isto vai engadir ao conxunto de datos, oito series de longura completa
nomeadas xnorm1, xnorm2, etcétera.

# 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 na que 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 columna 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 (de Pearson), tratando cada columna da
matriz argumento X como se fose unha variable. Mira tamén "corr", "cov",
"mcov".

# mcov
Resultado:     matriz
Argumentos:  X (matriz)
            dfcorr (enteiro, opcional)

Calcula unha matriz de varianzas-covarianzas, tratando cada columna da
matriz argumento X como se fose unha variable. O divisor é n - 1, no que n
é o número de filas de X; agás que o argumento dfcorr (opcional) sexa 0,
en cuxo caso se utiliza n.

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 os 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 é a suma para j dende -p ata p de w(|j|) *
X(t)X(t-j)' * u(t)u(t-j), onde X(t)' é a t-ésima fila de X.

Se u ven indicado como nulo, os termos u omítense, e se w ven indicado como
nulo, todas as ponderacións asúmese que son 1.0.

Por exemplo, o seguinte anaco de código

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

produce este resultado:

	  ? print X Retardo Adianto
	  X (6 x 2)

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

	  Retardo (6 x 2)

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

	  Adianto (6 x 2)

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

	  ? eval X'X
	      1.8295       1.4201
	      1.4201       8.7596

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

	  ? eval X'(X + Retardo + Adianto)
	      3.0585       2.5603
	      2.5603       10.004

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

# mean
Resultado:     escalar ou serie
Argumentos:  x (serie ou lista)
            parcial (booleano, opcional)

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. Por defecto,
se hai algún valor ausente en t, a media rexístrase como NA; pero se lle
das un valor non nulo a parcial, calquera valor non ausente se usará para
crear o estatístico.

O seguinte exemplo ilustra o funcionamento da función:

	  open denmark.gdt
	  eval mean(LRM)
	  list L = dataset
	  eval mean(L)

A primeira solicitude devolverá un escalar co valor medio da serie LRM, e a
segunda devolverá unha serie.

Mira tamén "median", "sum", "max", "min", "sd", "var".

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

Devolve as medias das columnas de X, sen omitir as observacións perdidas.

Por exemplo, o seguinte anaco de código...

	  matrix m = mnormal(5, 2)
	  m[1,2] = NA
	  print m
	  eval meanc(m)

xera este resultado:

	  ? print m
	  m (5 x 2)

	   -0.098299          nan
	      1.1829      -1.2817
	     0.46037     -0.92947
	      1.4896     -0.91970
	     0.91918      0.47748

	  ? eval meanc(m)
	     0.79075          nan

Mira tamén "meanr", "sumc", "maxc", "minc", "sdc", "prodc".

# 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.

O seguinte exemplo ilustra o funcionamento da función:

	  set verbose off
	  open denmark.gdt
	  eval median(LRM)
	  list L = dataset
	  series m = median(L)

A primeira solicitude devolverá un escalar co valor mediano da serie LRM, e
a segunda devolverá unha serie.

Mira tamén "mean", "sum", "max", "min", "sd", "var".

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

Calcula a matriz exponencial dunha matriz cadrada A. Se A é unha matriz
real, utilízase para elo o algoritmo 11.3.1 de Golub e Van Loan (1996). Se
A é unha matriz complexa, o algoritmo utiliza a descomposición en
autovalores e A debe ser diagonalizable.

Consulta tamén "mlog".

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

Derivadas analíticas para as ponderacións dun 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 tipo.

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

# midasmult
Resultado:     matriz
Argumentos:  mod (feixe)
            acumular (booleano)
            v (enteiro)

Devolve o cálculo dos multiplicadores MIDAS. O argumento mod debe ser un
feixe que inclúa un modelo MIDAS, do tipo que se xera mediante a
instrución "midasreg" e que é accesible mediante a clave "$model". A
función devolve unha matriz cos multiplicadores implícitos MIDAS para a
variable v na primeira columna, e as desviacións padrón correspondentes na
segunda columna. Se o argumento acumular non é cero, os multiplicadores se
acumulan.

Observa que automaticamente fornécese a matriz que se devolve de etiquetas
adecuadas para as filas, de xeito que resultan indicadas para usar como
primeiro argumento da instrución "modprint". Por exemplo, o código

	  open gdp_midas.gdt
	  list dIP = ld_indpro*
	  smpl 1985:1 ;
	  midasreg ld_qgdp 0 ; mds(dIP, 0, 6, 2)
	  matrix ip_m = midasmult($model, 0, 1)
	  modprint ip_m

xera o seguinte resultado:

             Coeficiente   Desv. padron     z       Valor p
  ---------------------------------------------------------
  dIP_0      0.343146      0.0957752     3.583     0.0003   ***
  dIP_1      0.402547      0.0834904     4.821     1.43e-06 ***
  dIP_2      0.176437      0.0673776     2.619     0.0088   ***
  dIP_3      0.0601876     0.0621927     0.9678    0.3332
  dIP_4      0.0131263     0.0259137     0.5065    0.6125
  dIP_5      0.000965260   0.00346703    0.2784    0.7807
  dIP_6      0.00000       0.00000      NA        NA

Mira tamén "mgradient", "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 na que 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. Se ese argumento é unha serie, faise a comprobación
para cada elemento. No caso de que x sexa 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. Por exemplo, o seguinte
código

    nulldata 3
    series x = normal()
    x[2] = NA
		series x_ismiss = missing(x)
		print x x_ismiss --byobs

establece un valor ausente na segunda observación de x, e xera unha nova
serie booleana x_ismiss que identifica a observación ausente.

		             y     y_ismiss

		1    -1.551247            0
		2                         1
		3    -2.244616            0

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 elemento a elemento. Por exemplo, o seguinte código

		nulldata 3
		series x = normal()
		x[2] = NA
		y = misszero(x)
		print x y --byobs

establece un valor ausente na segunda observación de x, e xera unha nova
serie y na que se substitúe a observación ausente por un cero:

	             x            y

		1    0.7355250    0.7355250
		2                     0.000
		3   -0.2465936   -0.2465936

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, e as matrices resultantes xúntanse
horizontalmente. O seguinte código ilustra este uso, introducindo para elo
unha matriz X que ten dúas columnas, e o argumento p que indica os retardos
1 e 2. Tamén se determina que os valores ausentes teñan o valor NA, en
contraposición ao 0 establecido por defecto.

	matrix X = mnormal(5, 2)
	print X
	eval mlag(X, {1, 2}, NA)

	m (5 x 2)

	    1.5953    -0.070740
    -0.52713     -0.47669
	   -2.2056     -0.28112
	   0.97753       1.4280
	   0.49654      0.18532

	       nan          nan          nan          nan
     1.5953    -0.070740          nan          nan
	   -0.52713     -0.47669       1.5953    -0.070740
	   -2.2056     -0.28112     -0.52713     -0.47669
	   0.97753       1.4280      -2.2056     -0.28112

Consulta tamén "lags".

# mlincomb
Resultado:     serie
Argumentos:  hfvars (lista)
            theta (vector)
            tipo (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 expresión

	  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 nalgúns ciclos de uso de CPU.

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

Devolve unha matriz co logaritmo matricial de A. O algoritmo que se usa
baséase na descomposición en autovalores, polo que necesita que a matriz A
sexa diagonalizable. Consulta tamén "mexp".

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

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. Se o omites, o número de columnas establécese en 1 (vector
columna), por defecto. 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 alto grao de multicolinearidade. Podes forzar o uso da
descomposición SVD mediante a instrución set svd on.

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

# monthlen
Resultado:     mesmo tipo que o introducido
Argumentos:  mes (escalar ou serie)
            ano (escalar ou serie)
            duracsemana (enteiro)

Devolve un resultado (do mesmo tipo que o argumento) que expresa cantos
días (relevantes) ten un mes dun ano (no calendario Gregoriano
proléptico). O argumento duracsemana, que debe de ser igual a 5, 6 ou 7,
indica o número de días da semana que se deben contar (co valor 6 non se
contan os domingos, e con 5 non se contan nin os sábados nin os domingos).

O valor que se devolva vai ser un escalar se son escalares tanto mes coma
ano; noutro caso vai ser unha serie.

Por exemplo, se tes aberto un conxunto de datos mensuais, a expresión

	  series wd = monthlen($obsminor, $obsmajor, 5)

devolverá unha serie que vai conter o número de días laborables de cada
un dos meses da mostra.

# 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 un
número de observacións iniciais, de forma que a súa media tomarase como
y(0); un valor de cero para control indica que deben de tomarse todas as
observacións para calcular ese valor. 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.

# mpiallred
Resultado:     enteiro
Argumentos:  &object (referencia a obxecto)
            op (cadea)

Só dispoñible cando GRETL está en modo MPI (consulta gretl + MPI);
deberán invocalo todos os procesos. Esta función opera igual que
"mpireduce" agás polo feito de que todos os procesos (non só o proceso
principal) reciben unha copia do obxecto "reducido" en troques do orixinal.
Polo tanto, isto é equivalente ao que fai a función mpireduce seguida por
unha chamada á función "mpibcast", pero máis eficiente.

# mpibarrier
Resultado:     enteiro

Só dispoñible cando GRETL está en modo MPI (consulta gretl + MPI); non
require argumentos. Forza a sincronización dos procesos MPI: ningún
proceso pode continuar máis alá da barreira ata que a acaden todos eles.

	  # Ningún pasa ata que todos cheguen aquí
	  mpibarrier()

# mpibcast
Resultado:     enteiro
Argumentos:  &obxecto (referencia a obxecto)
            raíz (enteiro, opcional)

Só dispoñible cando GRETL está en modo MPI (consulta gretl + MPI);
deberán invocalo todos os procesos. Difunde o argumento obxecto, que
deberás indicar en forma punteiro, a todos os procesos. O obxecto en
cuestión (unha matriz, un feixe, un escalar, un arranxo unha cadea de texto
ou unha lista) debe indicarse en todos os procesos anteriores á difusión.
Ningún proceso pode continuar despois dunha chamada a mpibcast ata que
todos os procesos o consigan executar con éxito.

Por defecto, enténdese que a "raíz" ou orixe da difusión é o proceso MPI
con rango 0; pero podes axustar isto por medio do segundo argumento
(opcional), que deberá ser un número enteiro entre 0 e o número de
procesos MPI menos 1.

Deseguido temos un exemplo sinxelo. Cando se complete con éxito, cada
proceso vai ter unha copia da matriz X definida no rango 0.

	  matrix X
	  if $mpirank == 0
	      X = mnormal(T, k)
	  endif
	  mpibcast(&X)

# mpirecv
Resultado:     obxecto
Argumento:   src (enteiro)

Só dispoñible cando GRETL está en modo MPI (consulta gretl + MPI). Para
maior aclaración, consulta a función "mpisend", coa que mpirecv deberá
sempre emparellarse. O argumento src especifica a xerarquía do proceso do
que se vai recibir o obxecto, no rango que vai desde 0 ata o número de
procesos MPI menos 1.

# mpireduce
Resultado:     enteiro
Argumentos:  &obxecto (referencia a obxecto)
            op (cadea)
            raíz (enteiro, opcional)

Só dispoñible cando GRETL está en modo MPI (consulta gretl + MPI);
deberán invocalo todos os procesos. Esta función reúne obxectos
(escalares, matrices ou arranxos) cun nome determinado indicados en forma de
punteiro, de todos os procesos, e os "reduce" a un único obxecto no nodo
raíz.

O argumento op especifica a operación ou método de redución. Os métodos
admitidos para os escalares son sum (suma), prod (produto), max (máximo) e
min (mínimo). Para as matrices, os métodos son sum, prod (produto de
Hadamard), hcat (concatenación horizontal) e vcat (concatenación
vertical). Para os arranxos só se admite acat (concatenación).

Por defecto, enténdese que a "raíz" ou meta da redución é o proceso MPI
con rango 0; pero podes axustar isto por medio do terceiro argumento
(opcional), que deberá ser un enteiro entre 0 e o número de procesos MPI
menos 1.

Deseguido temos un exemplo. Cando se complete con éxito o antedito, o
proceso raíz vai ter unha matriz X que será a suma das matrices X de todos
os procesos.

	  matrix X
	  X = mnormal(T, k)
	  mpireduce(&X, sum)

# mpiscatter
Resultado:     enteiro
Argumentos:  &M (referencia a matriz)
            op (cadea)
            raíz (enteiro, opcional)

Só dispoñible cando GRETL está en modo MPI (consulta gretl + MPI);
deberán invocalo todos os procesos. Esta función distribúe anacos dunha
matriz do proceso raíz, a todos os procesos. Debes anunciar a matriz en
todos os procesos que preceden a invocar a mpiscatter, e debes indicalo en
forma de punteiro.

O argumento op debe ser, ou ben byrows ou ben bycols. Denotemos con q ao
cociente entre o número de filas da matriz que se vai dispersar, e o
número de procesos. No caso byrows, o proceso raíz vai enviar as primeiras
q filas ao proceso 0; as seguintes q ao proceso 1, etcétera. Se queda un
remanente do reparto de filas, engádese á derradeira asignación. O caso
bycols é exactamente análogo pero o reparto da matriz faise por columnas.

A continuación temos un exemplo. Se temos 4 procesos, cada un (incluído o
raíz) vai ter unha porción 2500 x 10 da X orixinal, tal como se atopaba no
proceso raíz. Se quixeras manter a matriz completa no proceso raíz, é
necesario que fagas unha copia da mesma antes de invocar a mpiscatter.

	  matrix X
	  if $mpirank == 0
	      X = mnormal(10000, 10)
	  endif
	  mpiscatter(&X, byrows)

# mpisend
Resultado:     enteiro
Argumentos:  obxecto (obxecto)
            destino (enteiro)

Só dispoñible cando GRETL está en modo MPI (consulta gretl + MPI). Envía
o obxecto indicado (unha matriz, un feixe, un arranxo, un escalar, unha
cadea de texto ou unha lista) desde o proceso vixente cara ao identificado
polo enteiro destino (desde 0 ata o número de procesos MPI menos 1).

Unha chamada a esta función debe sempre estar emparellada cunha chamada a
"mpirecv" no proceso destino, como no seguinte exemplo no que se envía unha
matriz desde o rango 2 ata o rango 3.

	  if $mpirank == 2
	      matrix C = cholesky(A)
	      mpisend(C, 3)
	  elif $mpirank == 3
	      matrix C = mpirecv(2)
	  endif

# mpols
Resultado:     matriz
Argumentos:  Y (matriz)
            X (matriz)
            &U (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 ou matriz)
            p2 (escalar ou matriz, condicional)
            p3 (escalar, condicional)
            filas (enteiro)
            columnas (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 estar seguidos por dous números
enteiros para especificar o número de filas e de columnas que vai ter a
matriz aleatoria desexada. Se indicas p1 ou p2 en forma matricial, deben ter
un número de elementos que sexa igual ao produto de filas por columnas.

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:  nomeficheiro (cadea)
            importar (booleano, opcional)

Le unha matriz gardada no ficheiro chamado nomeficheiro. Se no nome 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 establecido nese momento en "workdir". Non obstante,
cando se indica un valor non nulo para o segundo argumento importar
(opcional) da función, o ficheiro procúrase no cartafol "punto" do
usuario. Isto ten a intención de que se use esta función xunto coas que
exportan matrices, e que se ofrecen no contexto da instrución "foreign".
Nese caso, o argumento nomeficheiro debe de ser un nome de ficheiro simple,
sen indicar o camiño ata o ficheiro.

Polo de agora, a función recoñece catro formatos de ficheiro:

Formato de texto orixinal

Estes ficheiros identifícanse grazas á extensión ".mat", e son
completamente compatibles co formato de ficheiro de matriz Ox. Cando o nome
do ficheiro ten a extensión ".gz", asúmese que ao gardar os datos se
aplicou a compresión gzip. O ficheiro asúmese que é de texto plano, de
acordo coa seguinte especificación:

  O ficheiro comeza con ningún ou con un número 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 contén dous enteiros,
  separados por un carácter de tabulación, para indicar o número de filas
  e de columnas, respectivamente.

  As columnas se separan mediante tabulacións.

  O separador decimal é o carácter punto, ".".

Ficheiros binarios

Os ficheiros coa extensión ".bin" asúmese que están en formato binario. A
extensión ".gz" tamén se recoñece para a compresión gzip. 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 orde de maior columna, con formato de "dobres" en extremo menor
(little-endian). Se executas GRETL nun sistema de extremo maior
(big-endian), os valores binarios convértense a extremo menor cando se
escriben, e convértense a extremo maior cando se len.

Ficheiros con texto delimitado

Se o nome do ficheiro que se vai ler ten a extensión ".csv", as regras que
administran a lectura do ficheiro segundo o seu formato son diferentes, e
máis laxas. Neste caso, o conxunto de datos presentes non debe estar
precedido por unha liña que especifique o número de filas e de columnas.
GRETL vai tratar de determinar o delimitador utilizado (coma, espazo, ou
punto e coma), e fará o que poda para importar a matriz, permitindo o uso
da coma como separador decimal, se é necesario. Cae na conta de que o
delimitador non debe ser o carácter do tabulador, polo risco de confundir
ese tipo de ficheiros cos que teñen o formato de matrices "orixinal" de
GRETL.

Ficheiros de conxuntos de datos de GRETL

Os ficheiros que teñan extensión ".gdt" ou ".gdtb" trátanse como
ficheiros orixinais de datos de GRETL, tal como os crea a instrución
"store" (gardar). En tal caso, a matriz que se vai devolver contén os
valores numéricos das series do conxunto de datos, ordenadas en columnas.
Cae na conta de que as series con valores en cadeas de texto non se len como
tales; a matriz só vai conter as súas codificacións numéricas.

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

# mreverse
Resultado:     matriz
Argumentos:  X (matriz)
            porcolumna (booleano, opcional)

Devolve unha matriz que contén as filas de X en orde inversa; ou as
columnas en orde inversa se o segundo argumento ten un valor non nulo.

# 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 desa ecuación.

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

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 primeira 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.

Se omites o terceiro argumento, por defecto c establécese igual a 1 se X é
1 x 1; noutro caso, establécese igual a N/r onde N representa o número
total de elementos que hai en X. Porén, cando N non é un múltiplo enteiro
de r se presenta un erro.

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.

# msplitby
Resultado:     arranxo de matrices
Argumentos:  X (matriz)
            v (escalar ou matriz)
            porcolum (booleano)

Devolve un arranxo de matrices, como resultado de separar horizontal ou
verticalmente a matriz X, baixo o control dos argumentos v e porcolum. Se o
argumento porcolum non é nulo, a matriz vaise separar por columnas; noutro
caso e como predeterminado, faise por filas.

O argumento v pode ser ben un vector ou ben un escalar. No primeiro caso, o
vector debe ter unha longura igual á dimensión relevante (de filas ou de
columnas) da matriz X; amais debe conter números enteiros cun valor mínimo
de 1, e un máximo igual ao número de matrices que terá o arranxo que se
quere. Cada elemento de v representa o índice que ten no arranxo, a matriz
á que deberá asignarse a correspondente fila de X. Se, en troques, v é un
escalar, entón vaise separar a matriz X en anacos que terán v
filas/columnas cada un (segundo o esixa o argumento porcolum); e vaise
amosar un fallo se a dimensión da matriz relevante non é un múltiplo
exacto de v.

No seguinte exemplo separamos as filas dunha matriz 4 x 3 en tres matrices:
as dúas primeiras filas asígnanse á primeira matriz; a segunda matriz
déixase baleira; a terceira e cuarta matrices inclúen a terceira e cuarta
filas de X, respectivamente.

	  matrix X = {1,2,3; 4,5,6; 7,8,9; 10,11,12}
	  matrices M = msplitby(X, {1,1,3,4})
	  print M

A orde de impresión depara

	  Arranxo de matrices, longura 4
	  [1] 2 x 3
	  [2] null
	  [3] 1 x 3
	  [4] 1 x 3

O seguinte exemplo separa X equitativamente:

	  matrix X = {1,2,3; 4,5,6; 7,8,9; 10,11,12}
	  matrices MM = msplitby(X, 2)
	  print MM[1]
	  print MM[2]

que depara

	  ? print MM[1]
	  1   2   3 
	  4   5   6 

	  ? print MM[2]
	  7    8    9 
	  10   11   12 

Consulta a función "flatten" para a operación inversa.

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

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. Se o omites, o número de columnas establécese en 1 (vector
columna), por defecto. 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)
            tipo (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 tipo 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 tipo 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", "midasmult", "mlincomb".

# mwrite
Resultado:     enteiro
Argumentos:  X (matriz)
            nomeficheiro (cadea)
            exportar (booleano, opcional)

Escribe a matriz do argumento X nun ficheiro co nome nomeficheiro. 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 de
columnas separados (respectivamente) por un carácter de tabulación. Nas
seguintes filas, os elementos da matriz amósanse con notación científica,
separados por tabulacións (unha liña por fila). Para evitar confusións á
hora da súa lectura, os ficheiros que se escriban neste formato deben ser
nomeados co sufixo ".mat". Para formatos alternativos, mira máis abaixo.

Cando xa existe un ficheiro chamado nomeficheiro, vaise sobrescribir. A
execución da función devolve un valor nominal de 0 cando se completa con
éxito; se fracasa a escritura, amósase un fallo.

O ficheiro cos resultados vai escribirse no cartafol establecido como
vixente, "workdir", agás que a cadea de texto do argumento nomeficheiro
especifique o cartafol co camiño completo. Non obstante, se indicas un
valor non nulo para o argumento exportar, o ficheiro cos resultados vai
escribirse no cartafol "punto" 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 Manual de usuario de
Gretl (Capítulo 17) para obter máis detalles.

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

  Se o argumento nomeficheiro ten a extensión ".gz", entón o ficheiro
  gárdase co formato descrito máis arriba, pero usando a compresión gzip.

  Se o argumento nomeficheiro ten a extensión ".bin", entón a matriz
  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 orde de
  maior columna, con formato de "dobres" en extremo menor (little-endian).
  Se executas GRETL nun sistema de extremo maior (big-endian), os valores
  binarios convértense a extremo menor cando se escriben, e convértense a
  extremo maior cando se len.

  Se o argumento nomeficheiro ten a extensión ".csv", entón a matriz
  gárdase con formato de separación con comas, sen a liña de
  encabezamento que indique o número de filas e de columnas que a seguen.
  Isto podería facer máis doado o tratamento con programas de terceiros,
  pero non se recomenda cando se pretende ler o ficheiro cos elementos da
  matriz por medio de GRETL.

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". Para escribir unha matriz nun ficheiro, como conxunto
de datos, consulta "store".

# 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, opcional)
            LOO (booleano, opcional)
            recorte (escalar, opcional)

Calcula 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 m(x_i),
os valores das estimacións de E(y_i|x_i) para cada un dos elementos non
ausentes da serie x.

A función núcleo (kernel) empregada por este estimador dada por K =
exp(-x^2/2h) cando |x|<T, e é igual a cero noutro caso. (T = Parámetro de
recorte.)

Os tres argumentos opcionais modulan o comportamento do estimador tal como
se describe máis abaixo.

Ancho de banda

Podes usar o argumento h para controlar o ancho de banda ("bandwidth"),
mediante un 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 é facer que h sexa proporcional a n^-0.2. Se omites h ou o igualas
a cero, o ancho de banda establécese por defecto cun valor determinado
polos datos, utilizando a proporcionalidade que se acaba de mencionar, pero
introducindo a dispersión dos datos de x tal como a mide o rango
inter-cuartil ou a desviación padrón; consulta o Manual de usuario de
Gretl (Capítulo 40) para obter máis detalles.

Deixar-unha-fóra

"Deixar-unha-fóra" é unha variante do algoritmo, que omite a observación
i-ésima cando se avalía m(x_i). Isto fai que o estimador de
Nadaraya-Watson sexa numericamente máis robusto, e por iso recoméndase
habitualmente utilizalo cando o estimador se calcula con intención de facer
inferencias. Esta variante non está permitida por defecto, pero actívase
cando se indica un valor non nulo para o argumento LOO.

Recorte

Podes usar o argumento recorte para controlar o grao de "recorte" que se
impón para previr problemas numéricos, cando a función 'kernel' se está
a avalíar demasiado lonxe do cero. Este parámetro exprésase como un
múltiplo de h, sendo 4 o valor por defecto. Nalgúns casos, pode ser
preferible utilizar un valor maior ca 4. De novo, consulta o Manual de
usuario de Gretl (Capítulo 40) para obter máis detalles.

Consulta tamén "loess".

# 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)
            maxavalfunc (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 vixentes 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; se 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
maxavalfunc. 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 Manual de usuario de Gretl
(Capítulo 37). 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
vixente seleccionada.

Mira tamén "pnobs", "pxnobs".

# 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)
            método (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 método (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)
            método (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 vixentes 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 Manual de usuario de Gretl
(Capítulo 37). 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 b como primeiro argumento
(ben directamente ou ben en forma de punteiro), seguido de calquera
argumento adicional que poida ser necesario, e debe 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 determinar o tamaño do paso 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, correspondendo o 1 co
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 ou arranxo de cadeas
Argumento:   t (escalar ou vector)

Se t é un escalar, devolve unha única cadea de texto que representa o
marcador de etiquetado da observación t. Podes facer a operación inversa
mediante a función "obsnum".

Se t é un vector, devolve un arranxo de cadeas de texto que representan os
marcadores de etiquetado das observacións indicadas polos elementos de t.

De todos os xeitos, os valores t deben ser enteiros que podan resultar
válidos como índices enteiros das observacións no conxunto de datos
vixente; noutro caso, amósase un aviso de fallo.

# obsnum
Resultado:     enteiro
Argumento:   s (cadea)

Devolve o número enteiro que indica a observación que se corresponde coa
cadea do argumento s. Ten en conta que o resultado non vai depender de que
teñas escollida unha submostra. Esta función é útil con conxuntos de
datos de series 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, 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 nas que os elementos non
son finitos (ou ben infinitos, ou ben "non números", para o 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, opcional)

Devolve unha matriz con r filas e c columnas, cuberta con valores iguais a
1. Se o omites, o número de columnas establécese en 1 (vector columna),
por defecto.

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

# orthdev
Resultado:     serie
Argumento:   y (serie)

Aplícase tan só se o conxunto vixente de datos 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 adiantadas un paso 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, Beta,
Exponencial, Weibull, Laplace, 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 centrales.

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

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

Se só indicas a serie ou vector do primeiro argumento, calcúlase 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 vixente de datos 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)
vixente 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)
            máscara (serie, opcional)

Aplícase tan só se o conxunto vixente de datos 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
temporais de cada unha destas).

Cando indicas o segundo argumento (opcional), vanse ignorar aquelas
observacións nas que o valor de máscara sexa igual a cero.

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

# pmean
Resultado:     serie
Argumentos:  y (serie)
            máscara (serie, opcional)

Aplícase tan só se o conxunto vixente de datos 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 nas que o valor de máscara sexa igual a cero.

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

# pmin
Resultado:     serie
Argumentos:  y (serie)
            máscara (serie, opcional)

Aplícase tan só se o conxunto vixente de datos 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 nas que o valor de máscara sexa igual a cero.

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

# pnobs
Resultado:     serie
Argumentos:  y (serie)
            máscara (serie, opcional)

Aplícase tan só se o conxunto vixente de datos 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 nas que o valor de máscara sexa igual a cero.

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

# polroots
Resultado:     matriz
Argumento:   a (vector)

Devolve as 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.

O valor que se devolve é un vector columna complexo con longura igual a p.

# 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)
            matrizcov (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 cos 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)
            máscara (serie, opcional)

Aplícase tan só se o conxunto vixente de datos ten unha estrutura de
panel, e devolve unha serie que contén a desviación padrón (na mostra) da
variable y 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 nas que o valor de máscara 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
Argumentos:  A (matriz simétrica)
            probapsd (booleano, opcional)

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 como iguais a cero.

Para forzar a comprobación de que A é semidefinida positiva, indica un
valor non nulo para o segundo argumento (opcional). Nese caso, amósase un
fallo se o máximo valor absoluto de A - LL' pasa de 1.0e-8. Este tipo de
comprobación tamén podes facela manualmente:

	  L = psdroot(A)
	  chk = maxc(maxr(abs(A - L*L')))

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 vixente de datos 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 do panel, ao longo
do rango da mostra vixente. Se a serie ten algunha unidade 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)
            máscara (serie, opcional)

Aplícase tan só se o conxunto vixente de datos 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 nas que o valor de máscara 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, Laplace e
Erro Xeneralizado.

Mira tamén "critical", "invcdf", "urcpval", "imhof".

# pxnobs
Resultado:     serie
Argumentos:  y (serie)
            máscara (serie, opcional)

Aplícase tan só se o conxunto vixente de datos 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 nas que o valor de máscara 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)
            máscara (serie, opcional)

Aplícase tan só se o conxunto vixente de datos 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 nas que o valor de máscara 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 de 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)
            &P (referencia a matriz, ou null)

Devolve unha matriz co cálculo dunha "tenue" descomposición QR dunha
matriz X de orde m x n sendo m >= n, de xeito que 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).

Se indicas o terceiro argumento (opcional), a descomposición utiliza o
pivotado de columnas e, cando se completa con éxito, P contén a
ordenación final das columnas en forma dun vector fila. Se as columnas non
están realmente reordenadas, P vaise equipar a "seq"(1, n).

Mira tamén "eigengen", "eigensym", "svd".

# quadtable
Resultado:     matriz
Argumentos:  n (enteiro)
            tipo (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 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. Supoñamos 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 -1 e 1. (Na cuadratura
de Hermite, os límites están fixados en menos e máis infinito; mentres
que no caso da cuadratura de Laguerre, están fixados en 0 e 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 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.

Hyndman e Fan (1996) describen nove métodos distintos para calcular os
cuantís da mostra. En GRETL, por defecto, o método é o que eles denominan
Q_6 (que tamén o é en Python, por defecto). En troques, podes seleccionar
os métodos Q_7 (que é o usado por defecto en R) ou Q_8 (que é o
recomendado por Hyndman e Fan) mediante a instrución "set", como en

	  set quantile_type Q7 # ou Q8

Por exemplo, o código

	  set verbose off
	  matrix x = seq(1,7)'
	  set quantile_type Q6
	  printf "Q6: %g\n", quantile(x, 0.45)
	  set quantile_type Q7
	  printf "Q7: %g\n", quantile(x, 0.45)
	  set quantile_type Q8
	  printf "Q8: %g\n", quantile(x, 0.45)

produce o seguinte resultado:

	  Q6: 3.6
	  Q7: 3.7
	  Q8: 3.63333

# 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 números pseudoaleatorios. Os argumentos de p1 a 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

  Loxística (lgt ou s): posición, escala

  Weibull (w ou W): forma, escala

  Laplace (l ou L): media, 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 o 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".

# randperm
Resultado:     vector
Argumentos:  n (enteiro)
            k (enteiro, opcional)

Se indicas só o primeiro argumento, devolve un vector fila que contén unha
permutación aleatoria dos números enteiros desde 1 ata ese valor n, sen
repetición dos elementos. Cando indiques o segundo argumento, deberá ser
un número enteiro positivo dentro do rango de 1 a n; nese caso a función
devolve un vector fila que contén k número enteiros escollidos de xeito
aleatorio desde 1 ata n, sen substitución.

Se queres extraer unha mostra de k filas dunha matriz X que ten n filas (e
sen substitución), iso podes conseguilo tal como se amosa debaixo:

	  matrix S = X[randperm(n, k),]

E se desexas manter a orde orixinal das filas na mostra:

	  matrix S = X[sort(randperm(n, k)),]

Consulta tamén a función "resample" para repetir a mostraxe, con
substitución.

# rank
Resultado:     enteiro
Argumentos:  X (matriz)
            tol (escalar, opcional)

Devolve un enteiro co rango da matriz X de orde r x c, calculado
numericamente mediante a descomposición en valores singulares.

O resultado desta operación é o número de valores singulares da matriz X
que numericamente se consideran maiores que 0. O parámetro opcional tol
podes usalo para retocar este aspecto. Vaise considerar que os valores
singulares non son nulos cando resultan ser maiores que m × tol × s, onde
m é o maior valor de entre r e c, sendo s o que expresa o valor singular
máis grande. Cando omites o segundo argumento, establécese que tol sexa
igual ao épsilon da máquina (consulta "$macheps"). Nalgúns casos, podes
desexar establecer que tol sexa un valor máis grande (p.e. 1.0e-9) co
obxecto de evitar que se sobreestime o rango da matriz X (o que podería dar
lugar a resultados numericamente inestables).

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, no que 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".

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

Devolve unha matriz real coa mesma dimensión que C, e que contén a parte
real da matriz dese argumento. Consulta tamén "Im".

# readfile
Resultado:     cadea
Argumentos:  nomeficheiro (cadea)
            código (cadea, opcional)

Se existe (e pode lerse) un ficheiro co nome do argumento nomeficheiro, a
función devolve unha cadea de texto que inclúe o contido dese ficheiro;
noutro caso amosa un fallo. Se nomeficheiro non indica unha especificación
da ruta completa ao ficheiro, vaise procurar en distintas localizacións
"probables", comezando polo cartafol vixente nese momento, "workdir". Cando
o ficheiro en cuestión está comprimido con gzip, manéxase do xeito
evidente.

Se nomeficheiro 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 vixente de codificación local
(se este non é UTF-8), ou desde ISO-8859-15 noutro caso. Se este sinxelo
funcionamento por defecto non cumpre coas 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)
            atopada (cadea)
            substit (cadea)

Devolve unha cadea de texto cunha copia de s na que todos os casos nos que
ocorre o padrón atopada, substitúense por substit. Os dous argumentos
atopada e substit 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:   nomeficheiro (cadea)

Se o ficheiro do argumento nomeficheiro existe e se o usuario o pode
modificar, esta función o elimina e devolve un 0. Se non existe o ficheiro,
ou non pode eliminarse por algunha razón, a función devolve un código non
nulo indicando un fallo.

Cando nomeficheiro non especifica a ruta completa, entón asúmese que o
ficheiro ao que se refire, está no cartafol vixente de traballo
("workdir").

# replace
Resultado:     mesmo tipo que o introducido
Argumentos:  x (serie ou matriz)
            achar (escalar ou vector)
            substit (escalar ou vector)

Devolve un resultado (do tipo de) x trocando os seus elementos que sexan
iguais ao elemento i-ésimo de achar polo concordante de substit.

Cando o segundo argumento (achar) é un escalar, o terceiro argumento
(substit) tamén debe de ser un escalar. Cando ambos son vectores, deben de
ter o mesmo número de elementos. Pero cando achar é un vector e substit é
un escalar, entón todas as coincidencias de aquel substitúense en x por
substit.

Exemplo:

	  a = {1,2,3;3,4,5}
	  acha = {1,3,4}
	  subst = {-1,-8, 0}
	  b = replace(a, acha, 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)
            tamañobloque (enteiro, opcional)
            extraccions (enteiro, opcional)

A descrición inicial desta función refírese aos casos con datos de corte
transversal ou con series temporais; 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 vaise obter das filas de x que
teñen a mesma probabilidade. Consulta tamén "randperm" para extraer unha
mostra de filas dunha matriz sen substitución.

O argumento tamañobloque (opcional) representa o tamaño do bloque para
facer a mostraxe por repetición movendo bloques. Cando se indique 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
tamañobloque 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ónzase para que se axuste.

Número de extraccións

Por defecto, o número de observacións que se volven extraer para acadar o
resultado é igual ó do argumento indicado -- se x fose unha serie, sería
a longura do rango mostral vixente; se x fose unha matriz, sería o número
das súas filas. No caso matricial, só podes axustar isto por medio do
terceiro argumento (opcional), que deberá ser un número enteiro positivo.
Cae na conta de que se o argumento tamañobloque é maior ca 1, o argumento
extraccions refírese ao número de observacións individuais, non ao
número de bloques.

Datos de panel

Cando o argumento x é unha serie, e o conxunto de datos ten 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 xeito 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".

# rnameget
Resultado:     cadea ou arranxo de cadeas
Argumentos:  M (matriz)
            r (enteiro, opcional)

Se indicas o argumento r, devolve unha cadea co nome da fila r da matriz M.
Se as filas de M non teñen nome, entón devólvese unha cadea baleira; e se
r está fóra dos límites do número de filas desta matriz, amósase un
fallo.

Se non indicas o segundo argumento, devolve un arranxo de cadeas de texto
que contén os nomes das filas de M, ou un arranxo baleiro se a matriz non
ten asignados nomes para as súas filas.

Exemplo:

	  matrix A = { 11, 23, 13 ; 54, 15, 46 }
	  rnameset(A, "Primeira Segunda")
	  string name = rnameget(A, 2)
	  print name

Mira tamén "rnameset".

# rnameset
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 elementos. Admítese tamén que indiques unha única cadea
de texto como segundo argumento; neste caso esta deberá de ter m subcadeas
de texto separadas por espazos.

Se devolve o valor nominal 0 cando as filas se nomean con éxito; en caso de
fracaso, amósase un fallo. Consulta tamén "cnameset".

Exemplo:

	  matrix M = {1, 2; 2, 1; 4, 1}
	  strings S = array(3)
	  S[1] = "Fila1"
	  S[2] = "Fila2"
	  S[3] = "Fila3"
	  rnameset(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".

# schur
Resultado:     matriz complexa
Argumentos:  A (matriz complexa)
            &Z (referencia a matriz, ou null)
            &w (referencia a matriz, ou null)

Realiza a descomposición de Schur da matriz complexa A do argumento,
devolvendo unha matriz triangular superior complexa T. Cando indicas un
segundo argumento que non sexa null (nulo), recolle unha matriz complexa Z
que contén os vectores de Schur asociados a A e T, tales que A = ZTZ^H.
Cando indicas o terceiro argumento, recolle os autovalores da matriz A nun
vector columna complexo.

# sd
Resultado:     escalar ou serie
Argumentos:  x (serie ou lista)
            parcial (booleano, opcional)

Se x é unha serie, a función devolve un escalar coa súa 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. Por defecto, se hai algún valor ausente en t, a desviación
padrón rexístrase como NA; pero se lle das un valor non nulo a parcial,
calquera valor non ausente se usará para crear o estatístico.

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 vixente de datos (consulta "$pd"
ou "$panelpd"). 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_nomevar, no que nomevar 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:  base (enteiro, opcional)
            centro (booleano, opcional)

Aplícase tan só se o conxunto vixente de datos 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 base (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 centro, 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.

Con datos de frecuencia semanal, o resultado concreto depende de se os datos
teñen data ou non. Se teñen data, créanse ata 53 series estacionais,
baseadas no número de semana ISO 8601 (consulta "isoweek"); se non a
teñen, o número máximo de series é 52 (e ao longo dun período
prolongado as series "estacionais" vanse desfasar co ano do calendario). No
caso de ter datos semanais, se desexas xerar series estacionais mensuais
podes facelo do seguinte xeito:

	  series month = $obsminor
	  list months = dummify(month)

Para obter máis detalles, consulta "dummify".

# 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 de 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 de 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
(sumando 1) desde a ata b, se o primeiro argumento é menor ca o segundo; ou
coa secuencia decrecente (restando 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 (feixe)
            clave (cadea)
            nota (cadea)

Insire unha nota descritiva para un obxecto que se identifica pola clave,
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 clave no feixe b).

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

Devolve a función signo de x; é dicir, 0 se x é cero, 1 se x é positivo,
-1 se x é negativo, ou NA se x é Non Numérico.

# 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 obter máis detalles e un exemplo, consulta o Manual de usuario de
Gretl (Capítulo 37). 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 (escalar)

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 vixente (é dicir, que se pare)
durante ns segundos. O argumento debe ser un escalar non negativo. Ao
"espertar", a función devolve o escalar 0.

# smplspan
Resultado:     escalar
Argumentos:  obsinicio (cadea)
            obsfin (cadea)
            pd (enteiro)

Devolve o número de observacións que hai contando desde obsinicio ata
obsfin (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 5 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, vector ou arranxo de cadeas)

Devolve un resultado do tipo de x cos valores ordenados de forma ascendente.
As observacións con valores ausentes se descartan cando x é unha serie,
pero ordénanse no final se x é un vector. 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".

# sphericorr
Resultado:     matriz
Argumentos:  X (matriz)
            modo (enteiro)
            &J (referencia a matriz, ou null)

Permite facer a representación en coordenadas esféricas dunha matriz de
correlacións, ou a operación inversa, dependendo do valor do parámetro
modo.

Cando se omite modo, ou é igual a 0, asúmese que X é unha matriz de
correlacións de orde n x n. O valor que se devolve é un vector que ten
n(n-1)/2 elementos entre 0 e pi. Neste modo, ignórase a referencia a J.

Cando modo é igual a 1 ou a 2, realízase a transformación inversa, polo
que X debe ser un vector que teña n(n-1)/2 elementos entre 0 e pi. O valor
que se devolve agora é a matriz R de correlacións cando a opción modo é
igual a 1; ou o seu factor K de Cholesky cando modo é igual a 2. Nestes
casos, cando se indica, o punteiro opcional á matriz J permite recuperar o
Xacobiano de vech(R) ou de vech(K) con respecto a X.

Cae na conta de que a representación en coordenadas esféricas fai moi
sinxelo o cálculo do log-determinante da matriz de correlacións R:

	 omega = sphericorr(X)
	 log_det = 2 * sum(log(sin(omega)))

# sprintf
Resultado:     cadea
Argumentos:  formato (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 formato. Ten a intención de darte
gran flexibilidade para crear cadeas de texto. Utiliza formato para indicar
o xeito preciso no que queres que se presenten os argumentos.

En xeral, o argumento formato debe de ser unha expresión que se corresponda
cunha 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.

A expresión %d na cadea de formato, indica que se quere un número enteiro
nese preciso lugar da saída que se vai presentar, e dado que esa é a
expresión co símbolo "por cento" que está máis á esquerda, emparéllase
co primeiro argumento, é dicir 5. A segunda secuencia especial é %6.4f, e
representa un valor con 6 díxitos de largo como mínimo, e con 4 díxitos
despois do separador decimal. 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. Para a "raíz cadrada matricial" consulta "cholesky".

# square
Resultado:     lista
Argumentos:  L (lista)
            produtos-cruz (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_nomevariable.
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:  orixe (cadea ou arranxo de cadeas)
            formato (cadea)
            ... (Mira máis abaixo)

Le valores indicados polo argumento orixe baixo o control do argumento
formato, 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, cunha extensión para escanear unha
matriz enteira, e que se describe máis abaixo baixo o título "Escaneando
unha matriz". Ten en conta que indicar un arranxo de cadeas de texto como
orixe só se acepta no caso de que escanees unha matriz.

Como argumento orixe podes usar unha cadea de texto literal contornada entre
comiñas, ou ben o nome dunha cadea de texto que definiras previamente. O
argumento formato indícase de xeito similar á cadea do argumento "formato"
en "printf" (mira máis abaixo); nesta última función, elementos debe de
ser unha lista de variables definidas antes, separadas por comas e que son
os obxectivos da conversión de orixe. (Para os afeitos a C: podedes fixar
previamente os nomes das variables numéricas con &, pero non se esixe.)

O texto literal no argumento formato compárase con orixe. 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; e %s para cadeas de texto. 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. 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, doutro xeito, podería terse convertido ao tipo
indicado). Por exemplo, a expresión %3d converte os seguintes 3 caracteres
de orixe nun enteiro, en caso de que sexa posible; e a expresión %*g
permite saltarse tantos caracteres de orixe como os que poderían
converterse nun número de punto flotante simple.

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 De seguido indícanse
varios exemplos:

	  # Escaneando valores escalares
	  scalar x
	  scalar y
	  sscanf("123456", "%3d%3d", x, y)
	  # Escaneando valores de cadea de texto
	  string s = "un dous"
	  string s1
	  string s2
	  sscanf(s, "%s %s", s1, s2)
	  print s1 s2

Escaneando unha matriz

O escaneado de matrices debe sinalarse mediante a especificación especial
de conversión, "%m". Podes indicar o número máximo de filas a ler,
inserindo un número enteiro entre o signo "%" e a "m" indicativa de matriz.
Se permiten dúas variantes: que orixe indique unha cadea de texto única
que represente unha matriz, e que orixe indique un arranxo de cadeas de
texto. Estas opcións descríbense de vez.

Se orixe é un argumento de cadea de texto única, o escáner le unha liña
da entrada e conta o número de campos numéricos (separados por espazo ou
por tabulador). Isto define o número de columnas da matriz. Por defecto, o
proceso de lectura continúa con todas as liñas (filas) que conteñan o
mesmo número de columnas numéricas, mais o número máximo de filas pode
limitarse mediante o valor enteiro opcional mencionado antes.

Se orixe é un arranxo de cadeas de texto, o resultado vai ser forzosamente
un vector columna, do que cada elemento vai ser a conversión numérica da
cadea correspondente, ou NA se a cadea de texto non representa un número. A
continuación, tes varios exemplos:

	  # Escaneando unha única cadea de texto
	  string s = sprintf("1 2 3 4\n5 6 7 8")
	  print s
	  matrix m
	  sscanf(s, "%m", m)
	  print m
	  # Escaneando un arranxo de cadeas de texto
	  strings S = defarray("1.1", "2.2", "3.3", "4.4", "5.5")
	  sscanf(S, "%4m", m)
	  print m

# sst
Resultado:     escalar
Argumento:   y (serie)

Devolve un escalar coa suma dos cadrados das desviacións respecto á media
(SCT), das observacións non ausentes da serie y. Mira tamén "var".

# stack
Resultado:     serie
Argumentos:  L (lista)
            n (enteiro)
            desprazamento (enteiro, opcional)

Deseñado para o manexo de datos no formato de series de tempo encasteladas,
que necesita GRETL para datos de panel. O valor que se devolve é unha serie
que se obtén encastelando de forma "vertical", grupos de n observacións de
cada serie da lista L. Por defecto, se usan as primeiras n observacións
(iso se corresponde con desprazamento = 0), pero podes trasladar o punto de
inicio indicando un valor positivo para desprazamento. Se a serie resultante
fose máis longa que o conxunto de datos vixente, engádense tantas
observacións como sexan necesarias.

Con esta función podes manexar o caso dun ficheiro de datos que conteña
series de tempo colocadas unhas a carón das outras, para un grupo de
unidades de sección cruzada. E tamén cando se considera o tempo en sentido
horizontal, e cada fila representa unha unidade atemporal.

Consulta a sección titulada "Panel data specifics" no Manual de usuario de
Gretl (Capítulo 4) para obter detalles e exemplos do seu uso.

# stdize
Resultado:     mesmo tipo que o introducido
Argumentos:  X (serie, lista ou matriz)
            v (enteiro, opcional)

Por defecto, devolve un resultado do mesmo tipo que o argumento, coa
versión tipificada desa serie, lista ou matriz: o argumento céntrase e
divídese pola súa desviación padrón mostral (con corrección de 1, nos
graos de liberdade). No caso de que o argumento sexa unha matriz, os
resultados calcúlanse por columnas.

Podes usar o segundo argumento (opcional) para modular o resultado. Un valor
non negativo dese v permite configurar a corrección nos graos de liberdade
que se utilizan para a desviación padrón; así v = 0 solicita utilizar o
estimador máximo-verosímil. Como caso especial, se estableces que v sexa
igual a -1, unicamente se vai centrar o primeiro argumento.

# strftime
Resultado:     cadea
Argumentos:  tm (escalar)
            formato (cadea, opcional)

O argumento tm utilízase para proporcionar o número de segundos dende o
inicio do ano 1970, de acordo co UTC (Tempo Universal Coordinado, antes
coñecido como tempo medio de Greenwich). O valor que se devolve é unha
cadea de texto que proporciona a data e/ou hora correspondente, ben nun
formato especificado mediante o segundo argumento (opcional) ou ben, por
defecto, mediante a "representación preferida de data e hora no entorno
local vixente" tal como determinaría a biblioteca do sistema C.

Aviso: Esta función compórtase de xeito distinto en sistemas operativos de
Windows e de tipo Unix para as datas anteriores ao 1 de xaneiro de 1970. Nos
sistemas de tipo Unix (Linux, macOS), podes usar argumentos negativos para
representar esas datas, de modo que os valores negativos dan como resultado
cadeas de texto coas datas normais; en Windows, non se admiten esas datas,
polo que o valor do resultado é unha cadea nula.

Podes obter valores axeitados de tm para utilizar con esta función mediante
o accesorio "$now" ou a función "strptime".

Podes atopar as opcións de formato consultando as páxinas sobre strftime
do manual, en sistemas que as teñan; ou por medio dun dos moitos sitios web
que presentan información relevante, como por exemplo
https://devhints.io/strftime.

# 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. Se non se cumpre algunha destas condicións,
amósase un fallo.

O valor nominal que devolve esta función é cero, cando se completa con
éxito.

Mira tamén "strvals".

Unha alternativa a stringify que te pode ser de utilidade nalgúns contextos
é a asignación directa dun arranxo de cadeas de texto a unha serie: isto
xera unha serie cuxos valores se toman da serie de forma secuencial; o
número de elementos do arranxo debe ser igual, ben á longura total do
conxunto de datos ou ben á longura do rango da mostra vixente, e os valores
pódense repetir como sexa necesario.

# strlen
Resultado:     enteiro
Argumento:   s (cadea ou arranxo de cadeas)

Se s é unha cadea de texto simple, devolve a cantidade de caracteres UTF-8
que contén. Ten en conta que iso non é igual ao número de bytes, se
algúns caracteres están fóra do intervalo de impresión ASCII. Cando
desexes obter o número de bytes, podes usar a función "nelem". Por
exemplo:

	  string s = "Olé!"
	  printf "strlen(s) = %d, nelem(s) = %d\n", strlen(s), nelem(s)

debera devolver

	  strlen(s) = 5, nelem(s) = 7

Se o argumento é un arranxo de cadeas de texto, o valor que se devolve é
un vector columna que contén o número de caracteres de cada cadea. Tamén
se acepta que uses como argumento unha serie con cadeas de valores; nese
caso, o valor que se devolve é unha serie que contén a longura das cadeas
de valores ao longo do rango mostral vixente.

# 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)....

# strptime
Resultado:     escalar
Argumentos:  s (cadea)
            formato (cadea)

Esta función é a recíproca de "strftime". Analiza a cadea de texto s que
expresa tempo ou data, utilizando o formato especificado; e devolve un
escalar que proporciona o número de segundos transcorridos dende o inicio
de 1970 segundo o Tempo Universal Coordinado (UTC).

Aviso: Esta función compórtase de xeito distinto en sistemas operativos de
Windows e de tipo Unix para as datas anteriores ao 1 de xaneiro de 1970. Nos
sistemas de tipo Unix (Linux, macOS), devólvense intervalos negativos de
tempo en segundos; en Windows, non se admiten esas datas, polo que o valor
que se devolve é NA.

Podes atopar as opcións de formato consultando a páxina sobre strptime do
manual, en sistemas que dispoñan das mesmas; ou por medio dun dos moitos
sitios web que presentan información relevante, como por exemplo
http://man7.org/linux/man-pages/man3/strptime.3.html.

O exemplo de debaixo amosa como podes converter información de datas dun a
outro formato.

	  scalar tm = strptime("Sunday 17/02/19", "%A %d/%m/%y")
	  eval strftime(tm) # Resultado por defecto
	  eval strftime(tm, "%A, %d de %B de %Y")

No entorno local galego (España), o resultado é

	  17/02/2019 0:00:00
	  domingo, 17 de febreiro de 2019

# strsplit
Resultado:     cadea ou arranxo de cadeas
Argumentos:  s (cadea)
            sep (cadea, opcional)
            i (enteiro, opcional)

No seu funcionamento básico, cun único argumento, devolve o arranxo de
cadeas de texto que resulta ao separar o contido de s conforme aos espazos
baleiros que ten (é dicir, conforme a calquera combinación dos caracteres
de espazo, tabulación e/ou liña nova).

Podes utilizar o segundo argumento (opcional) para especificar o separador
que se usa para separar s. Por exemplo...

	  string Cesta = "Plátano,Mazá,Yaca,Laranxa"
	  strings S = strsplit(Cesta,",")

vai separar o primeiro argumento da función nun arranxo de catro cadeas de
texto, usando a coma como elemento separador.

As secuencias de barra diagonal esquerda para escapar, indicadas mediante
"\n", "\r" e "\t", considérase que representan unha liña nova, un salto de
liña e unha tabulación cando se indican no argumento opcional sep. Se
queres incluír unha barra diagonal esquerda literal como carácter
separador, debes de duplicala como en "\\". Exemplo:

	  string s = "c:\fiddle\sticks"
	  strings S = strsplit(s, "\\")

Con independencia do separador, aos elementos do arranxo que se devolve, se
lles recorta calquera espazo en branco ao comezo ou ao final. En
consecuencia, se sep contén caracteres que non son espazos en branco,
entón se lle quita calquera espazo ao comezo ou ao final.

Cando indicas un valor enteiro maior ca cero como terceiro argumento, o
valor que se devolve é unha única cadea de texto; en concreto, o elemento
i (en base 1) do arranxo que se xeraría doutro xeito sen ese terceiro
argumento. Cando i sexa menor ca 1, se produce un fallo; mais cando i excede
o número de elementos implicados, devólvese unha cadea de texto baleira.

# strstr
Resultado:     cadea
Argumentos:  s1 (cadea)
            s2 (cadea)
            ign_mayus (booleano, opcional)

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

Se o argumento opcional ign_mayus non é cero, a procura non é sensible a
maiúsculas e minúsculas. Por exemplo:

	  strstr("Bilbao", "b")

devolve "bao", pero

	  strstr("Bilbao", "b", 1)

devolve "Bilbao".

Se unicamente queres descubrir se s1 contén a s2 (proba booleana), consulta
"instring".

# 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 ou arranxo de cadeas)
            atopada (cadea)
            substit (cadea)

Devolve unha cadea de texto cunha copia de s na que se substituíu toda a
cadea atopada por substit. 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
Argumentos:  y (serie)
            submostra (booleano, opcional)

Cando a serie y se compón de cadeas de texto que expresan valores, esta
función devolve por defecto un arranxo que contén todos eses valores (con
independencia do rango mostral que estea vixente), ordenados numericamente
comezando polo 1. Se está vixente unha submostra do conxunto de datos,
podes proporcionar un valor non nulo para o segundo argumento (opcional) e
obter deste xeito un arranxo que conteña só as cadeas de texto presentes
na submostra.

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".

Unha alternativa a strvals que te pode ser de utilidade nalgúns contextos
é a asignación directa dunha serie con valores de cadeas de texto a un
arranxo de cadeas de texto: isto non só proporciona os valores que sexan
diferentes, senón tódolos valores da serie no rango da mostra vixente.

# substr
Resultado:     cadea
Argumentos:  s (cadea)
            inicio (enteiro)
            fin (enteiro)

Devolve a subcadea do argumento s, comezando no carácter indicado polo
enteiro positivo de inicio, e rematando no indicado polo de fin, ambos
incluídos; ou desde inicio ata o remate de s se fin é igual a -1.

Por exemplo, o código de abaixo

          string s1 = "Hola, GRETL!"
          string s2 = substr(s1, 7, 11)
          print s2

proporciona:

    ? print s2
    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
Argumentos:  x (serie, matriz ou lista)
            parcial (booleano, opcional)

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. Por defecto, se hai algún valor ausente en t, a suma
rexístrase como NA; pero se lle das un valor non nulo a parcial, calquera
valor non ausente se usará para crear a suma.

# 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 o 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".

# svm
Resultado:     serie
Argumentos:  L (lista)
            bparms (feixe)
            bmod (referencia a feixe, opcional)
            bprob (referencia a feixe, opcional)

Esta función te permite o adestramento (e a predición baseada nela) dunha
MSV (Máquina de Soporte Vectorial ou SVM), utilizando a librería LIBSVM
como soporte. O argumento de tipo lista L deberá de incluír a variable
dependente seguida das variables independentes; ademáis, o feixe bparms
emprégase para pasarlle opcións ao mecanismo da MSV. O valor que se
devolve é unha serie que contén as predicións da MSV. Podes utilizar os
dous argumentos opcionais punteiro-feixe para recuperar información
adicional despois do adestramento e/ou predición.

Para obter máis detalles, consulta a documentación PDF para gretl + SVM.

# 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".

# tdisagg
Resultado:     matriz
Argumentos:  Y (serie ou matriz)
            X (serie, lista ou matriz, opcional)
            s (escalar)
            opcions (feixe, opcional)
            resultados (feixe, opcional)

Realiza a desagregación temporal (conversión a unha frecuencia maior) dos
datos de tipo serie temporal que haxa en Y. O argumento s proporciona o
factor de expansión (por exemplo, 3 para pasar de trimestrais a mensuais).
O argumento X pode conter unha ou máis covariantes (que teñan a frecuencia
maior) para axudar no proceso de desagregación. Podes asumir diversas
opcións no argumento opcions, e podes recoller os detalles da
desagregación por medio de resultados.

Consulta o Manual de usuario de Gretl (Capítulo 9) para obter máis
detalles.

# toepsolv
Resultado:     vector columna
Argumentos:  c (vector)
            r (vector)
            b (vector)
            det (referencia a escalar, opcional)

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,
o 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.

Cando se indica o argumento opcional det (en forma de punteiro), ao
finalizar, este vai conter o determinante de T. Por exemplo, o código:

	  A = unvech({3;2;1;3;2;3})    # Configura unha matriz 3x3 de Toeplitz
	  x = ones(3,1)                # e un vector 3x1
	  print A x
	  eval A\x                     # Soluciona mediante a inversión xeral
	  eval det(A)                  # Presenta o determinante
	  a = A[1,]
	  d = 0
	  eval toepsolv(a, a, x, &d)   # Utiliza a función específica
	  print d

produce

A (3 x 3)

  3   2   1 
  2   3   2 
  1   2   3 

x (3 x 1)

  1 
  1 
  1 

     0.25000 
 -3.3307e-17 
     0.25000 

8
     0.25000 
  2.7756e-17 
     0.25000 

d =  8.0000000

# 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 da 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 transposición: X'.

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

Devolve un resultado do mesmo tipo que o argumento coa función trigamma de
x; isto é, a segunda derivada do logaritmo da función Gamma.

Mira tamén "lngamma", "digamma".

# trimr
Resultado:     matriz
Argumentos:  X (matriz)
            tsup (enteiro)
            tinf (enteiro)

Devolve unha matriz que é unha copia da matriz X na que se eliminaron as
tsup filas superiores e as tinf 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:   nome (cadea)

Devolve un código de tipo numérico cando nome é unha cadea de texto que
identifica un obxecto que xa está 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
dos que compoñen un feixe ou un 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:   codigotipo (enteiro)

Devolve unha cadea de texto co nome do tipo de dato de GRETL que se
corresponde co argumento codigotipo. Podes utilizalo xuntamente coas
funcións "typeof" e "inbundle". A 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 non ausentes 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
Argumentos:  v (vector)
            d (escalar, opcional)

Se omites o segundo argumento, 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 ser un enteiro triangular, ou sexa, un número k tal que exista un
enteiro n que cumpra a seguinte propiedade: k = n(n+1)/2. Esta función é a
inversa de "vech".

Se indicas o argumento d, a función devolve unha matriz (n+1) x (n+1), coas
posicións fóra da diagonal principal ocupadas cos elementos de v, como no
caso anterior. Pola contra, todos os elementos da diagonal principal se
establece que sexan iguais a d.

Exemplo:

        v = {1;2;3}
        matrix un = unvech(v)
        matrix dous = unvech(v, 99)
        print un dous

devolve

      un (2 x 2)

      1   2 
      2   3 

      dous (3 x 3)

      99     1     2 
       1    99     3 
       2     3    99 

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 os 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 a 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 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 da 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, ignorando calquera dos valores ausentes. 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
Argumentos:  x (serie ou lista)
            parcial (booleano, opcional)

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. Por
defecto, se hai algún valor ausente en t, a varianza rexístrase como NA;
pero se lle das un valor non nulo a parcial, calquera valor non ausente se
usará para crear o estatístico.

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:   nomevar (cadea)

Devolve un número enteiro co código ID da variable que ten o nome do
argumento nomevar, 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; e é 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.

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 incorporándoos á 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
Argumentos:  A (matriz cadrada)
            omitir-diag (booleano, opcional)

Esta función volve ordenar nun vector columna, os elementos da matriz A que
están na diagonal principal e por enriba dela, agás que lle asignes un
valor non nulo á opción omitir-diag, en cuxo caso só se teñen en conta
as posicións por enriba.

Normalmente esta función utilízase con matrices simétricas, en cuxo caso,
esa operación pode reverterse a través da función "unvech". Se a matriz
de entrada non é simétrica e o seu triángulo inferior contén os valores
"correctos", podes obter o resultado desexado mediante vech(A') (aínda que
os seus elementos pode que teñan que ordenarse de novo). Mira tamén "vec".

# vma
Resultado:     matriz
Argumentos:  A (matriz)
            K (matriz, opcional)
            horizonte (enteiro, opcional)

Esta función xera unha matriz coa representación VMA dun sistema VAR. Se
u_t son as perturbacións das predicións adiantadas un paso e y(t) = A1
y(t-1) + ... + Ap y(t-p) + u(t), a correspondente representación VMA é
y(t) = C0 e(t) + C1 e(t-1) + .... A relación entre u_t (perturbacións das
predicións) con e_t (impactos estruturais) será u(t) = K e(t). (Cae na
conta de que C_0 = K.)

A matriz A de coeficientes do primeiro argumento, fórmase encastelando as
matrices A_i de xeito horizontal; terá rango n x np, con unha fila por cada
ecuación. Isto correspóndese coas primeiras n filas da matriz $compan que
proporcionan as instrucións var e vecm de GRETL. A matriz K é opcional,
indicando por defecto a matriz identidade.

A matriz que devolve esta función ten un número de filas igual a
horizonte, e n^2 columnas: cada i-ésima fila contén C_i-1 en formato
vectorial. O valor de horizonte se establece por defecto igual a 24, cando
non se indique.

Mira tamén "irf".

# weekday
Resultado:     mesmo tipo que o introducido
Argumentos:  ano (escalar ou serie)
            mes (escalar ou serie)
            día (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.

Admítese tamén unha solicitude alternativa: cando se indica un único
argumento, considérase que é unha data (ou unha serie de datas) en formato
numérico "básico" ISO 8601, YYYYMMDD. Deste xeito, as seguintes dúas
solicitudes xeran o mesmo resultado, concretamente 2 (martes).

	  eval weekday(1990, 5, 1)
	  eval weekday(19900501)

# wmean
Resultado:     serie
Argumentos:  Y (lista)
            W (lista)
            parcial (booleano, opcional)

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 Y e W de variables deben de ter o mesmo tamaño, e as ponderacións
deben de ser non negativas.

Por defecto, o resultado é NA, se hai algún valor ausente na observación
t; pero se lle das un valor non nulo a parcial, se utilizará calquera valor
non ausente.

Mira tamén "wsd", "wvar".

# wsd
Resultado:     serie
Argumentos:  Y (lista)
            W (lista)
            parcial (booleano, opcional)

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 Y e W de variables deben de ter o mesmo tamaño, e as
ponderacións deben de ser non negativas.

Por defecto, o resultado é NA, se hai algún valor ausente na observación
t; pero se lle das un valor non nulo a parcial, se utilizará calquera valor
non ausente.

Mira tamén "wmean", "wvar".

# wvar
Resultado:     serie
Argumentos:  X (lista)
            W (lista)
            parcial (booleano, opcional)

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 Y e W de variables deben de ter o mesmo tamaño, e as
ponderacións deben de ser non negativas.

Por defecto, o resultado é NA, se hai algún valor ausente na observación
t; pero se lle das un valor non nulo a parcial, se utilizará calquera valor
non ausente.

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)
            ruta (cadea ou arranxo de cadeas)
            coincidencias (referencia a escalar, opcional)

O argumento buf debe de ser un búfer XML, tal como pode recuperarse dun
lugar web adecuado mediante a función "curl" (ou lerse dun ficheiro
mediante a función "readfile"); e o argumento ruta debe de ser, ben unha
especificación XPath sinxela ou ben 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.

Por defecto, amósase un fallo se ruta non coincide no búfer XML; pero este
comportamento modifícase se indicas o terceiro argumento (opcional) pois,
neste caso, o argumento recupera un reconto das coincidencias, devolvéndose
unha cadea baleira se non hai ningunha. Chamada de exemplo:

	  ngot = 0
	  ret = xmlget(xbuf, "//some/thing", &ngot)

Agora ben, aínda vaise amosar un fallo no caso de facer unha solicitude mal
configurada.

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, opcional)

Devolve unha matriz nula con r filas e c columnas. Se o omites, o número de
columnas establécese en 1 (vector columna), por defecto. Mira tamén
"ones", "seq".