= DecoTools =

'''Módulo de descomposiciones y dueto's'''

== Introducción ==

... Véase [wiki:Decompositions]

== Definición ==

El paquete de descomposiciones y dueto's [wiki:DecoTools] ofrece un conjunto de funciones para la creación de descomposiciones aditivas. 

=== La descomposición ===

La unidad elemental sobre la que se construye todo el módulo es la ''decomposición''. En el paquete se denomina '''decomposición''' (aditiva) a todo conjunto de datos donde el primero de ellos denominado '''total''' es igual a la suma del resto, a los que se denominan '''contribuciones'''.

{{{
decomposition := {total, contributions} / total = Sum(contributions)
}}}

Por ejemplo:
{{{
#!java
a = {5, 2, 2, 1}    // OK
b = {4.4, 3.3, 1.0} // NO
c = {10}            // NO
}}}
el conjunto {{{a}}} es una descomposición, mientras que {{{b}}} y {{{c}}} no lo son.

Una descomposición se caracteriza así por tener tres o más elementos, el total y al menos un par de contribuciones:
{{{
deco = {deco1, deco2, deco3, ...}
          ^      ^      ^
          |      |      contribution 2
          |      contribution 1
          total
}}}

=== Agrupación de contribuciones ===

Al trabajar con descomposiciones es bastante común querer agrupar las contribuciones y obtener así una nueva decomposición con menos contribuciones.
Para ello en DecoTools se crean dos estructuras TOL con las que definir cómo reagrupar una decomposición: 

==== @Contribution.Def ====

{{{Struct @Contribution.Def}}} es una estructura que permite definir una nueva contribución como combinación de contribuciones de referencia.
Sus argumentos son:
 * {{{Text Name}}}: Nombre de la nueva contribución.
 * {{{SetOf{@Contribution.Def} Contributions}}}: Conjunto de contribuciones de referencia que conformarán la nueva contribución.

==== @Contribution.Ref ====

{{{Struct @Contribution.Ref}}} es una estructura que permite definir una contribución de referencia.
Sus argumentos son:
 * {{{[Real|Text] Info}}}: Nombre de la contribución de referencia o su índice en la descomposición de referencia.
 * {{{[Real|Serie|...|Code] BasePart}}}: Parte que se sustrae a la contribución de referencia a la hora de crear la nueva contribución. Puede ser un valor fijo o una función que lo obtenga al aplicarla sobre la contribución.

==== Ejemplos ====

{{{
#!java
// Definición de una nueva contribución que agrupa (suma) 
// las tres primeras contribuciones de referencia:
Set @Contribution.Def("TresPrimeras", [[
  @Contribution.Ref(1, 0),
  @Contribution.Ref(2, 0),
  @Contribution.Ref(3, 0)
]]);
}}}

{{{
#!java
// Definición de una nueva contribución que suma dos series 
// (contribuciones) restándoles un nivel dado por su primer dato:
Set @Contribution.Def("DosSinNivel", [[
  @Contribution.Ref("SerieA", FirstS),
  @Contribution.Ref("SerieB", FirstS)
]]);
}}}

