{5} Accepted, Active Tickets by Owner (Full Description) (98 matches)

Se require la implementación de un API nativa en TOL para hacer uso de glpk ya que el API vía Rglpk no ofrece opciones como criterios de parada.

Create an example showing how to use BysMCMC to create a custom Gibbs sampler.

We have realized that GetDir is behaving quite slow when the path is located remotely and the amount of files ia around 100. Below is an implementation based on OS commands that is faster than the builtin GetDir.

//////////////////////////////////////////////////////////////////////////////
Set GetDir_Files(Text path)
//////////////////////////////////////////////////////////////////////////////
{
  // Versión de GetDir(...)[1] más rápida. Para Windows.
  If(OSName=="WINDOWS" & True, {
    Text WriteFile(TmpDir<<"dirbf.bat", "@echo off\ndir %1 /B /A-D");
    Real WinSystem(Qt(TmpDir<<"dirbf.bat")<<" "<<Qt(path)<<" > "
      <<Qt(TmpDir<<"dirbf.dat"), 0, 1);
    Set dir = Tokenizer(ReadFile(TmpDir<<"dirbf.dat"), "\n");
    Real FileDelete(TmpDir<<"dirbf.bat");
    Real FileDelete(TmpDir<<"dirbf.dat");
    Select(dir, TextLength)
  }, GetDir(path)[1])
};


Text path = "M:/TfnEsp/MeMoCC/repository/repMovil/Estimations/";
Real t1 = Copy(Time);
Set GetDir_Files(path);
Real t2 = Copy(Time);
Set GetDir(path)[1];
Real t3 = Copy(Time);
WriteLn("Método1: "<<(Real t2-t1)<<"s\nMétodo2: "<<(Real t3-t2)<<"s");

On Linux, we have found that some binary packages depends on some specific version of stdlibc++. This is the case of IpoptCore with depends on GLIBCXX_3.4.9. Whe we try to load that package we get a message like this:

