Variables calculadas y variables primitivas

[irobles]

No se si la nomenclatura de variables base y variables calculadas es la correcta, pero bueno, espero que se entienda.

Igual que existe un metodo que nos dice las dependecias de una variables, nos sería muy util un metodo que hago lo contrario, para una variable, nos diga en que variables calculadas de un modelo participa

Os pongo un código de ejemplo que hemos realizado por si os puede ayudar

//////////////////////////////////////////////////////////////////////////////
Set GetSetVarDependences(Set setVar){
//////////////////////////////////////////////////////////////////////////////
  EvalSet(setVar, Set(NameBlock var){
    Set depen = var::GetDependences(?);
    If(IsEmpty(depen), 
      [[ var ]], 
      {
        BinGroup("<<",GetSetVarDependences(depen))
       })
    })
};
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
Real BelongByName(NameBlock var,Set setVar)
//////////////////////////////////////////////////////////////////////////////
{
  Set namesVar = EvalSet(setVar, Text (NameBlock varAux){varAux::GetName(?)});
  If(var::GetName(?)<:namesVar,1,0)
};
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
Set GetVariablesCalculadas( NameBlock varToFind,NameBlock model){
//////////////////////////////////////////////////////////////////////////////
  Set mVariables = model::GetMVariables(?);
  Set variables = EvalSet(mVariables, NameBlock (NameBlock mvar){

    mvar::GetVariable(?)

  });

  Set Select(variables, Real (NameBlock var){
    Set varDepen = BinGroup("<<",GetSetVarDependences([[var]]));
    If(BelongByName(varToFind,varDepen),1,0)

  })
};
//////////////////////////////////////////////////////////////////////////////

[Pedro Gea]

El objetivo de estas funciones es algo particular.
Tracemos una ruta de funcionalidades que nos ayuden a alcanzar este objetivo:

Lo primero que hemos de contemplar es que una variable puede depender de otras (sus dependencias) al mismo tiempo que otras (sus dependientes) dependen de ella.

En el enunciado se utilizan los términos variable base (no confundir con las base-variables, las instancias de @BaseVariable) como las variables más primitivas o que no tienen dependencias y variables calculadas como las variables que dependen de otras.
En éstas podríamos distinguir calculadas finales y calculadas intermedias según si existen o no otras variables que dependen de ellas.

Para definir algo la terminología podemos usar:

• primitivas: sin dependencias
  • aisladas: sin dependientes
  • ligadas: con dependientes
• calculadas: con dependencias
  • finales: sin dependientes
  • intermedias: con dependientes

Desde una variable dada podemos obtener sus dependencias (o sus dependientes) de manera recursiva a distintos niveles, de modo que:

• el nivel 0 es la propia variable,
• el nivel 1 son las dependencias (o dependientes) directas de la variable y
• los niveles mayores que 1 son las dependencias (o dependientes) indirectas.

[Pedro Gea]

(In [2292]) Se introducen métodos para acceder al grafo de dependencias de las variables, tanto en la dirección directa de las dependencias GetDependences_ToLevel como en la dirección inversa GetDependents_ToLevel.
Estos cambios se acompañan de un conjunto de mecanismos relativos con el álgebra de conjuntos que reemplazan (al menos temporalmente) a los de TOL.
Refs #533

[Pedro Gea]

Las funciones GetDependences_ToLevel y GetDependents_ToLevel permiten obtener las dependencias y las dependientes desde el nivel 0 hasta el nivel indicado como argumento.
Si se desea recorrer toda la profundidad de las dependencias indíquese un nivel desconocido (con ? o con un número negativo).

[Pedro Gea]

El objetivo propuesto con el método GetVariablesCalculadas es obtener la intersección entre todo el conjunto de dependientes de la variable indicada varToFind y todo el conjunto de dependencias de las variables utilizadas en el modelo (asignadas en las m-variables).

El mecanismo para hacer esto paso a paso sería:

// [1] Obtener las variables utilizadas en el modelo desde las m-variables
Set variables = EvalSet(model::GetMVariables(?), 
  MMS::@Variable (MMS::@MVariable mVariable) { mVariable::GetVariable(?) });
// [2] Obtener el conjunto completo de dependencias de estas variables:
//     Obtenemos los conjuntos para cada una de ellas y los unimos
Set dependencesSets = EvalSet(variables, Set (MMS::@Variable variable) {
  variable::GetDependences_ToLevel(?)
});
Set dependences = MMS::Unique.(SetConcat(dependencesSets), MMS::MMS.ObjectCompare);
// [3] Obtenemos las dependientes de la varaible seleccionada:
Set dependents = varToFind::GetDependents_ToLevel(?);
// [4] Obtenemos el conjunto objetivo como intersección de éstos:
Set MMS::Intersection.(dependences, dependents, MMS::MMS.ObjectCompare);

[atorre]

Me surge una duda: para que sirven los métodos GetDependences, GetDependences.Info?

[Pedro Gea]

(In [2365]) Se rehacen las funciones para realizar operaciones de álgebra de conjuntos, recibiendo como argumento una relación de equivalencia.
Se deshace el uso provisional de Classify. (Véase [2326]).

En el tique #533 se proponía un modo de usar los métodos GetDependences_ToLevel y GetDependents_ToLevel haciendo uso de las funciones anteriores.
Mientras se llevan a TOL la propuesta de estas funciones se sugiere utilizar las nuevas funciones acabadas en "_Eq" y la función ya implementa SameNameBlock.
El código sugerido quedaría como sigue:

...
Set dependences = MMS::Unique_Eq(SetConcat(dependencesSets), SameNameBlock);
...
Set MMS::Intersection_Eq(dependences, dependents, SameNameBlock);

Refs #533

[Pedro Gea]

La diferencia entre GetDependences, GetDependences.Info es la siguiente: mientras el primer método devuelve las variables dependientes (los objetos en sí mismos) la segunda devuelve la información utilizada para su definición. En general ésta es un conjunto formado por los nombres que dan lugar al identificador del objeto, en el caso de las variables es el sólo el nombre o el par nombre-escenario.

Nótese que de acuerdo a la revisión de los enlaces hecha en #556 el atributo _.dependences_ puede contener (dependiendo de si está hecho o no el enlace) los objetos o la información que los refiere.