Para otros ejemplos véase [#Deco.BaseDefinition]

=== Variables auxiliares ===

==== PermutationsLimit ==== 

{{{Real PermutationsLimit}}}: Límite máximo de contribuciones para que se realize la descomposición canónica exacta.

Se utiliza en las funciones [#Deco.Canonical] y [#Deco.BaseCanonical]. Su valor por defecto es {{{6}}}.
El valor por defecto es 6. Véanase las funciones

==== SampleSize ==== 

{{{Real SampleSize}}}: Tamaño por defecto de la muestra de permutaciones para realizar la descomposición canónica.

Se utiliza en las funciones [#Deco.Canonical] y [#Deco.BaseCanonical]. Su valor por defecto es {{{6}}}.

== Funciones ==

A continuación se describen todas las funciones que ofrece DecoTools:

 * [#Deco.Ordered]
 * [#Deco.Marginal]
 * [#Deco.FirstIn]
 * [#Deco.Canonical]
  * [#Deco.Canonical.Exact]
  * [#Deco.Canonical.Sample]
 * [#Deco.Exponential.Canonical]

 * [#Deco.BaseOrdered]
 * [#Deco.BaseMarginal]
 * [#Deco.BaseFirstIn]
 * [#Deco.BaseCanonical]
  * [#Deco.BaseCanonical.Exact]
  * [#Deco.BaseCanonical.Sample]
 * [#Deco.Exponential.BaseCanonical]

 * [#DueTo.Period]
 * [#DueTo.Statistic]
 * [#GeneralizedDueTo.Period]
 * [#GeneralizedDueTo.Statistic]
 * [#InverseDueTo.Period]

 * [#Test]
 * [#Deco.BaseDefinition]
 * [#Deco.SynergyFree]
 * [#Deco.BaseSynergyFree]
 * [#Deco.Serie.DatCh]
 * [#Deco.BaseRelative]
 * [#Deco.TotalRelative]

=== Descomposiciones por transformación ===

Una de las situaciones más comunes al crear una descomposición aditiva es partir de la descomposición de un modelo multiplicativo al que se tomaron logaritmos. En general la linealización de un modelo puede haberse realizado mediante una transformación cualquiera, el problema que nos ocupa consiste en encontrar una descomposición aditiva de un modelo que no era lineal, conocida la descomposición del modelo linealizado y la función de transformación inversa:
{{{
#!java
Set decomposition = <function>(Set decomposition_transformed, Code transformation_inverse.function);
}}}

La discusión sobre este tema puede verse en: [wiki:Decompositions#Descomposiciónaditivademodelosmultiplicativos Descomposición aditiva de modelos multiplicativos].

==== Deco.Ordered ====

{{{Set Deco.Ordered(Set decomposition, Code transf)}}} [[BR]]
Devuelve la decomposición aditiva ordenada obtenida al aplicar la transformación.

Para más detalles véase: [wiki:Decompositions#Descomposiciónordenada Descomposición ordenada].

==== Deco.Marginal ====

{{{Set Deco.Marginal(Set decomposition, Code transf)}}} [[BR]]
Devuelve la descomposición aditiva marginal obtenida al aplicar la transformación.

Para más detalles véase: [wiki:Decompositions#DescomposiciónMarginalodecontribucionesmarginales Descomposición marginal].

==== Deco.FirstIn ====

{{{Set Deco.FirstIn(Set decomposition, Code transf)}}} [[BR]]
Devuelve la descomposición aditiva first-in obtenida al aplicar la transformación.

Para más detalles véase: [wiki:Decompositions#DescomposiciónFirstInodecontribucionesprimeras Descomposición first-in].

==== Deco.Canonical ====

{{{Set Deco.Canonical(Set decomposition, Code transf)}}} [[BR]]
Devuelve la descomposición aditiva canónica obtenida al aplicar la transformación. [[BR]]
Si el número de contribuciones excede el valor [#PermutationsLimit] se resolverá mediante una muestra de permutaciones de tamaño [#SampleSize].

Para más detalles véase: [wiki:Decompositions#Descomposicióncanónica Descomposición canónica].

==== Deco.Canonical.Exact ====

{{{Set Deco.Canonical.Exact(Set decomposition, Code transf)}}} [[BR]]
Devuelve la descomposición aditiva canónica obtenida al aplicar la transformación. [[BR]]
Realiza la descomposición canónica exacta promediando sobre todas las premutaciones independientemente del valor de {{{DecoTools::PermutationsLimit}}}.

==== Deco.Canonical.Sample ====

{{{Set Deco.Canonical.Sample(Set decomposition, Code transf, Real length)}}} [[BR]]
Devuelve la descomposición aditiva canónica obtenida al aplicar la transformación. [[BR]]
Realiza la descomposción canónica sobre una muestra de permutaciones del tamaño indicado.

==== Deco.Exponential.Canonical ====

{{{Set Deco.Exponential.Canonical(Set decomposition)}}} [[BR]]
Devuelve la descomposición aditiva canónica obtenida al aplicar la transformación exponencial.

Esta función utiliza un algoritmo que permite, para la transformación exponencial, calcular el promedio sobre todas las permutaciones sin calcularlas.
Véase el documento: ''Descomposición aditiva de contribuciones multiplicativas''.

==== Ejemplos ====

Tomemos como ejemplo para ilustrar las funciones la siguiente descomposición de partida con 4 contribuciones:
{{{
#!java
Set deco0 = [[3.5, 1.5, 0.5, 1.0, 0.5]];
}}}
y sea {{{rExp}}} la transformación exponencial:
{{{
#!java
Code rExp = FindCode("Real", "Exp");
}}}
que se define para evitar la advertencia que causa su sobrecarga (véase [https://www.tol-project.org/ticket/1180 TOL#1180]).

{{{
#!java
Set DecoTools::Deco.Ordered(deco0, rExp);
// [[ 33.115, (total)
//    1, (initial effect)
//    3.482, 2.907, 12.696, 13.030
// ]]
}}}

{{{
#!java
Set DecoTools::Deco.Marginal(deco0, rExp);
// [[ 33.115, (total)
//    1, (initial effect)
//    25.726, 13.030, 20.933, 13.030, 
//    -40.604 (synergy)
// ]]
}}}

{{{
#!java
Set DecoTools::Deco.FirstIn(deco0, rExp);
// [[ 33.115, (total)
//    1, (initial effect)
//    3.482, 0.649, 1.718, 0.649, 
//    25.617 (synergy)
// ]]
}}}

{{{
#!java
Set DecoTools::Deco.Canonical(deco0, rExp);
// [[ 33.115, (total)
//    1, (initial effect)
//    12.437, 5.198, 9.282, 5.198
// ]]
}}}

Nótese que las dos primeras descomposiciones: la marginal y la ''first-in'' (o de primera contribución) son inexactas y presentan sinergía (véase: [wiki:Decompositions#Descomposicionesinexactas Descomposiciones inexactas]).

Nótese también que la transformación exponencial presenta un efecto inicial no nulo (véase: [wiki:Decompositions#Efectoinicialdelatransformación Efecto inicial de la transformación]).

=== Descomposiciones base ===

Una situación muy habitual, que además nos facilita eliminar el efecto inicial de la transformación, es aquélla en la que la descomposición presenta una contribución principal sobre la que se pueden referir los efectos de las demás contribuciones. A esta contribución principal la denominaremos '''base''', de modo que una descomposición con base, viene dada por:
{{{
decomposition.base := {total, base, contributions} / total = base + Sum(contributions)
}}}

La discusión sobre este tema puede verse en: [wiki:Decompositions#Descomposicionesbase Descomposiciones base].

==== Deco.BaseOrdered ====

{{{Set Deco.BaseOrdered(Set decomposition, Code transf)}}} [[BR]]
Devuelve la decomposición aditiva ordenada con contribución base obtenida al aplicar la transformación.

==== Deco.BaseMarginal ====

{{{Set Deco.BaseMarginal(Set decomposition, Code transf)}}} [[BR]]
Devuelve la descomposición aditiva marginal con contribución base obtenida al aplicar la transformación.

==== Deco.BaseFirstIn ====

{{{Set Deco.FirstIn(Set decomposition, Code transf)}}} [[BR]]
Devuelve la descomposición aditiva first-in con contribución base obtenida al aplicar la transformación.

==== Deco.BaseCanonical ====

{{{Set Deco.BaseCanonical(Set decomposition, Code transf)}}} [[BR]]
Devuelve la descomposición aditiva canónica con contribución base obtenida al aplicar la transformación. [[BR]]
Si el número de contribuciones excede el valor [#PermutationsLimit] se resolverá mediante una muestra de permutaciones de tamaño [#SampleSize].

==== Deco.BaseCanonical.Exact ====

{{{Set Deco.BaseCanonical .Exact(Set decomposition, Code transf)}}} [[BR]]
Devuelve la descomposición aditiva canónica con contribución base obtenida al aplicar la transformación. [[BR]]
Realiza la descomposición canónica exacta promediando sobre todas las premutaciones independientemente del valor de {{{DecoTools::PermutationsLimit}}}.

==== Deco.BaseCanonical.Sample ====

{{{Set Deco.BaseCanonical .Sample(Set decomposition, Code transf, Real length)}}} [[BR]]
Devuelve la descomposición aditiva canónica con contribución base obtenida al aplicar la transformación. [[BR]]
Realiza la descomposción canónica sobre una muestra de permutaciones del tamaño indicado.

==== Deco.Exponential.BaseCanonical ====

{{{Set Deco.Exponential.BaseCanonical(Set decomposition)}}} [[BR]]
Devuelve la descomposición aditiva canónica con contribución base obtenida al aplicar la transformación exponencial.

==== Ejemplos ====

Para ilustrar estas funciones seguiremos usando la decomposición de partida [#Ejemplos1 anterior].

{{{
#!java
Set DecoTools::Deco.BaseOrdered(deco0, rExp);
// [[ 33.115, (total)
//    4.482 (base), 2.907, 12.696, 13.030
// ]]
}}}

{{{
#!java
Set DecoTools::Deco.BaseMarginal(deco0, rExp);
// [[ 33.115, (total)
//    4.482 (base), 13.030, 20.933, 13.030,
//    -18.359 (synergy)
// ]]
}}}

{{{
#!java
Set DecoTools::Deco.BaseFirstIn(deco0, rExp);
// [[ 33.115, (total)
//    4.482 (base), 2.907, 7.701, 2.907,
//    15.118 (synergy)
// ]]
}}}

{{{
#!java
Set DecoTools::Deco.BaseCanonical(deco0, rExp);
// [[ 33.115, (total)
//    4.482 (base), 7.428, 13.777, 7.428
// ]]
}}}

=== Útiles para operar con descomposiciones ===

==== Test ====

{{{Real Test(Set decomposition)}}} [[BR]]
Comprueba si una descomposición está bien definida, es decir, si el primer elemento (total) es igual a la suma del resto (contribuciones).

==== Deco.BaseDefinition ====

{{{Set Deco.BaseDefinition(Set decomposition, Set definition)}}} [[BR]]
Crea una nueva descomposición a partir de otra agrupando sus contribuciones según se indica en la nueva definición. [[BR]]
La primera contribución nueva será una contribución base y asumirá la diferencia que pudiera haber entre el total y la suma del resto de contribuciones.

==== Deco.SynergyFree ====

{{{Set Deco.SynergyFree(Set decomposition)}}} [[BR]]
Elimina la sinergía de una descomposición repartiéndola proporcionalmente entre las contribuciones.

==== Deco.BaseSynergyFree ====

{{{Set Deco.BaseSynergyFree(Set decomposition, Code transf)}}} [[BR]]
Elimina la sinergía y el posible efecto inicial de la transformación de una descomposición repartiéndola 
proporcionalmente entre las contribuciones. [[BR]]
La transformación sólo se usa para determinar si la descomposición tiene efecto inicial.

==== Deco.Serie.DatCh ====

{{{Set Deco.Serie.DatCh(Set decomposition, TimeSet timeset, Code funS)}}} [[BR]]
Hace un cambio de fechado en una descomposición de series temporales.
Véase la función estándar {{{DatCh}}}.

==== Deco.BaseRelative ====

{{{Set Deco.BaseRelative(Set decomposition)}}} [[BR]]
Devuelve la descomposición correspondiente a la diferencia entre el total y la base, en unidades relativas a la base.

==== Deco.TotalRelative ====

{{{Set Deco.TotalRelative(Set decomposition))}}} [[BR]]
Devuelve la descomposición en unidades relativas al total.