= Actualización a MMS_0.6 =

== Transformaciones ==

El uso de las transformaciones ({{{@MMS.Transformation}}}) de MMS_0.5 en los proyectos ha sido muy variopinto
dada la flexibilidad que ofrecían a los usuarios. Sin embargo, su diseño original
no estaba pensado para ello y esto conlleva algunas dificultades sobre todo
de cara a la persistencia. En MMS_0.6 las transformaciones se modifican y asumen un
papel más definido y estricto, destinado a las transformaciones invertibles propias
de la linealización de los modelos.

A continuación describimos cómo ha de modificarse la programación para conseguir 
los mismos resultados:

=== Transformación del Output ===

La transformación del output no suele presentar la flexibilidad en las transformaciones
que comentábamos y se limita a la familia de transformaciones BoxCox.
Éstas están implementadas en MMS_0.6.

'''Código en MMS_0.5'''

{{{
#!java
@MMS.Transformation _.transformation = BoxCox(0,0);
}}}

'''Código en MMS_0.6'''

Construcción de la transformación:
{{{
#!java
// Modo 1
MMS::@Transformation _.transformation.1 = MMS::@Transformation.BoxCox::Default(0,0);
// Modo 2
MMS::@Transformation _.transformation.2 = MMS::@Transformation::Family("BoxCox", [[0,0]]);
// Nombre de la transformación
Text _.transformation.2::GetName(?);
//> "BoxCox_0.0"
}}}

Alternativa en los argumentos de una MVariable:
{{{
#!java
// Modo 1 ó 2
NameBlock [_.output|_.input] = [[
  ...
  MMS::@Transformation _.transformation = ...
  ...
]]
// Modo 3 (por nombre)
NameBlock [_.output|_.input] = [[
  ...
  Text _.transformationLabel = "BoxCox_0.0";
  ...
]]
}}}

=== Transformación del Input ===

La transformación del input es algo más delicada ya que en sus transformaciones
se usaban funciones de distinto tipos que no sólo transformaban los datos
sino que los ampliaban o recortaban.

MMS_0.6 no acepta esto en las transformaciones de modo que para ello hay que
acudir a mecanismos del módulo de variables. Quizá hay varias maneras de solucionar 
esta situación e incluso puede ser muy interesante considerar el uso que se ha
hecho en algunos proyectos de las transformaciones para enriquecer más el módulo de variables.

==== A través de Variables Calculadas ====

A continuación proponemos una solución basada en la construcción de variables calculadas
cuando se presente la necesidad de transformar una variable.

'''Código en MMS_0.5'''

El código que nos ocupa se separa en dos partes:

(i) donde se definen constructores específicos para las transformaciones del proyecto:
{{{
#!java
///////////////////////////////////////////////////////////////////////////////
@MMS.Transformation MMC_ExtendedNormalizeBoxCox(Real first, Real second, Date dat)
//////////////////////////////////////////////////////////////////////////////
{
  @MMS.Transformation::Block(NameBlock { NameBlock args = [[
    Text _.name              = "MMC_ExtendedNormalizeBoxCox"<<first<<"_"<<second;
    Text _.grammar           = "Serie";
    Text _.contextExpression = "
      Real _.first = "<<first<<";
      Real _.second = "<<second<<";
    ";
    Text _.directExpression  = If(first==0, 
      "Serie (Serie s) { MMC_NomalizeExtendSerLastValue("+FormatDate(dat)+", Log(s + _.second)) }",
      "Serie (Serie s) { MMC_NomalizeExtendSerLastValue("+FormatDate(dat)+", ((s + _.second)**_.first - 1)/_.first ) }"
    );
    Text _.inverseExpression = If(first==0, 
      "Serie (Serie t) { MMC_NomalizeExtendSerLastValue("+FormatDate(dat)+", (Exp(t) - _.second) ) }",
      "Serie (Serie t) { MMC_NomalizeExtendSerLastValue("+FormatDate(dat)+", ((_.first * t + 1)**(1/_.first) - _.second) )}"
    )
  ]] })
};
PutDescription("
  Aplica una transformación logarítmica a la serie, la normaliza 
  a la fecha dat y la extiende en previsión con el última dato",
  MMC_ExtendedNormalizeBoxCox
);
}}}

(ii) y donde se utilizan las transformaciones:
{{{
#!java
Text variableName = ...;
Real model::CreateBaseExpTermOmega([[
  ...
  Text _.variableName = variableName ;
  @MMS.Transformation _.transformation = transformation;
  // donde:
  // transformation = MMC_ExtendedNormalizeBoxCox(0, 0, modelBegin)
  ...
]]);
}}}

'''Código en MMS_0.6'''

Como alternativa a 

(i) los constructores específicos proponemos la creación de nuevas funciones:

{{{
#!java
///////////////////////////////////////////////////////////////////////////////
Serie MMC_ExtendedNormalizeBoxCox(Serie s, Real first, Real second, Date dat)
//////////////////////////////////////////////////////////////////////////////
{
  If(first==0, 
    MMC_NomalizeExtendSerLastValue(dat, Log(s+ second)),
    MMC_NomalizeExtendSerLastValue(dat, ((s + second)**first - 1)/first)
  )
};
PutDescription("
  Aplica una transformación logarítmica a la serie s, la normaliza 
  a la fecha dat y la extiende en previsión con el último dato",
  MMC_ExtendedNormalizeBoxCox
);
}}}

(ii) mientras que en la construcción de los términos explicativos (en MMS_0.6 no se pasa
por la creación de un término base) se ha de construir "en tiempo de definición" una
nueva variable cuando sea necesario, es decir cuando la transformación no sea la identidad:

{{{
#!java
Text variableName = ...;

MMS::@Variable vc = model::GetDataSet(?)::CreateVariable([[
  ...
  Text _.name = variableName<<"_Transformed";
  Text _.type = ...;
  Text _.expression = transformationExpression;
  // donde:
  // transformationExpression = "MMC_ExtendedNormalizeBoxCox(%1, 0, 0, <modelBegin>)"
  // %i hace referencia a la i-ésima dependencia
  Set _.dependences = [[ variableName ]]
]]);

Anything submodel::CreateExpTerm_TransferFunction([[
  ...
  NameBlock _.input = [[
    Text _.name = <name>;
    Text _.variableIdentifier = variableName<<"_Transformed"
  ]];
  ...
]])
}}}

En ausencia de transformación sería simplemente:
{{{
#!java
Text variableName = ...;
Anything submodel::CreateExpTerm_TransferFunction([[
  ...
  NameBlock _.input = [[
    Text _.name = <name>;
    Text _.variableIdentifier = variableName
  ]];
  ...
]])
}}}