/usr/lib/libstdc++.so.6: version `GLIBCXX_3.4.9' not found

in order to solve that we need to remove that constraint or to depends on a lower version.

It is requested the implementation of a way to specify an AR(p) in the state equation within RKFAS package.

TclCore no debe distribuir Tcl, sino que debe usar el disponible en el sistema. En el caso de Windows usar el distribuido con TOL.

Las funciones Excel.ReadCell y sus variantes especializadas Excel.ReadText, Excel.ReadReal y Excel.ReadDate no devuelven nada si la celda solicitada está vacía.

Esto supone que la sentencia

  Anything cell = Excel.ReadCell(xls,[[1,1]]);

no crea el objeto TOL cell y las sentencias que posteriormente lo invoquen darán error.

Creo que debería haber una función Excel.IsEmpty que indique si una celda está o no vacía, pero al margen de eso, las funciones de lectura deberían devolver algo en cualquier caso.

Las funciones tipificadas Excel.ReadText, Excel.ReadReal y Excel.ReadDate}} deberían devolver sus correspondientes valores desconocidos. Para {{{Excel.ReadCell habría que elegir uno de ellos, quizás el omitido de Real ? que es el más sencillo de manejar.

When running a client code in TolServer sometimes is useful to know, inside the client code, the task id assigned to this piece of code.

Se solicita la implementación de un API para invocar desde TOL a las funciones hclust y clara de R.

Estudiar si podemos sustiuir clapack por lapacke. Esto es para facilitar la migración de tol a 64 bits en windows.

Implementar el paquete JSONRPC_Client para facilitar las llamadas a un servidor JSON-RPC desde TOL.

ver ​http://www.jsonrpc.org/specification

Hola,

cuando DBSeries o DBTable devuelven un tipo de dato Decimal, este aparece truncado. La conexión es con una base de datos Teradata pero creo que esto también ocurre con otros gestores como Oracle, por ejemplo.

Real ex1 = DBTable("Select cast('0.82' as decimal(10,5))")[1][1]; Resultado: 0 Real ex2 = DBTable("Select cast('0.82' as float)")[1][1]; Resultado: 0.82

The following code results in a wrong date:

TolExcel::@WorkBook xls2 = TolExcel::@WorkBook::Open("ex2.xls");
Real xls2::ActivateWS(1);
Date d = xls2::ReadDate( 1, 1 );

with the attached file d should y1820m1d1 but it is y1820m01d02

El problema se produjo al tratar de crear una serie a patir de dos conjuntos que tienen igual cantidad de elementos (12 para el caso tratado), el primero contenía los datos y el segundo las fechas. La función SetSer debía crear una serie de 12 elementos, pero la serir que crea es de sólo dos elementos correspondientes a las dos últimas fechas. El error se puede reproducir con el siguiente fragmento de código:

Set datos= 1, 2, 3, 4, 5, 6, 7, 8 ,9, 10, 11, 12?; Set fechas= y2010m01d01, y2010m04d01, y2010m07d01, y2010m10d01, y2011m01d01, y2011m04d01, y2011m07d01, y2011m10d01, y2012m01d01, y2012m04d01, y2012m07d01, y2012m10d01?; TimeSet fechado= DatesOfSet(fechas); Serie ser= SetSer(datos, fechas[1], fechado);

Aunque en este caso las fechas corresponden con un fechado trimestral, podríamos tener el caso en que las fechas no se ajusten a un fechado básico. Si se usa un fechado básico como el Trimestral, entonces funciona correctamente; por ejemplo, el código siguiente produce la serie correcta: Serie ser1= SetSer(datos, fechas[1], Trimestral);

Hola, al abrir TOL me encuentro los siguientes mensajes:

Warning: [1] Está usando una versión demasiado vieja o desconocida de TOL v3.1 p009 2012-04-10 08:34:06 i686-win
La versión estable con mantenimiento más antigua de TOL para windows es v2.0.1 b.9 2011-11-07 17:58:33 i686-win

La última versión oficial de TOL para windows es v3.1 p010 2012-05-09 15:30:39 i686-win
La última versión de desarrollo de TOL para windows es v3.2 b009 2012-04-09 16:07:36 i686-win


ERROR: [1] No ha sido posible convertir de Set hacia Text para el objeto '$tmp$'

[Call stack]
  [1] Real TolCore::CheckTOLRelease (Real maxDaysOfDelay)
  Local package TolCint.2.1 created at y2011m01d19h22i28s00.000 could be updated to newer remote patch since y2011m01d19h15i29s00.000

Un saludo.

TclCore needs to include the following extension in order to tolcon use CurlApi and other functions:

• base64
• TclCurl7.19.6
• tequila
• tlogger
• tolcomm

TOL debería almacenar en memoria todos los caracteres ascii (<256) usando sólo un byte.

Esto debe asegurarse para todas las cadenas creadas desde el fuente .cpp y fuente .tol

Cuando una clase A se compone de otras clases, B y C por ejemplo, puede ser util incorpoar las opciones de menu definidas para las clases B y C como opciones de submenu en el menu de opciones de A.

In order to customize the appearance of the icons associated with the users types created as classes it is required a way to associate an image resource to a Class name. The image resource must be defined in ImageManager. This image will be used by the GUI when showing the object inspector.

Some package depend on tcllib. tcllib is available in tolsh and Tolbase but not in tolcon. In order to use tcllib from plain tol (tolcon,tolmachine) it is requested the implementation of TclLib package.

Implement a legend in MapViewer

In order to create and distribute a package which is required by default during tol initialization it is needed a way to disable this default #Require as a command line option.

The tool to draw the theoretical ACF & PACF for a given ARIMA model (From Menu: Tool->Analysis tools->ARIMA->Draw ACF and PACF of ARIMA models) doesnt seems to work.

"Error al graficar la serie de autocorrelaciones. incorrect object reference in ResolveObject"

Older versions of tool (pre 2.0) are draw graphics but with wrong values.

There is no way to query the tabs within an excel file. It is requested the implementation of the following methods:

• GetNumberOfSheets: returns the number of sheets
• GetSheetNames: returns a Set with the names of the sheets

Cuando utilizas esta función sin introducir ningún valor, te devuelve el valor anterior por defecto. Y siempre que no introdujeras ningun valor tendría que devolver :

"can't read "___TclResult__": no such variable"

Por ejemplo: Si ejecutas la función una vez, introduciendo el valor x, y nuevamente la utilizas y esta vez no introduces ningun valor, te toma el valor x anterior.

Hola!!

He intentado estimar un modelo VAR sin constante, para ello lo que he hecho es No incluir la siguiente línea:

Real model::SetConstant(1);

luego cuando voy a ejecutar la siguiente línea:

VarModel::@VarEstimation varest = VarModel::@VarEstimation::New(model, Real pmax = 15?);

me da errores y de tal manera que ni siquiera lo puedo mirar porque el tol se cierra.

Muchas gracias

Corregir TOLSH_PATH cuando es llamado desde R.

Al menos, disponer de una función que devuelva el root de TOL del proceso que está corriendo. Por ahora una posible solución (utilizando Tcl) es:

string map {{/stdlib/_init_stdlib.tol} {}} [lindex ::tol::info var {NameBlock TolCore}] 3]

The ex1.xls attached could not be read using ReadSeriesByCol. While the ex1.1.xls attached can be read.

The difference is that ex1.xls has the dates in text format while ex1.1.xls has the dates with date format.

#Require TolExcel;

TolExcel::@WorkBook xls = TolExcel::@WorkBook::Open("/tmp/ex1.xls");
Real xls::ActivateWS(1);
Set xls::ReadSeriesByCol( 1, 1, 12, 2, W, "%d-%m-%Y" );

Se requiere la implementacion de una funcion que retorne la identificacion del sistema y el compilador usado. Esto es necesario para introducir las mejoras en la gestion de paquetes binarios.

refs #1821

Para utilizar los paquetes que contienen archivos binarios (librerías .dll o .so) con las diferentes variantes de TOL (compiladas en distintos sistemas operativos y con distintos compiladores) disponibles es necesario crear variantes de estos paquetes. Véase #1821

Este tique recoge la necesidad de crear las variantes del paquete NonLinGloOpt.

Portar SaddExcel a un paquete público denominado TComExcel.

Al estimar un nodo de observaciones con una matriz de covarianzas, el muestreo de la sigma2 parece realizarse sobre el ruido estructurado (output-filter) y no sobre los residuos obtenidos al deshacer la estructura de covarianzas, ya que los valores obtenidos para la sigma2 no parecen corresponderse con lo esperado.

Se solicita la implementación de una alternativa a las funciones System o WinSystem que permita hacer llamadas al sistema operativo y que canalice las respuestas de la llamada.

De las dos funciones actuales sólo System es capaz de ejecutar comandos del sistema operativo como dir o copy. Sería deseable que esto fuese siempre así.

El siguiente código funciona con System pero no con WinSystem:

Real System("dir c:\\ > c:\\temp\\dir.txt");
Real System("del c:\\temp\\dir.txt");

Sin embargo ninguna es capaz de devolver la respuesta de la llamada, ni siquiera del error de la llamada devolviendo siempre:

• System:

  ERROR: [] 
  [2]=No such file or directory
  No se pudo ejecutar el mandato: 
  <...>
  

• WinSystem:

  ERROR: [] Error del Sistema Operativo 
  Creando el proceso 
  <...>
  El sistema no puede encontrar el archivo especificado.
  

A continuación se adjunta una implementación en código TOL de la función buscada que se apoya en la construcción de archivos temporales:

Text AnsSystem(Text cmd) {
  Text batFile = TmpDir<<"ans.bat";
  Text ansFile = TmpDir<<"ans.txt";
  Text errFile = TmpDir<<"ans.err.txt";
  Real FileDelete(batFile);
  Real FileDelete(ansFile);
  Real FileDelete(errFile);
  Text WriteFile(batFile, cmd<<" > "<<Qt(ansFile)<<" 2> "<<Qt(errFile));
  Real WinSystem(batFile, False, True);
  Text ans = ReadFile(ansFile);
  Text err = ReadFile(errFile);
  If(TextLength(err), Write("[AnsSystem] "<<err,"E"));
  Real FileDelete(batFile);
  Real FileDelete(ansFile);
  Real FileDelete(errFile);
  ans
};

Entiendo que sobre el modo de encaminar la respuesta y los errores hay distintas formas y quizá podría implementarse una variedad de la función que no mostrase el error sino que lo devolviese, algo semejante a Tcl_Eval devolviendo un conjunto con un real que indique el éxito de la llamada y un texto con la respuesta o el mensaje de error de la llamada. Esta función podría implementarse como System_Eval o algo así.

Hola, Las estimación probit por BSR da un error RandTruncatedMultNormal: No se pudieron cumplir las restriciones pero genera la cadena.

Se encuentran diversos errores al ejecutar tareas sencillas con MMS o ModelExcel debido a problemas en la función OSFilCopy y otras similares.

Se sospecha que el problema es debido a la ejecución de TOL en un entorno en el que la consola de comandos de Windows tiene restringido su uso.

Se solicita una función que permita obtener de manera similar a como funciona GetConsoleObject, el conjunto correspondiente a un archivo compilado.

Se solicita la sustitución de las funciones de la StdLib incluidas en el paquete ForComb.

Véase #1622.

Se sugiere la posibilidad de distribuir la librería de enlace a R con TOL.

Actualmente esta librería se incluye en el paquete tolLink para R.

De este modo podría generarse un nuevo paquete de R (alternativo a tolLink) sin componentes binarias que dependan del sistema operativo o plataforma.

Creo que es conveniente solucionar los errores ortográficos que presentan las funciones de TOL, de algunos incluso estoy empezando ya a acostumbrarme.

Empiezo con los de las funciones compiladas, que en la StdLib hay mucho que revisar:

• AsimetryS -> AsymmetryS
• Backasting -> Backcasting
• GetHardSoftPlattform -> GetHardSoftPlatform. No entiendo bien lo de "HardSoft", pero platform tiene una sola "t".
• MatTraze -> MatTrace
• OmmitFilter -> FilterMissings. El verbo omit tiene una sola "m". Sin embargo no creo que la mejor traducción de omitido sea omitted sino missing. Respecto al orden creo que lo más común es poner el verbo y luego lo que hace, sólo se suele anteponer al verbo el sujeto de la acción (y si fuera el caso sería algo como SerieFilterMissings).
• Tokenizer -> Tokenize. El verbo tokenize (separar por símbolos) no tiene 'r', no es como filter donde la acción el actor son iguales. Entiendo que ésta es una función muy común. Así que entiendo que podría admitirse como excepción.
• Covarianze -> Covariance
• Choleski* -> Cholesky*. Aunque el nombre del matemático francés es ​André-Louis Cholesky (con "y") parece bastante común usar la variante con "i", quizá por influencia del polaco (de donde viene el apellido). En este caso, quizá no merece la pena corregir el nombre, quizá podría admitirse la doble variante. Pero que conste que es con "y". En BSR sí se usa con 'y', por ejemplo en el nombre de las configuraciones: bsr.cholesky.epsilon, ...
• SwartzInf -> SchwarzInfo. Algo similar ocurre con el matemático austriaco Gideon E. Schwarz ​BIC y aquí no entiendo de dónde sale esa extraña ortografía. Esta función es de la StdLib, pero creo que este nombre aparece por algún lado más. Propongo también el cambio de Inf a Info como es común en muchas funciones (dejando Inf para Infinite) aunque el criterio de abreviatura no es claro. En caso de ambigüedad optaría por poner la palabra Information entera, aunque Info parece una abreviatura bastante intuitiva.
• Traspose, TrasposePivots -> Transpose, TransposePivots. En castellano se admite la versión con "n" y sin ella de transponer, pero en inglés no.

También creo que es bueno revisar la coherencia en el uso de abreviaturas y la composición de los nombres de las funciones. Pero bueno, eso quizá merece otro tique.

Buenas

Desde hace algún tiempo he notado que hay un problema con la función WriteLn. Es muy común, intentado hacer debug del código, ver el contenido de un conjunto haciendo un WriteLn y añadiendo un conjunto al texto a mostrar.

Si el conjunto contiene NameBlocks, tol, en ocasiones, se viene abajo. Depende del nameblock. He comprobado que falla con estimaciones, previsiones, variables (de un modelo), pero he comprobado que funciona para Set [[ NameBlock BabelTool ]] (en cuyo caso, muestra todos los contenidos del nameblock BabelTool hasta no sé cuál nivel de recursividad. Creo que muestra todas las cadenas de texto que hay dentro del NameBlock.

Independientemente del comportamiento que se decida para WriteLn en el caso de atacar un nameblock, agradecería que se solucionase el problema de la caída de Tol.

Muchas gracias, un saludo.

Se encuentran valores inesperados al concatenar matrices virtuales sin filas o columnas.

Los operadores | y << no funcionan bien con VMatrix cuando el número de filas o columnas es cero respectivamente.

Ejemplo:

VMatrix va = Zeros(10, 2) | Zeros(10, 0);
Real VRows(va);    //-> 10
Real VColumns(va); //-> 2

VMatrix vb = Zeros(0, 2) | Zeros(0, 5);
Real VRows(vb);    //-> 0
Real VColumns(vb); //-> 0!!! (7)

VMatrix vc = Zeros(2, 10) << Zeros(0, 10);
Real VRows(vc);    //-> 2
Real VColumns(vc); //-> 10

VMatrix vd = Zeros(2, 0) << Zeros(5, 0);
Real VRows(vd);    //-> 0!!! (7)
Real VColumns(vd); //-> 0

Las matrices vb y vd no se han construido correctamente.

Esto sin embargo sí funciona bien con las matrices comunes:

Matrix a = Zeros(10, 2) | Zeros(10, 0);
Real Rows(a);    //-> 10
Real Columns(a); //-> 2

Matrix b = Zeros(0, 2) | Zeros(0, 5);
Real Rows(b);    //-> 0
Real Columns(b); //-> 7

Matrix c = Zeros(2, 10) << Zeros(0, 10);
Real Rows(c);    //-> 2
Real Columns(c); //-> 10

Matrix d = Zeros(2, 0) << Zeros(5, 0);
Real Rows(d);    //-> 7
Real Columns(d); //-> 0

It is neccesary to add prior information about ARMA parameters: Hierarchical linear structure with latent, pure prior and domain restrictions should be added.

Internal mathematical algorithm is trivial due to the only one thing needed is to add log-density of current priors and modify intervals to the intersection with stationarity constraints.

No so easy will be to modify all API's to allow to define it.

Dynamic Heterocedasticity of Variance can be treated in a BSR specialized master with

1. a main Gibbs block having an standard BSR model
2. a Gibbs block for each heterocedastic variance that have another standard BSR over the squares of residuals of its segment

BSR model hipotesys over the residuals should be checked:

1. Normality
2. Independence
3. Outliers

In order to deal with large massive models TOL needs to have an internal way to work in parallel in a cluster of connected machines (distributed memory) and also in multiprocessor machines (shared memory).

It's neccessary to have a large battery of tests over most commonly used models in order to ensure backward compatibility of future changes.

This battery will be also very usefull as examples for learning of new users, and selecting a pattern to fast develop of new projects.

Los métodos tradicionales de post-procesado basados en el burn-in y el thinning son demasiado arbitrarios para poder parametrizarlos de forma automática sin intervención del usuario.

Implement and API to communicate with Ipopt, see: ​https://projects.coin-or.org/Ipopt

En procesos de cálculo numérico de gran complejidad como la estimación o simulación de modelos estadísticos se utilizan usualmente estructuras de datos bastante intrincadas que incluyen los datos conocidos y las variables cuyos valores se desea conocer.

Sin embargo, los algoritmos matemáticos están pensados para trabajar con simples vectores o matrices con los datos convenientemente colocados.

Por ejemplo, para manipular un modelo ARIMA, es necesario un conjunto de factores que son a su vez conjuntos que incluyen la periodicidad que es un número entero y los polinomios DIF, AR y MA. Tanto la periodicidad como las diferencias son datos conocidos mientras que en los polinomios AR y MA el coeficiente de grado 0 es siempre 1 y el resto de coeficientes son las variables del modelo. Para hacer ciertas operaciones, como la aplicación del filtro a una serie, conviene mantener la estructura de conjuntos de polinomios, pero para otras, como la aplicación de un método típico de optimización, conviene tener un vector con sólo los valores de las variables.

En un marco más general podríamos hablar de que existen operaciones estructurales y operaciones vectoriales, en el sentido de que las primeras se efectúan más cómoda y eficientemente usando las estructuras de datos originales, mientras que las segundas se realizan mucho mejor usando arreglos.

Si las operaciones estructurales y las vectoriales se suceden en el tiempo de forma alternativa dentro de un ciclo entonces es necesario pasar de una forma a la otra en cada iteración, lo cual puede llegar a ser muy ineficaz.

La solución más razonable para tratar con este tipo de problemas es el uso de referencias, de forma que la forma vectorial de los datos apunte realmente a la posición de memoria en la estructura original. De esta forma, cualquier cambio en una forma se ve automáticamente reflejado en la otra sin coste alguno.

Este tipo de tratamiento puede ser especialmente útil combinado con el uso de TolCint pero desde el propio TOL también se le puede sacar un gran partido.

La solución que se propone sería crear un nuevo tipo de datos en TOL que podría llamarse VectorRef y que tendría funciones para ir añadiendo referencias a valores reales inscritos en distintos tipos de datos TOL. En principio se podrían crear referencias simples o masivas a datos de estos tipos

• Real

  //Creates a single reference to a Real variable
  VectorRef Ref.Real(Real x);
  

• Polyn

  //Creates a single reference to a coefficient of a polynomial
  VectorRef Ref.Polyn.Coef(Polyn pol, Real deg));
  //Creates a vectorial reference to all coefficients of a polynomial among a selection of degrees
  VectorRef Ref.Polyn.Extract(Polyn pol, Set degrees));
  //Creates a vectorial reference to all coefficients of a polynomial
  VectorRef Ref.Polyn.Full(Polyn pol));
  

• Matrix

  //Creates a single reference to a cell in a Matrix
  VectorRef Ref.Matrix.Cell(Matrix mat, Real row, Real column));
  //Creates a vectorial reference to all cells in a rectangle of a Matrix
  VectorRef Ref.Matrix.Minor(Matrix mat, Real fromRow, Real fromColumn, Real untilRow, Real untilColumns));
  //Creates a vectorial reference to all cells in a subset of selected rows from a Matrix
  VectorRef Ref.Matrix.Rows(Matrix mat, Set rowIndexs));
  //Creates a vectorial reference to all cells in a subset of selected coluns from a Matrix
  VectorRef Ref.Matrix.Columns(Matrix mat, Set colIndexs));
  //Creates a vectorial reference to all cells in a Matrix
  VectorRef Ref.Matrix.Full(Matrix mat, Set colIndexs));
  

• Set

  //Creates a single reference to a Real element of a Set
  VectorRef Ref.Set.Element(Set set, Real numElement));
  //Creates a vectorial reference to all selected elements of a Set
  VectorRef Ref.Set.Extract(Set set, Set indexes));
  //Creates a vectorial reference to all selected elements of a Set with type Real
  VectorRef Ref.Set.Full(Set set));
  //Creates a vectorial reference to all selected elements of a Set with type Real, Polyn or Matrix, and recursively in elements of type Set or NameBlock
  VectorRef Ref.Set.Deep(Set set));
  
  

• NameBlock

  //Creates a single reference to a Real member of a NameBlock
  VectorRef Ref.NameBlock.Element(NameBlock nb, Real numElement));
  //Creates a vectorial reference to all selected members of a NameBlock 
  VectorRef Ref.NameBlock.Extract(NameBlock nb, Set indexes));
  //Creates a vectorial reference to all selected members of a NameBlock with type Real
  VectorRef Ref.NameBlock.Full(NameBlock nb));
  //Creates a vectorial reference to all selected members of a NameBlock with type Real, Polyn or Matrix, and recursively in elements of type Set or NameBlock
  VectorRef Ref.NameBlock.Deep(NameBlock nb));
  
  

Sería necesario también disponer de algunas funciones para la definición de vectores de referencia a partir de otros mediante composición y extracción.

//Añade al primer vector de referecias las del segundo
VectorRef Ref.Append(VectorRef a, VectorRef b);
//Extrae las referencias seleccionadas
VectorRef Ref.Extract(VectorRef a, Real indexes);

Para su uso con CINT haría falta una función de exportación

  Real Cint.ExportRef(VectorRef a [, Text nameSpace=""])

lo cual crearía en el ámbito global o el namespace especificado una instancia de la clase con el nombre de la variable exportada

class VectorRef
{
private:
  int s_;
  double** ref_;
public:
  VectorRef(int s, double** ref)
  : s_(s),
    ref_(ref)
  {}
 ~VectorRef() {}

  int size() const;

  //zero based const array access
  const double & operator [] (int i) const { return (*ref_[i]); }
  //zero based non const array access
  double & operator [] (int i) { return (*ref_[i]); }

  //one based const array access
  const double & operator () (int i) const { return (*ref_[i-1]); }
  //one based non const array access
  double & operator () (int i) { return (*ref_[i-1]); }

  //set the referenced values from an std::vector
  void setValues(const std::vector<double>& v)
  {
    if(v.size()==s_)
    {
      int i;
      double* rf = ref_;
      for(i=0; i<s; i++, rf++) { *rf = v[i]; }
    }
  }
  //get the referenced values into a std::vector
  void getValues(std::vector<double>& v) const
  {
    if(v.size()==s_)
    {
      int i;
      double* rf = ref_;
      for(i=0; i<s; i++, rf++) { v[i] = *rf; }
    }
  };

  //set the referenced values from a pointer to double
  void setValues(const double* v)
  {
    int i;
    double* rf = ref_;
    const double* v_ = ref_;
    for(i=0; i<s; i++, rf++, v_++) { *rf = *v_; }
  }
  //get the referenced values into a a pointer to double
  void getValues(double* v) const
  {
    int i;
    double* rf = ref_;
    const double* v_ = ref_;
    for(i=0; i<s; i++, rf++, v_++) { *v_ = *rf; }
  };

Finalmente haría falta una función para lectura y escritura desde y a Matrix

//Devuelve una matriz columna con los valores referenciados
Matrix v = Ref.Get(vr);
//Modifica los valores referenciados haciéndolos iguales a los elementos de una matriz columna con el mismo número de elementos
Real Ref.Put(vr,v*2);

De esta forma en cada iteración de un hipotético ciclo TOL sólo sería necesario llamar una vez a cada una de estas dos funciones.