Changeset 1120932 in tol

Timestamp:

Jun 24, 2024, 4:59:36 PM (2 years ago)

Author:

pradeep <pradeep.bangera@…>

Branches:

devel

Children:

b216c65

Parents:

e95dfdb

Message:

Changes done to compile successfully on Ubuntu22

Files:

• .gitignore (modified) (1 diff)
• tol/CMakeLists.txt (modified) (6 diffs)
• tol/OIS/oisxml.cpp (modified) (4 diffs)
• tol/OIS/tol_ois.h (modified) (1 diff)
• tol/bbasic/tol_btext.h (modified) (1 diff)
• tol/btol/matrix_type/matgra.cpp (modified) (62 diffs)
• tol/btol/serie_type/tsrgrai.cpp (modified) (24 diffs)
• tol/btol/timeset_type/tol_btmsgra.h (modified) (6 diffs)
• tol/btol/vmatrix_type/vmatgra.cpp (modified) (41 diffs)

.gitignore

@@ -31 +31 @@
 *.out
 *.app
+
+# Others
+*.json
+
+# build/release
+tol/build/*

tol/CMakeLists.txt

@@ -34 +34 @@
     PATHS ${PKG_FFTW_LIBRARY_DIRS}
     )
-  #message( "aaaaaa FFTW_LIB ${FFTW_LIB}" )
   #-DFFTW_ROOT:PATH=c:/MinGW/msys/1.0/local -DFFTW_USE_STATIC_LIBS=1 
   set( CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/Runtime_Base" )
@@ -59 +58 @@
   add_definitions( "-Wall" )
 endif( MINGW )
+
 if( WIN32 )
   add_definitions( -DTOLDLL_EXPORTS )
@@ -111 +111 @@
 function( download_tol_package pkg bin )
   # WGET should be previously searched and the variables WGET_EXECUTABLE and WGET_ERROR_MESSAGE defined
-  set( url "http://packages.tol-project.org/OfficialTolArchiveNetwork/repository.php?action=download&format=attachment&tol_package_version=4&package=${pkg}" )
-  # Obtains package name for current platform
+  set( url "http://packages.tol-prj.org/OfficialTolArchiveNetwork/repository.php?action=download&format=attachment&tol_package_version=4&package=${pkg}" )
+  # Obtains package name for the current platform.
   if( ${bin} )
     get_tol_plat( tol_plat )
-        set( url "${url}%23${tol_plat}" )       
-        set( pkg_plat "${pkg}#${tol_plat}" )
-        message( STATUS "Downloading last version of '${pkg}' for platform '${tol_plat}' ..." )
+          set( url "${url}%23${tol_plat}" )     
+          set( pkg_plat "${pkg}#${tol_plat}" )
+          message( STATUS "Downloading last version of '${pkg}' for platform '${tol_plat}' ..." )
   else( )
     set( tol_plat "" )
-        set( pkg_plat "${pkg}" )        
-        message( STATUS "Downloading last version of '${pkg}' ..." )
+          set( pkg_plat "${pkg}" )      
+          message( STATUS "Downloading last version of '${pkg}' ..." )
   endif( )
   # Removes previous downloaded versions of the package if necessary
@@ -159 +159 @@
     set( TOL_SUBLIBRARIES $<TARGET_OBJECTS:${name}> CACHE INTERNAL "" )
   else( )
-    set( TOL_SUBLIBRARIES "${TOL_SUBLIBRARIES};$<TARGET_OBJECTS:${name}>" 
-      CACHE INTERNAL "" )
+    set( TOL_SUBLIBRARIES "${TOL_SUBLIBRARIES};$<TARGET_OBJECTS:${name}>" CACHE INTERNAL "" )
   endif( )
 endmacro( )
@@ -174 +173 @@
   endif( WIN32 )
   file( GLOB headers RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" *.h *.hpp )
-  install( FILES ${headers} DESTINATION "include/tol"
-        COMPONENT DEVELOPMENT )
+  install( FILES ${headers} DESTINATION "include/tol" COMPONENT DEVELOPMENT )
   if( skip_copy_headers )
     message( STATUS "Skipping create_header_links for ${CMAKE_CURRENT_SOURCE_DIR}" )
@@ -566 +564 @@
     # Download default packages
     download_tol_package( StdLib 0 )
-    download_tol_package( TclCore 1 )
+    download_tol_package( TclCore 0 )
         # Obtain the list of the downloaded default packages
     file( GLOB default_zips "${CMAKE_CURRENT_BINARY_DIR}/*.zip" )       

tol/OIS/oisxml.cpp

@@ -214 +214 @@
         }
       }
-      header_->Print("<file_%d><path>%s</path><release>%s</release><size>%"_LLD64_"</size></file_%d>\n", 
+      header_->Print("<file_%d><path>%s</path><release>%s</release><size>%s</size></file_%d>\n",
+                    _LLD64_, 
                      n+1,
                      path.String(), 
@@ -245 +246 @@
     if(allFiles_[n])
     {                           
-      header_->Print("<%s><size>%"_LLD64_"</size><entries>%ld</entries></%s>\n",
+      header_->Print("<%s><size>%s</size><entries>%ld</entries></%s>\n",
+                    _LLD64_,
                     allFiles_[n]->Title().String(), 
                     stat_.fileStat_[n].bytes_, 
@@ -551 +553 @@
     XMLEnsure(XMLGetNextTagValue(tag_, value_, "path"   )); tolSources_[n].path_ = value_;
     XMLEnsure(XMLGetNextTagValue(tag_, value_, "release")); tolSources_[n].release_ = dateFmt_.TextToDate(value_);
-    XMLEnsure(XMLGetNextTagValue(tag_, value_, "size"   )); 
-    sscanf(value_,"%"_LLD64_,&tolSources_[n].bytes_  ); 
+    XMLEnsure(XMLGetNextTagValue(tag_, value_, "size"   ));
+    sscanf(value_,_LLD64_,&tolSources_[n].bytes_  ); 
     XMLEnsure(XMLEnsureEndTag   (fn.String()));
     
@@ -600 +602 @@
     XMLEnsure(XMLGetNextTagTitle(tag_, allFiles_[n]->Title().String()));
     XMLEnsure(XMLGetNextTagValue(tag_, value_, "size"   ));
-    sscanf(value_,"%"_LLD64_, &stat_.fileStat_[n].bytes_  );
+    sscanf(value_,_LLD64_, &stat_.fileStat_[n].bytes_  );
     XMLEnsure(XMLGetNextTagValue(tag_, value_, "entries")); sscanf(value_,"%d",   &stat_.fileStat_[n].entries_);
     XMLEnsure(XMLEnsureEndTag   (allFiles_[n]->Title().String()));

tol/OIS/tol_ois.h

@@ -52 +52 @@
 
 #if defined( __MINGW32__ ) || ( defined(_MSC_VER) && (_MSC_VER<1400) )
-#  define _LLD64_ "I64d"
+#define _LLD64_ "%I64d"
 #else
-#  define _LLD64_ "lld"
+#define _LLD64_ "%lld"
 #endif
 

tol/bbasic/tol_btext.h

@@ -431 +431 @@
 
 
-        friend BText TmpFileName(const BText& path=BText::None(), const BText& prefix=BText::None());
+        friend BText TmpFileName(const BText& path, const BText& prefix);
 
 

tol/btol/matrix_type/matgra.cpp

@@ -169 +169 @@
           (int)sizeof(BDat)+
           I2("\n Expected file size: ",
-             "\n Tamaño esperado del fichero:")+
+             "\n Tamaï¿œo esperado del fichero:")+
           (int)(rows*cols*sizeof(BDat)+2*sizeof(int))+
           I2("\n Real file size e: ",
-             "\n Tamaño real del fichero:")+(int)fs + comment;
+             "\n Tamaï¿œo real del fichero:")+(int)fs + comment;
          if(msgType=='E') { Error(msg); }
     else if(msgType=='W') { Warning(msg); }
@@ -454 +454 @@
        "(Text nombreFichero, Matrix mat)"),
     I2("Append matrix 'mat' to file 'filename'.",
-       "Añade la matrix 'mat' al fichero 'nombreFichero'."),
+       "Aï¿œade la matrix 'mat' al fichero 'nombreFichero'."),
     BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -473 +473 @@
      "BINARY: "+
      I2("Standard TOL binary format",
-        "Formato estándar binario de TOL ")+
+        "Formato estï¿œndar binario de TOL ")+
      "WGRIB2TXT: "+
      I2("Result of command", "Resultado del comando")+
@@ -482 +482 @@
      " ...\n" +
      " datum[rows,cols]\n"+
-     I2("View more on ", "Ver más en ")+
+     I2("View more on ", "Ver mï¿œs en ")+
      "http://www.cpc.noaa.gov/products/wesley/wgrib2/",
     BOperClassify::MatrixAlgebra_);
@@ -533 +533 @@
   I2("Returns rows and columns of the matrix stored in a file with "
      "binary format",
-     "Devuelve el número de filas y columnas de la matriz almacenada "
+     "Devuelve el nï¿œmero de filas y columnas de la matriz almacenada "
      "en un fichero con formato binario"),
     BOperClassify::MatrixAlgebra_);
@@ -569 +569 @@
      "Lee un rango de filas de una matriz de un fichero en formato binario\n"
      "Si el argumento <file> es un Text entonces el fichero en ese "
-     "camino será abierto antes de leer y cerrado después.\n"
+     "camino serￜ abierto antes de leer y cerrado despuￜs.\n"
      "Si el argumento <file> es un Real creado con FOpen entonces el "
-     "fichero ya está abierto y será el usuario el que lo cierre cuando "
-     "se requiera. Este es el método más rápido cuando hay que hacer "
-     "múltiples lecturas sobre un mismo fichero.\n"
-     "Si además los argumentos <numRows> y <numColumns> son mayores que "
-     "cero entonces no será necesario leerlos del propio fichero lo cual "
+     "fichero ya estￜ abierto y serￜ el usuario el que lo cierre cuando "
+     "se requiera. Este es el mï¿œtodo mï¿œs rï¿œpido cuando hay que hacer "
+     "mï¿œltiples lecturas sobre un mismo fichero.\n"
+     "Si ademï¿œs los argumentos <numRows> y <numColumns> son mayores que "
+     "cero entonces no serￜ necesario leerlos del propio fichero lo cual "
      "puede acelerarse mucho el proceso."),
     BOperClassify::MatrixAlgebra_);
@@ -624 +624 @@
      "Lee un rango de filas de una matriz de un fichero en formato binario\n"
      "El argumento <file> es el resultado de una llamada previa a FOpen.\n"
-     "El argumento <rows> indica las líneas a ser leídas."),
+     "El argumento <rows> indica las lï¿œneas a ser leï¿œdas."),
     BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -667 +667 @@
      "Lee una celda de una matriz de un fichero en formato binario\n"
      "Si el argumento <file> es un Text entonces el fichero en ese "
-     "camino será abierto antes de leer y cerrado después.\n"
+     "camino serￜ abierto antes de leer y cerrado despuￜs.\n"
      "Si el argumento <file> es un Real creado con FOpen entonces el "
-     "fichero ya está abierto y será el usuario el que lo cierre cuando "
-     "se requiera. Este es el método más rápido cuando hay que hacer "
-     "múltiples lecturas sobre un mismo fichero.\n"
-     "Si además los argumentos <numRows> y <numColumns> son mayores que "
-     "cero entonces no será necesario leerlos del propio fichero lo cual "
+     "fichero ya estￜ abierto y serￜ el usuario el que lo cierre cuando "
+     "se requiera. Este es el mï¿œtodo mï¿œs rï¿œpido cuando hay que hacer "
+     "mï¿œltiples lecturas sobre un mismo fichero.\n"
+     "Si ademï¿œs los argumentos <numRows> y <numColumns> son mayores que "
+     "cero entonces no serￜ necesario leerlos del propio fichero lo cual "
      "puede acelerarse mucho el proceso."),
     BOperClassify::MatrixAlgebra_);
@@ -1489 +1489 @@
 DefIntOpr(1, BMat##FUN, #FUN, 1, 1,               \
 "(Matrix mat)",                     \
-I2("Returns "ENGLISH" of each element of a matrix.",           \
-  "Devuelve "SPANISH" de cada elemento de una matriz."),         \
+I2("Returns "+ENGLISH+" of each element of a matrix.",           \
+  "Devuelve "+SPANISH+" de cada elemento de una matriz."),         \
 BOperClassify::MatrixAlgebra_);                 \
                        \
@@ -1850 +1850 @@
   I2("Given a column or row of any realignment of integers numbers "
      "1 ... N returns the inverse permutation. ",
-     "Dada una fila o columna con una reordenación cualquiera de "
-     "los enteros 1 ... N, devuelve la permutación inversa."),
+     "Dada una fila o columna con una reordenaciï¿œn cualquiera de "
+     "los enteros 1 ... N, devuelve la permutaciï¿œn inversa."),
     BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -1967 +1967 @@
   I2("Applies the Cholesky decomposition to solve X in the linear "
      "regresion M*X=B+e ",
-     "Aplica la descomposición de Cholesky para resolver X en la "
-     "regresión lineal M*X=B+e."),
+     "Aplica la descomposiciï¿œn de Cholesky para resolver X en la "
+     "regresiï¿œn lineal M*X=B+e."),
     BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -1994 +1994 @@
      "sistema lineal M*X=B comenzando por el valor inicial <X0> y "
      "continuando hasta  que el error sea menor que <chop> o se "
-     "supere el número de iteraciones indicadas."),
+     "supere el nï¿œmero de iteraciones indicadas."),
     BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -2108 +2108 @@
      "passing Diag(n,1) as B argument.",
      "Aplica el metodo de reduccion de Gauss para invertir una matriz "
-     "cuadrada triangular inferior. Para sistemas triangulares más generales "
+     "cuadrada triangular inferior. Para sistemas triangulares mï¿œs generales "
      "use TrSolve pasando Diag(n,1) como argumento B"),
     BOperClassify::MatrixAlgebra_);
@@ -2131 +2131 @@
      "Aplica el metodo de reduccion de Gauss para resolver el sistema "
      "lineal L*X=B donde L es triangular inferior. Para sistemas triangulares "
-     "más generales use TrSolve"),
+     "mï¿œs generales use TrSolve"),
     BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -2717 +2717 @@
      "the hyper-rectangle defined by limits [xMin,xMax].",
      "Devuelve el vector de escalado con el que se obtienen variaciones "
-     "unitarias de las evaluaciones de una función en un entorno de "
-     "un punto dado x0 interior al hiper-rectángulo definido por los "
-     "límites [xMin,xMax]."
+     "unitarias de las evaluaciones de una funciï¿œn en un entorno de "
+     "un punto dado x0 interior al hiper-rectï¿œngulo definido por los "
+     "lï¿œmites [xMin,xMax]."
      ),
     BOperClassify::NumericalAnalysis_);
@@ -2758 +2758 @@
      "function ---> function to be analyzed,                             \n"
      "point    ---> point where the gradient is calculated               \n",
-     "Calcula el gradiente numérico de una funcion evaluada en un punto "
+     "Calcula el gradiente numï¿œrico de una funcion evaluada en un punto "
      "dado.\n"
-     "En primer lugar intenta usar la fórmula central de cinco puntos. "
-     "Si el punto está muy cerca de la frontera del dominio, es posible que "
-     "la evaluación falle en algún punto lateral. En tal caso se intentará " 
-     "usar una fórmula asimétrica con cuatro o tres puntos.\n" 
+     "En primer lugar intenta usar la fï¿œrmula central de cinco puntos. "
+     "Si el punto estￜ muy cerca de la frontera del dominio, es posible que "
+     "la evaluaciￜn falle en algￜn punto lateral. En tal caso se intentarￜ " 
+     "usar una fï¿œrmula asimï¿œtrica con cuatro o tres puntos.\n" 
      "Argumentos:                                                        \n" 
       "function ---> funcion a analizar,                                 \n"
@@ -2806 +2806 @@
      "  function ---> function to be analyzed,                             \n"
      "  point    ---> point where the gradient is calculated               \n",
-     "Calcula el vector segundo gradiente numérico (diagonal del hessiano) "
+     "Calcula el vector segundo gradiente numï¿œrico (diagonal del hessiano) "
      "de una funcion evaluada en un punto dado.          \n"
-     "En primer lugar intenta usar la fórmula central de cinco puntos. "
-     "Si el punto está muy cerca de la frontera del dominio, es posible que "
-     "la evaluación falle en algún punto lateral. En tal caso se intentará " 
-     "usar una fórmula asimétrica con cuatro o tres puntos.\n" 
+     "En primer lugar intenta usar la fï¿œrmula central de cinco puntos. "
+     "Si el punto estￜ muy cerca de la frontera del dominio, es posible que "
+     "la evaluaciￜn falle en algￜn punto lateral. En tal caso se intentarￜ " 
+     "usar una fï¿œrmula asimï¿œtrica con cuatro o tres puntos.\n" 
      "Argumentos:                                                          \n" 
      "  function ---> funcion a analizar,                                  \n"
@@ -2850 +2850 @@
      "function ---> function to be analyzed,                                    \n"
      "point    ---> point where the hessian is calculated                       \n",
-     "Calcula el hessiano numérico de una funcion evaluada en un punto dado.     \n"
+     "Calcula el hessiano numï¿œrico de una funcion evaluada en un punto dado.     \n"
      "Argumentos:                                                               \n" 
       "function ---> funcion a analizar,                                        \n"
@@ -2980 +2980 @@
      "http://www.network-theory.co.uk/docs/gslref/TheMultinomialDistribution.html ",
      "Devuelve una matriz de filas distribuidas como multinomiales con "
-     "tamaño poblacional <N> y vector de probabilidades <p>\n."
+     "tamaï¿œo poblacional <N> y vector de probabilidades <p>\n."
      "Esta funcion llama a la funcion GSL gsl_ran_multinomial: "
      "http://www.network-theory.co.uk/docs/gslref/TheMultinomialDistribution.html "),
@@ -3153 +3153 @@
             "be sets with the same number of reals ",
             "Fallo en formato de conjunto: todos sus elementos "
-            "deberían ser conjuntos con el mismo número de reales");
+            "deberï¿œan ser conjuntos con el mismo nï¿œmero de reales");
   if(!set.Card() || (set[1]->Grammar()->Name()!="Set"))
   {
@@ -3165 +3165 @@
   {
     Warning(_mid+I2("Emty set is converted in empty matrix",
-             "El conjunto vacío se convierte en la matriz vacía"));
+             "El conjunto vacï¿œo se convierte en la matriz vacï¿œa"));
     mat = BMat::Unknown();
   }
@@ -3296 +3296 @@
       if(y>=y1) 
       {
-        Error(I2("Invalid access in","Acesso inválido en")+ " PolMat " +
+        Error(I2("Invalid access in","Acesso invï¿œlido en")+ " PolMat " +
               " r="+r+
               " c="+c+
@@ -3320 +3320 @@
   I2("Returns the matrix representation of a backshift polynomial.",
      "Devuelve la representacion matricial de un polinomio de retardos."
-     "Si el polinomio no contiene términos en F, entonces "
+     "Si el polinomio no contiene tï¿œrminos en F, entonces "
      "se trata de una matriz triangular inferior que tiene todos los "
      "valores de la diagonal principal iguales al coeficiente de grado 0 "
      "del polinomio, y los de las diagonales inferiores iguales al "
      "coeficiente del grado correspondiente. "
-     "Si tiene térmnos en F, ocurre de forma análoga con las diagonales "
+     "Si tiene tï¿œrmnos en F, ocurre de forma anï¿œloga con las diagonales "
      "superiores"),
     BOperClassify::Conversion_);
@@ -3491 +3491 @@
      "does nothing and returns 0, else returns the total number of "
      "rows.",
-     "Modifica la primera matriz añadiéndole todas las filas de la"
-     "segunda. En caso de éxito, devuelve el número total de filas,"
-     "pero si las dos matrices no tienen el mismo número de columnas "
+     "Modifica la primera matriz aï¿œadiï¿œndole todas las filas de la"
+     "segunda. En caso de ï¿œxito, devuelve el nï¿œmero total de filas,"
+     "pero si las dos matrices no tienen el mismo nï¿œmero de columnas "
      "no hace nada y devuelve 0."),
       BOperClassify::MatrixAlgebra_);
@@ -3597 +3597 @@
      "Si la matriz no es cuadrada silo se tendra en cuenta la submatriz "
      "menor principal.\n"
-     "Si el tamaño de <m> es n entonces el tamaño del vector devuelto "
+     "Si el tamaï¿œo de <m> es n entonces el tamaï¿œo del vector devuelto "
      "sera k=n*(n+1)/2\n" 
      "Para restaurar la matriz triangular use SetTriang"),
@@ -3651 +3651 @@
      "  una matriz triangular inferior si <UPLOSI>==\"L\" \n"
      "  una matriz simetrica si <UPLOSI>==\"S\" \n"
-     "El tamaño del vector <v> debe ser un entero k tal que "
-     "k=n*(n+1)/2, siendo n el tamaño de la matriz cuadrada "
+     "El tamaï¿œo del vector <v> debe ser un entero k tal que "
+     "k=n*(n+1)/2, siendo n el tamaï¿œo de la matriz cuadrada "
      "resultante"),
     BOperClassify::MatrixAlgebra_);
@@ -3708 +3708 @@
   I2("Adds right columns to a orthonormal matrix in order to obtain a "
      "orthonormal matrix of m columns",
-     "Añade columnas a una matriz ortonormal para obtener una matriz "
+     "Aï¿œade columnas a una matriz ortonormal para obtener una matriz "
      "ortonormal de m columnas."),
     BOperClassify::MatrixAlgebra_);
@@ -3811 +3811 @@
   {
     Error(I2("Wrong dimensions for ",
-               "Dimensiones erróneas para ")+
+               "Dimensiones errï¿œneas para ")+
             "PostProdDiag({"+m+"x"+n+"},{"+s+"x"+s+"})");
     return;
@@ -3857 +3857 @@
   {
     Error(I2("Wrong dimensions for ",
-               "Dimensiones erróneas para ")+
+               "Dimensiones errï¿œneas para ")+
             "PreProdDiag({"+s+"x"+s+"},{"+m+"x"+n+"})");
     return;
@@ -5196 +5196 @@
     Warning(I2("Boostrap size should be a positive value, "
                "assuming BSize = 1000",
-               "El tamaño del boostrap debe ser positivo, "
+               "El tamaï¿œo del boostrap debe ser positivo, "
                "asumiremos BSize = 1000"));
     B = 1000;
@@ -5497 +5497 @@
     Warning(I2("Boostrap size should be a positive value, "
                "assuming BSize = 1000",
-               "El tamaño del boostrap debe ser positivo, "
+               "El tamaï¿œo del boostrap debe ser positivo, "
                "asumiremos BSize = 1000"));
     B = 1000;
@@ -6141 +6141 @@
        "   s2,A: s2*A es parametro covarianza de la distribucion N_R. Ver debajo la descripcion del parametro A.\n"
        "    B,b: B*X<=b define la region R asociada a las restricciones lineales.\n"
-       "   size: tamaño de la cadena de markov solicitado.\n"
+       "   size: tamaï¿œo de la cadena de markov solicitado.\n"
        "burning: numero de muestras descartadas.\n"
        "     X0: punto inicial de la cadena. Debe pertencer a R, es decir B*X0<=b.\n\n"
@@ -6339 +6339 @@
              "    Matrix b = Col(0.0, 0.0);\n"
              "    Matrix sample = RandConstrainedMNormal(mu, COV, B, b, 1, 100);",
-       "Realiza una muestra a partir de una multinormal truncada donde la zona de muestreo viene dada por un sistema de desigualdades lineales Bx <= b. El parametro 'size' indica el tamaño de la cadena de markov a generar para obtener la muestra.\n"
+       "Realiza una muestra a partir de una multinormal truncada donde la zona de muestreo viene dada por un sistema de desigualdades lineales Bx <= b. El parametro 'size' indica el tamaï¿œo de la cadena de markov a generar para obtener la muestra.\n"
        "La matriz de covarianza COV puede especificarse en diversas formas:\n"
        "  Matrix COV : iternamente se usa cholesky para descomponer la matrix\n"
@@ -6408 +6408 @@
              "    Matrix c2 = Col(1.0, 1.5);\n"
              "    Matrix MCsample = GibbsRectangleMNormal(mu, COV, c1, c2, 1, 100);",
-       "Genera una cadena de markov para una multinormal truncada donde la zona de muestreo es el rectangulo multidimensional definido por las esquinas c1,c2. El parametro 'size' indica el tamaño de la cadena.\n"
+       "Genera una cadena de markov para una multinormal truncada donde la zona de muestreo es el rectangulo multidimensional definido por las esquinas c1,c2. El parametro 'size' indica el tamaï¿œo de la cadena.\n"
        "La matriz de covarianza COV puede especificarse en diversas formas:\n"
        "  Matrix COV : iternamente se usa cholesky para descomponer la matrix\n"
@@ -6475 +6475 @@
              "    Matrix c2 = Col(1.0, 1.5);\n"
              "    Matrix MCsample = RandRectangleMNormal(mu, COV, c1, c2, 1, 100);",
-       "Realiza una muestra a partir de una multinormal truncada donde la zona de muestreo es el rectangulo multidimensional definido por las esquinas c1,c2. El parametro 'size' indica el tamaño de la cadena.\n"
+       "Realiza una muestra a partir de una multinormal truncada donde la zona de muestreo es el rectangulo multidimensional definido por las esquinas c1,c2. El parametro 'size' indica el tamaï¿œo de la cadena.\n"
        "La matriz de covarianza COV puede especificarse en diversas formas:\n"
        "  Matrix COV : iternamente se usa cholesky para descomponer la matrix\n"
@@ -6544 +6544 @@
              "es el rectangulo multidimensional definido por las esquinas c1,c2.\n"
              "Por razones de eficiencia la matriz de covarianzas viene dada por la descomposicion triangular cov=L*Tra(L)\n"
-             "El parametro 'size' indica el tamaño de la cadena.\n"
+             "El parametro 'size' indica el tamaï¿œo de la cadena.\n"
              "Si L es la matriz 1x1 con el elemento 1 entonces la matriz de covarianzas se asumira unitaria.\n"
              "Si test==Cierto la funcion chequeara que todos los valores devueltos cumplen las restricciones\n."
@@ -6685 +6685 @@
      ,
      "En matematicas, el producto de Kronecker, denotado por una x dentro "
-     "de un circulo, es una operacion de dos matrices de tamaño arbitrario "
+     "de un circulo, es una operacion de dos matrices de tamaï¿œo arbitrario "
      "dando por resultado la matriz del bloque (aij*B).  "
      "Es un caso especial de un producto del tensor. El producto de "
@@ -6875 +6875 @@
   if (L >= U) {
     english += "invalid interval: upper must be greater than lower";
-    spanish += "intervalo inválido: sup debe ser mayor que inf";
+    spanish += "intervalo invï¿œlido: sup debe ser mayor que inf";
     Error(I2(english,spanish));
     return;
@@ -6886 +6886 @@
     if (!dat_x0->IsFinite() || x0<L || x0>U) {
       english += "invalid x0 argument value: must be finite and included in [L,U]";
-      spanish += "valor de argumento x0 inválido: debe ser finito e incluido en [L,U]";
+      spanish += "valor de argumento x0 invï¿œlido: debe ser finito e incluido en [L,U]";
       Error(I2(english,spanish));
       return;
@@ -6897 +6897 @@
       if (!dat_size->IsFinite()) {
         english += "invalid size argument value: must be finite";
-        spanish += "valor de argumento size inválido";
+        spanish += "valor de argumento size invï¿œlido";
         Error(I2(english,spanish));
         return;
@@ -6907 +6907 @@
         if (!dat_burn->IsFinite()) {
           english += "invalid size argument value: must be finite";
-          spanish += "valor de argumento size inválido";
+          spanish += "valor de argumento size invï¿œlido";
           Error(I2(english,spanish));
           return;
@@ -6920 +6920 @@
                 cod->Operator()->MaxArg()!=2) {
               english += "invalid argument number for logf argument: should be 2";
-              spanish += "número de argumentos inválidos para argumento logf: debe ser 2";
+              spanish += "nï¿œmero de argumentos invï¿œlidos para argumento logf: debe ser 2";
               Error(I2(english,spanish));  
               return;
@@ -6929 +6929 @@
               english += cod->Operator()->GrammarForArg(2)->Name();
               english += " for second argument of logf argument: should be Set";
-              spanish += "tipo inválido ";
+              spanish += "tipo invï¿œlido ";
               spanish += cod->Operator()->GrammarForArg(2)->Name();
               spanish += " en el segundo argumento del argumento logf: debe ser Set";
@@ -6944 +6944 @@
             if (!dat_w->IsFinite()) {
               english += "invalid w argument value: must be finite";
-              spanish += "valor de argumento w inválido";
+              spanish += "valor de argumento w invï¿œlido";
               Error(I2(english,spanish));
               return;
@@ -6952 +6952 @@
               if (!dat_m->IsKnown()) {
                 english += "invalid m argument value: must be known";
-                spanish += "valor de argumento m inválido: debe ser conocido";
+                spanish += "valor de argumento m invï¿œlido: debe ser conocido";
                 Error(I2(english,spanish));
                 return;
@@ -6972 +6972 @@
               cod->Operator()->MaxArg()!=1) {
             english += "invalid argument number for logf argument: should be 1";
-            spanish += "número de argumentos inválidos para argumento logf: debe ser 1";
+            spanish += "nï¿œmero de argumentos invï¿œlidos para argumento logf: debe ser 1";
             Error(I2(english,spanish));  
             return;
@@ -6993 +6993 @@
   if (!cod->Operator()) {
     english += "invalid code argument";
-    spanish += "argumento código inválido";
+    spanish += "argumento cï¿œdigo invï¿œlido";
     Error(I2(english,spanish));
     return;
@@ -7003 +7003 @@
     english += cod->Grammar()->Name();
     english += " for logf argument: should be Real";
-    spanish += " tipo inválido ";
+    spanish += " tipo invï¿œlido ";
     spanish += cod->Grammar()->Name();
     spanish += " para argumento logf: debe ser Real";
@@ -7015 +7015 @@
     english += cod->Operator()->GrammarForArg(1)->Name();
     english += " for first argument of logf argument: should be Real";
-    spanish += "tipo inválido ";
+    spanish += "tipo invï¿œlido ";
     spanish += cod->Operator()->GrammarForArg(1)->Name();
     spanish += " en el primer argumento del argumento logf: debe ser Real";
@@ -7138 +7138 @@
      "[[-2,3]] ordena por la segunda columna descendente y por la "
      "tercera ascendente en caso de empate."
-     "Devuelve la matriz de permutación tal que PivotByRows(mat,p) "
+     "Devuelve la matriz de permutaciï¿œn tal que PivotByRows(mat,p) "
      "es la matriz ordenada."),
      BOperClassify::Statistic_);
@@ -7213 +7213 @@
      "column with the maximum value inside these row, and second one "
      "the maximum value. Unknown values are skipped.",
-     "Devuelve dos columnas para cada fila: la primera con el índice "
-     "de la columna de máximo valor dentro de esa fila, y la segunda "
-     "con dicho valor máximo. Los valores omitidos no se tienen en "
+     "Devuelve dos columnas para cada fila: la primera con el ï¿œndice "
+     "de la columna de mï¿œximo valor dentro de esa fila, y la segunda "
+     "con dicho valor mï¿œximo. Los valores omitidos no se tienen en "
      "cuenta."),
      BOperClassify::Statistic_);
@@ -7271 +7271 @@
   {
     Error(I2("<fun> argument of function ForMat has no operator",
-             "El argumento <fun> de la función ForMat no tiene operador"));
+             "El argumento <fun> de la funciï¿œn ForMat no tiene operador"));
     return;
   }
@@ -7280 +7280 @@
   {
     Error(I2("<fun> argument of function ForMat ",
-             "El argumento <fun> de la función ForMat ")+"\n"+
+             "El argumento <fun> de la funciï¿œn ForMat ")+"\n"+
           opr->Grammar()->Name()+" "+code.Name()+opr->Arguments()+"\n"+
           I2("should be declared as ",
-             "debería estar declarada como ")+"\n"+
+             "deberï¿œa estar declarada como ")+"\n"+
           "Real "+code.Name()+"(Real i, Real j) \n");
     return;
@@ -7316 +7316 @@
   "Example : \n"
   ,
-  "Devuelve una matriz con las evaluaciones de una función dada de "
+  "Devuelve una matriz con las evaluaciones de una funciï¿œn dada de "
   "Real a Real en cada celda de la matriz especificada.\n"
   "Ejemplo : \n")+
@@ -7333 +7333 @@
   {
     Error(I2("<fun> argument of function EvalMat has no operator",
-             "El argumento <fun> de la función EvalMat no tiene operador"));
+             "El argumento <fun> de la funciï¿œn EvalMat no tiene operador"));
     return;
   }
@@ -7341 +7341 @@
   {
     Error(I2("<fun> argument of function EvalMat ",
-             "El argumento <fun> de la función EvalMat ")+"\n"+
+             "El argumento <fun> de la funciï¿œn EvalMat ")+"\n"+
           opr->Grammar()->Name()+" "+code.Name()+opr->Arguments()+"\n"+
           I2("should be declared as ",
-             "debería estar declarada como ")+"\n"+
+             "deberï¿œa estar declarada como ")+"\n"+
           "Real "+code.Name()+"(Real x) \n");
     return;
@@ -7375 +7375 @@
   "Example : \n"
   ,
-  "Devuelve una matriz con las evaluaciones de una función dada de "
+  "Devuelve una matriz con las evaluaciones de una funciï¿œn dada de "
   "Real^n a Real en cada fila de una matriz M(m x n) devolviendo una matriz "
   "columna.\n"
@@ -7394 +7394 @@
   {
     Error(I2("<fun> argument of function Vectorize has no operator",
-             "El argumento <fun> de la función Vectorize no tiene operador"));
+             "El argumento <fun> de la funciï¿œn Vectorize no tiene operador"));
     return;
   }
@@ -7405 +7405 @@
   {
     Error(I2("<fun> argument of function EvalMatRows ",
-             "El argumento <fun> de la función EvalMatRows ")+"\n"+
+             "El argumento <fun> de la funciï¿œn EvalMatRows ")+"\n"+
           opr->Grammar()->Name()+" "+code.Name()+opr->Arguments()+"\n"+
           I2("should be declared as ",
-             "debería estar declarada como ")+"\n"+
+             "deberï¿œa estar declarada como ")+"\n"+
           "Real "+code.Name()+"(Real x1, ..., Real x"+n+") \n");
     return;
@@ -7443 +7443 @@
   "Reemplaza en la matriz arbitraria 'data' todas las ocurrencias "
   "de las celdas de la matriz columna 'old' por la celda "
-  "correspondiente de la matriz columna 'new', que lógicamente "
+  "correspondiente de la matriz columna 'new', que lï¿œgicamente "
   "debe tener las mismas dimensiones que 'old'.\n"
-  "¡CUIDADO!: 'old' no debe tener celdas repetidas\n"),
+  "ï¿œCUIDADO!: 'old' no debe tener celdas repetidas\n"),
   BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -7517 +7517 @@
   "Argument <sign> can be 1 for direct transform or -1 for inverse transform\n"
   "See more on:\n",
-  "API para las rutinas de la librería GSL para la transformada rápida de "
-  "Fourier sobre datos reales de cualquier tamaño.\n" 
+  "API para las rutinas de la librerï¿œa GSL para la transformada rï¿œpida de "
+  "Fourier sobre datos reales de cualquier tamaï¿œo.\n" 
   "El argumento <data> tiene dos columnas que almacenan la parte real y la "
   "imaginaria respectivamente.\n"
-  "El argumento <sign> puede ser 1 para la transformación directa ó -1 para la inversa \n"
-  "Ver más en:\n")+
+  "El argumento <sign> puede ser 1 para la transformaciￜn directa ￜ -1 para la inversa \n"
+  "Ver mï¿œs en:\n")+
   "http://www.gnu.org/software/gsl/manual/html_node/"
      "Mixed-radix FFT routines for complex data.html",
@@ -7582 +7582 @@
   "Returns complex roots of given polynomial in a real matrix with "
   "two columns",
-  "Devuelve las raíces complejas de un polinomio en una matriz real "
+  "Devuelve las raï¿œces complejas de un polinomio en una matriz real "
   "de dos columnas"),
   BOperClassify::MatrixAlgebra_);

tol/btol/serie_type/tsrgrai.cpp

@@ -222 +222 @@
   I2("Returns - 1, 0, or 1 according to S will be smaller, equal or greater "
      "than zero.",
-     "Devuelve -1, 0, o 1 según S sea menor, igual o mayor que "
+     "Devuelve -1, 0, o 1 segï¿œn S sea menor, igual o mayor que "
      "cero"),
           BOperClassify::TimeSeriesAlgebra_);
@@ -252 +252 @@
   I2("Returns the series of the nearest entire numbers to each datum of "
      "a given series.",
-     "Devuelve la serie de los números enteros mas cercanos a cada dato de "
+     "Devuelve la serie de los nï¿œmeros enteros mas cercanos a cada dato de "
      "una serie dada."),
           BOperClassify::TimeSeriesAlgebra_);
@@ -281 +281 @@
   "(Serie S)",
   I2("Returns the square root of S.",
-     "Devuelve la raíz cuadrada de S."),
+     "Devuelve la raï¿œz cuadrada de S."),
   BOperClassify::TimeSeriesAlgebra_);
   DefIntOpr(2, BTsrSqrt, "SqRt", 1, 1,
   "(Serie S)",
   I2("Returns the square root of S.",
-     "Devuelve la raíz cuadrada de S."),
+     "Devuelve la raï¿œz cuadrada de S."),
             BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -342 +342 @@
   "(Serie S)",
   I2("Returns the trigonometric sine of S.",
-     "Devuelve el seno trigonométrico de S."),
+     "Devuelve el seno trigonomï¿œtrico de S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -356 +356 @@
   "(Serie S)",
   I2("Returns the trigonometric cosine of S.",
-     "Devuelve el coseno trigonométrico de S."),
+     "Devuelve el coseno trigonomï¿œtrico de S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -370 +370 @@
   "(Serie S)",
   I2("Returns the trigonometric tangent of S.",
-     "Devuelve la tangente trigonométrica de S."),
+     "Devuelve la tangente trigonomï¿œtrica de S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -384 +384 @@
   "(Serie S)",
   I2("Returns the series wich trigonometric sine is S.",
-     "Devuelve la serie cuyo seno trigonométrico es S."),
+     "Devuelve la serie cuyo seno trigonomï¿œtrico es S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -398 +398 @@
   "(Serie S)",
   I2("Returns the series wich trigonometric cosine is S.",
-     "Devuelve la serie cuyo coseno trigonométrico es S."),
+     "Devuelve la serie cuyo coseno trigonomï¿œtrico es S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -412 +412 @@
   "(Serie S)",
   I2("Returns the series wich trigonometric tangent is S.",
-     "Devuelve la serie cuya tangente trigonométrica es S."),
+     "Devuelve la serie cuya tangente trigonomï¿œtrica es S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -426 +426 @@
   "(Serie S)",
   I2("Returns the series wich hyperbolic sine is S.",
-     "Devuelve la serie cuyo seno hiperbólico es S."),
+     "Devuelve la serie cuyo seno hiperbï¿œlico es S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -441 +441 @@
   "(Serie S)",
   I2("Returns the sereis wich hyperbolic cosine is S.",
-     "Devuelve la serie cuyo coseno hiperbólico es S."),
+     "Devuelve la serie cuyo coseno hiperbï¿œlico es S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -456 +456 @@
   "(Serie S)",
   I2("Returns the series wich hyperbolic tangent is S.",
-     "Devuelve la serie cuya tangente hiperbólica es S."),
+     "Devuelve la serie cuya tangente hiperbï¿œlica es S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -471 +471 @@
   "(Serie S)",
   I2("Returns the hyperbolic sine of the S.",
-     "Devuelve el seno hiperbólico de S."),
+     "Devuelve el seno hiperbï¿œlico de S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -485 +485 @@
   "(Serie S)",
   I2("Returns the hyperbolic cosine of S.",
-     "Devuelve el coseno hiperbólico de ."),
+     "Devuelve el coseno hiperbï¿œlico de ."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -499 +499 @@
   "(Serie S)",
   I2("Returns the hyperbolic tangent of S.",
-     "Devuelve la tangente hiperbólica de S."),
+     "Devuelve la tangente hiperbï¿œlica de S."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -571 +571 @@
      "Devuelve la potencia de S1 elevada a S2.")+
   I2("Also it can be used the operator ** or the function Pow.",
-     "También se puede utilizar el operador ** o la función Pow."),
+     "Tambiï¿œn se puede utilizar el operador ** o la funciï¿œn Pow."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -664 +664 @@
 DefExtOpr(1, BTsrSet##STAT, NAME, 1, 1, "Set",                               \
 "(Set series)",                                                              \
-I2("Returns "ENGLISH" of a set of series.",                                  \
-   "Devuelve "SPANISH" de un conjunto de series."),                          \
+I2("Returns "+ENGLISH+" of a set of series.",                                \
+   "Devuelve "+SPANISH+" de un conjunto de series."),                        \
 BOperClassify::TimeSeriesAlgebra_);                                          \
                                                                              \
@@ -677 +677 @@
 DecSerStat("SetProd",Product,"the product","el producto");
 DecSerStat("SetAvr",Average,"the average","la media");
-DecSerStat("SetHarmonicAvr",HarmonicAverage,"the harmonic average","la media armónica");
-DecSerStat("SetGeometricAvr",GeometricAverage,"the geometric average","la media geométrica");
+DecSerStat("SetHarmonicAvr",HarmonicAverage,"the harmonic average","la media armï¿œnica");
+DecSerStat("SetGeometricAvr",GeometricAverage,"the geometric average","la media geomï¿œtrica");
 DecSerStat("SetVar",Varianze,"the varianze","la varianza");
-DecSerStat("SetStDs",StandardDeviation,"the standard deviation","la desviación estándar");
-DecSerStat("SetAsymmetry",AsymmetryCoefficient,"the asymmetry coefficient","el coeficiente de asimetría");
+DecSerStat("SetStDs",StandardDeviation,"the standard deviation","la desviaciï¿œn estï¿œndar");
+DecSerStat("SetAsymmetry",AsymmetryCoefficient,"the asymmetry coefficient","el coeficiente de asimetrï¿œa");
 DecSerStat("SetKurtosis",Kurtosis,"the kurtosis","la kurtosis");
-DecSerStat("SetMax",Maximum,"the maximum","el máximo");
-DecSerStat("SetMin",Minimum,"the minimum","el mínimo");
+DecSerStat("SetMax",Maximum,"the maximum","el mï¿œximo");
+DecSerStat("SetMin",Minimum,"the minimum","el mï¿œnimo");
 DecSerStat("SetMedian",Median,"the median","la mediana");
 
@@ -691 +691 @@
 DefIntOpr(1, BTsrIf, "IfSer", 3, 3,
   I2("(Serie condition, Serie S1, Serie S2)",
-     "(Serie condición, Serie S1, Serie S2)"),
+     "(Serie condiciï¿œn, Serie S1, Serie S2)"),
   I2("For each date returns the value of S1 if condition is true. Else "
      "returns the value of S2.",
-     "Para cada fecha devuelve el valor de S1 si la condición se cumple."
+     "Para cada fecha devuelve el valor de S1 si la condiciï¿œn se cumple."
      "En otro caso devuelve el valor de S2."),
           BOperClassify::TimeSeriesLogic_);
@@ -838 +838 @@
   "(Serie S1 [, Serie S2, ...])",
   I2("Returns the series of the minima from among two or more series.",
-     "Devuelve la serie de los mínimos de entre dos o más series."),
+     "Devuelve la serie de los mï¿œnimos de entre dos o mï¿œs series."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -862 +862 @@
   "(Serie S1 [, Serie S2, ...])",
   I2("Returns the series of the maxima from among two or more series.",
-     "Devuelve la serie de los máximos de dos o mas numeros."),
+     "Devuelve la serie de los mï¿œximos de dos o mas numeros."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -885 +885 @@
   "(Serie S)",
   I2("Normal(0,1) probability distribution of a serie.",
-     "Distribución de probabilidad Normal(0,1) de una serie."),
+     "Distribuciï¿œn de probabilidad Normal(0,1) de una serie."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------
@@ -946 +946 @@
         Error(I2("Wrong argument function in EvalSet function calling."
                            "It must have just one argument of Real type and return another Real.",
-                           "Función argumento errónea en llamada a la función EvalSet."
-                           "Ésta debe tener exactamente un argumento de tipo Real y devolver un Real."));
+                           "Funciï¿œn argumento errï¿œnea en llamada a la funciï¿œn EvalSet."
+                           "ï¿œsta debe tener exactamente un argumento de tipo Real y devolver un Real."));
       code_ = NULL;
             return;
@@ -963 +963 @@
      "applying a real to real function to each datum",
      "Devuelve una serie con el mismo fechado y fechas que la serie "
-     "dada aplicando una función de real a real para cada dato."),
+     "dada aplicando una funciï¿œn de real a real para cada dato."),
           BOperClassify::TimeSeriesAlgebra_);
 //--------------------------------------------------------------------

tol/btol/timeset_type/tol_btmsgra.h

@@ -27 +27 @@
 #include <tol/tol_bgenobj.h>
 #include <tol/tol_btmsexc.h>
+
+#define throw(...)
 
 
@@ -604 +606 @@
     enMsg = "Bad argument used to create a TimeSet variable: D(";
     enMsg += ss.str() + ").";
-    esMsg = "Argumento erróneo al crear una variable TimeSet: D(";
+    esMsg = "Argumento errï¿œneo al crear una variable TimeSet: D(";
     esMsg += ss.str() + ").";
     throw TimeSetException(enMsg, esMsg);  
@@ -652 +654 @@
     enMsg = "Bad argument used to create a TimeSet variable: M(";
     enMsg += ss.str() + ").";
-    esMsg = "Argumento erróneo al crear una variable TimeSet: M(";
+    esMsg = "Argumento errï¿œneo al crear una variable TimeSet: M(";
     esMsg += ss.str() + ").";
     throw TimeSetException(enMsg, esMsg);  
@@ -695 +697 @@
     enMsg = "Bad argument used to create a TimeSet variable: H(";
     enMsg += ss.str() + ").";
-    esMsg = "Argumento erróneo al crear una variable TimeSet: H(";
+    esMsg = "Argumento errï¿œneo al crear una variable TimeSet: H(";
     esMsg += ss.str() + ").";
     throw TimeSetException(enMsg, esMsg);  
@@ -737 +739 @@
     enMsg = "Bad argument used to create a TimeSet variable: Mi(";
     enMsg += ss.str() + ").";
-    esMsg = "Argumento erróneo al crear una variable TimeSet: Mi(";
+    esMsg = "Argumento errï¿œneo al crear una variable TimeSet: Mi(";
     esMsg += ss.str() + ").";
     throw TimeSetException(enMsg, esMsg);  
@@ -778 +780 @@
     enMsg = "Bad argument used to create a TimeSet variable: S(";
     enMsg += ss.str() + ").";
-    esMsg = "Argumento erróneo al crear una variable TimeSet: S(";
+    esMsg = "Argumento errï¿œneo al crear una variable TimeSet: S(";
     esMsg += ss.str() + ").";
     throw TimeSetException(enMsg, esMsg);  

tol/btol/vmatrix_type/vmatgra.cpp

@@ -356 +356 @@
   "(Real nrow, Set items)",
   I2("Merge rows of a set of virtual matrices and row indexes.",
-     "Mezcla las filas de un conjunto de matrices virtuales e índices "
+     "Mezcla las filas de un conjunto de matrices virtuales e ï¿œndices "
      "de filas ."),
      BOperClassify::Conversion_);
@@ -520 +520 @@
      "minimum size of returned matrix."
 ,
-     "Convierte una matriz virtual para ser almacenados en la forma óptima:\n"
+     "Convierte una matriz virtual para ser almacenados en la forma ï¿œptima:\n"
      " * Convierte una matriz densa a escasa si tiene bastantes celdas cero, es decir, si\n"
      "1-VNonNullCells (M) / (VRows (M) * VColumns (M))> = sparsity\n"
      "* Convierte una matriz dispersa a densa si no hay bastantes celdas cero, es decir, si\n"
      "1-VNonNullCells (M) / (VRows (M) * VColumns (M)) <= sparsity\n"
-     "Si no es así, las matrices sparse serán empaquetadas al máximo internamente.\n"
-     "* Convierte las matrices triplet a denso o sparse según estas mismas reglas\n"
-     "* Las matrices factor serán empaquetadas al máximo internamente\n"
-     "Si el argumento 'sparsity' es desconocido entonces será calculado "
-     "para garantizar el mínimo tamaño posible de la matriz devuelta."),
+     "Si no es asￜ, las matrices sparse serￜn empaquetadas al mￜximo internamente.\n"
+     "* Convierte las matrices triplet a denso o sparse segï¿œn estas mismas reglas\n"
+     "* Las matrices factor serï¿œn empaquetadas al mï¿œximo internamente\n"
+     "Si el argumento 'sparsity' es desconocido entonces serￜ calculado "
+     "para garantizar el mï¿œnimo tamaï¿œo posible de la matriz devuelta."),
 BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -567 +567 @@
      "Construye una VMatrix Cholmod.R.Triplet T con la sdimensiones dadas a "
      "partir de una lista de tripletas ijx que pueden expresarse bien "
-     "como un conjunto de conjuntos de tres números cada uno, bien como "
+     "como un conjunto de conjuntos de tres nï¿œmeros cada uno, bien como "
      "una matriz con tres columnas. Cada tripleta (i,j,x) define una celda "
      "almacenada T(i,j)=x. Las celdas no listadas se asumen como cero.\n"
-     "Si los índices de fila i ó columna j no son enteros serán truncados.\n"
-     "Es posible reubicar los índices de las filas y columnas de las celdas "
-     "especificándolo con los argumentos rowIdx y colIdx, que deben ser "
-     "matrices fila o columna de números enteros.\n"
-     "CUIDADO: ¡Las celdas repetidas serán sumadas! Para evitarlo use "
+     "Si los ￜndices de fila i ￜ columna j no son enteros serￜn truncados.\n"
+     "Es posible reubicar los ï¿œndices de las filas y columnas de las celdas "
+     "especificï¿œndolo con los argumentos rowIdx y colIdx, que deben ser "
+     "matrices fila o columna de nï¿œmeros enteros.\n"
+     "CUIDADO: ï¿œLas celdas repetidas serï¿œn sumadas! Para evitarlo use "
      "TripletUnique"),
 BOperClassify::MatrixAlgebra_);
@@ -613 +613 @@
       Error(I2(BText("Just row or column matrices of maximum length nrow=")+nrow+
                " are allowed as rowIdx argument of function Triplet",
-               BText("Sólo se permiten matrices fila o columna de tamaño máximo ncol=")+nrow+
-               " como argumento rowIdx de la función Triplet"));
+               BText("Sï¿œlo se permiten matrices fila o columna de tamaï¿œo mï¿œximo ncol=")+nrow+
+               " como argumento rowIdx de la funciï¿œn Triplet"));
       return;
     }
@@ -627 +627 @@
                  BText("No se permiten valores desconocidos, infinitos ni fuera del "
                  "rango [1,...,nrow=")+nrow+"], como "+ ri+", en el argumento "
-                 "rowIdx de la función Triplet"));
+                 "rowIdx de la funciï¿œn Triplet"));
         return;
       }
@@ -647 +647 @@
         Error(I2(BText("Just row or column matrices of maximum length ncol=")+ncol+
                  " are allowed as rowIdx argument of function Triplet",
-                 BText("Sólo se permiten matrices fila o columna de tamaño máximo ncol=")+ncol+
-                 " como argumento rowIdx de la función Triplet"));
+                 BText("Sï¿œlo se permiten matrices fila o columna de tamaï¿œo mï¿œximo ncol=")+ncol+
+                 " como argumento rowIdx de la funciï¿œn Triplet"));
         return;
       }
@@ -661 +661 @@
                    BText("No se permiten valores desconocidos, infinitos ni fuera del "
                    "rango [1,...,ncol=")+ncol+"], como "+ cj+", en el argumento "
-                   "colIdx de la función Triplet"));
+                   "colIdx de la funciï¿œn Triplet"));
           return;
         }
@@ -688 +688 @@
      "Construye una VMatrix Cholmod.R.Triplet T con la sdimensiones dadas a "
      "partir de una lista de tripletas ijx que pueden expresarse bien "
-     "como un conjunto de conjuntos de tres números cada uno, bien como "
+     "como un conjunto de conjuntos de tres nï¿œmeros cada uno, bien como "
      "una matriz con tres columnas. Cada tripleta (i,j,x) define una celda "
      "almacenada T(i,j)=x. Las celdas no listadas se asumen como cero.\n"
-     "Si los índices de fila i ó columna j no son enteros serán truncados.\n"
-     "Es posible reubicar los índices de las filas y columnas de las celdas "
-     "especificándolo con los argumentos rowIdx y colIdx, que deben ser "
-     "matrices fila o columna de números enteros."),
+     "Si los ￜndices de fila i ￜ columna j no son enteros serￜn truncados.\n"
+     "Es posible reubicar los ï¿œndices de las filas y columnas de las celdas "
+     "especificï¿œndolo con los argumentos rowIdx y colIdx, que deben ser "
+     "matrices fila o columna de nï¿œmeros enteros."),
 BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -732 +732 @@
   I2("Returns the matrix representation of a backshift polynomial.",
      "Devuelve la representacion matricial de un polinomio de retardos."
-     "Si el polinomio no contiene términos en F, entonces "
+     "Si el polinomio no contiene tï¿œrminos en F, entonces "
      "se trata de una matriz triangular inferior que tiene todos los "
      "valores de la diagonal principal iguales al coeficiente de grado 0 "
      "del polinomio, y los de las diagonales inferiores iguales al "
      "coeficiente del grado correspondiente. "
-     "Si tiene térmnos en F, ocurre de forma análoga con las diagonales "
+     "Si tiene tï¿œrmnos en F, ocurre de forma anï¿œloga con las diagonales "
      "superiores"),
     BOperClassify::Conversion_);
@@ -807 +807 @@
      "Devuelve una matriz Cholmod.R.Sparse cuyas celdas son todas cero "
      "excepto los elementos de la diagonal especificada cuyos valores "
-     "vendrán dados por el argumento x. Si es un Real todos ellos serán igual "
-     "a éste y si es una VMatrix fila o columna se utilizarán sus valores "
+     "vendrï¿œn dados por el argumento x. Si es un Real todos ellos serï¿œn igual "
+     "a ï¿œste y si es una VMatrix fila o columna se utilizarï¿œn sus valores "
      "ordenados. La diagonal principal se referencia como diag=0, las "
      "sub-diagonales principales como diag<0 y las superiores como diag>0."),
@@ -1205 +1205 @@
      "positive. Returned matrix has same dimensions than incoming one.",
      "Extrae las diagonales consecutivas seleccionadas. La diagonal "
-     "principal se referencia como 0, las inferiores como números "
+     "principal se referencia como 0, las inferiores como nï¿œmeros "
      "negativos y las superiores como positivos. La matriz devuelta "
      "tiene las mismas dimensiones que la entrante."),
@@ -1232 +1232 @@
      "positive.",
      "Extrae la diagonales seleccionada como una matriz fila. La diagonal "
-     "principal se referencia como 0, las inferiores como números "
+     "principal se referencia como 0, las inferiores como nï¿œmeros "
      "negativos y las superiores como positivos."),
     BOperClassify::MatrixAlgebra_);
@@ -1334 +1334 @@
 DefIntOpr(1, BVMat##FUN, #FUN, 1, 1,                                           \
 "(VMatrix mat)",                                                               \
-I2("Returns "ENGLISH" of each element of a virtual matrix.",                   \
-   "Devuelve "SPANISH" de cada elemento de una matriz virtual."),              \
+I2("Returns "+ENGLISH+" of each element of a virtual matrix.",                   \
+   "Devuelve "+SPANISH+" de cada elemento de una matriz virtual."),              \
 BOperClassify::MatrixAlgebra_);                                                \
 void BVMat##FUN::CalcContens()                                                 \
@@ -1347 +1347 @@
 DefIntOpr(1, BVMat##FUN, #FUN, 1, 1,                                           \
 "(VMatrix mat)",                                                               \
-I2("Returns "ENGLISH" of each element of a virtual matrix.",                   \
-   "Devuelve "SPANISH" de cada elemento de una matriz virtual.")+              \
+I2("Returns "+ENGLISH+" of each element of a virtual matrix.",                   \
+   "Devuelve "+SPANISH+" de cada elemento de una matriz virtual.")+              \
 warn_auto_dense(),                                                             \
 BOperClassify::MatrixAlgebra_);                                                \
@@ -1699 +1699 @@
   I2("Returns a boolean matrix with cells equal to 1 just for each non zero "
      "cell.",
-     "Devuelve una matriz booleana con celdas igual a 1 sólo para las celdas "
+     "Devuelve una matriz booleana con celdas igual a 1 sï¿œlo para las celdas "
      "distintas de cero."),
   BOperClassify::MatrixAlgebra_);
@@ -1715 +1715 @@
   "(VMatrix mat)",
   I2("Returns a boolean matrix with cells equal to 1 just for each zero cell.",
-     "Devuelve una matriz booleana con celdas igual a 1 sólo para las celdas "
+     "Devuelve una matriz booleana con celdas igual a 1 sï¿œlo para las celdas "
      "iguales a cero.")+warn_auto_dense(),
   BOperClassify::MatrixAlgebra_);
@@ -1731 +1731 @@
   "(VMatrix mat)",
   I2("Returns a boolean matrix with cells equal to 1 just for each unknown cell.",
-     "Devuelve una matriz booleana con celdas igual a 1 sólo para las celdas "
+     "Devuelve una matriz booleana con celdas igual a 1 sï¿œlo para las celdas "
      "con valores desconocidos.")+warn_auto_dense(),
   BOperClassify::MatrixAlgebra_);
@@ -1748 +1748 @@
   "(VMatrix mat)",
   I2("Returns a boolean matrix with cells equal to 1 just for each finite known cell.",
-     "Devuelve una matriz booleana con celdas igual a 1 sólo para las celdas "
+     "Devuelve una matriz booleana con celdas igual a 1 sï¿œlo para las celdas "
      "con valores finitos conocidos.")+warn_auto_dense(),
   BOperClassify::MatrixAlgebra_);
@@ -1785 +1785 @@
   "(VMatrix A [, {VMatrix|Real} B, ...])",
   I2("Returns the logical AND of arguments.",
-     "Devuelve el AND (Y) lógico de los argumentos"),                              
+     "Devuelve el AND (Y) lï¿œgico de los argumentos"),                              
   BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -1815 +1815 @@
   "(VMatrix A [, {VMatrix|Real} B, ...])",
   I2("Returns the logical OR of arguments.",
-     "Devuelve el OR (O) lógico de los argumentos"),                              
+     "Devuelve el OR (O) lï¿œgico de los argumentos"),                              
   BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -1845 +1845 @@
   "(VMatrix A [, {VMatrix|Real} B, ...])",
   I2("Returns in each cell the minimum value of arguments ",
-     "Devuelve en cada celda el mínimo de los argumentos ")+
+     "Devuelve en cada celda el mï¿œnimo de los argumentos ")+
      "Min(A[i,j],B[i,j])",                              
   BOperClassify::MatrixAlgebra_);
@@ -1875 +1875 @@
   "(VMatrix A [, {VMatrix|Real} B, ...])",
   I2("Returns in each cell the maximum value of arguments ",
-     "Devuelve en cada celda el máximo de los argumentos ")+
+     "Devuelve en cada celda el mï¿œximo de los argumentos ")+
      "Max(A[i,j],B[i,j])",                              
   BOperClassify::MatrixAlgebra_);
@@ -1906 +1906 @@
   "(VMatrix A, {VMatrix|Real} B [, {VMatrix|Real} C, ...])",
   I2("Returns TRUE just in each cell where ",
-     "Devuelve CIERTO sólo para las celdas para las que ")+
+     "Devuelve CIERTO sï¿œlo para las celdas para las que ")+
      "A[i,j]==B[i,j]",   
   BOperClassify::MatrixAlgebra_);
@@ -1939 +1939 @@
   "(VMatrix A, {VMatrix|Real} B [, {VMatrix|Real} C, ...])",
   I2("Returns TRUE just in each cell where ",
-     "Devuelve CIERTO sólo para las celdas para las que ")+
+     "Devuelve CIERTO sï¿œlo para las celdas para las que ")+
      "A[i,j]!=B[i,j]"+warn_auto_dense(),
   BOperClassify::MatrixAlgebra_);
@@ -1972 +1972 @@
   "(VMatrix A, {VMatrix|Real} B [, {VMatrix|Real} C, ...])",
   I2("Returns TRUE just in each cell where ",
-     "Devuelve CIERTO sólo para las celdas para las que ")+
+     "Devuelve CIERTO sï¿œlo para las celdas para las que ")+
      "A[i,j]<=B[i,j]",   
   BOperClassify::MatrixAlgebra_);
@@ -2005 +2005 @@
   "(VMatrix A, {VMatrix|Real} B [, {VMatrix|Real} C, ...])",
   I2("Returns TRUE just in each cell where ",
-     "Devuelve CIERTO sólo para las celdas para las que ")+
+     "Devuelve CIERTO sï¿œlo para las celdas para las que ")+
      "A[i,j]<B[i,j]"+warn_auto_dense(),
   BOperClassify::MatrixAlgebra_);
@@ -2039 +2039 @@
   "(VMatrix A, {VMatrix|Real} B [, {VMatrix|Real} C, ...])",
   I2("Returns TRUE just in each cell where ",
-     "Devuelve CIERTO sólo para las celdas para las que ")+
+     "Devuelve CIERTO sï¿œlo para las celdas para las que ")+
      "A[i,j]>=B[i,j]",   
   BOperClassify::MatrixAlgebra_);
@@ -2073 +2073 @@
   "(VMatrix A, {VMatrix|Real} B [, {VMatrix|Real} C, ...])",
   I2("Returns TRUE just in each cell where ",
-     "Devuelve CIERTO sólo para las celdas para las que ")+
+     "Devuelve CIERTO sï¿œlo para las celdas para las que ")+
      "A[i,j]>B[i,j]"+warn_auto_dense(),
   BOperClassify::MatrixAlgebra_);
@@ -2153 +2153 @@
      "  S = L*L'\n"
      "Si es Cholmod.R.Sparse una Cholmod.R.Factor que contiene internamente "
-     "una matriz triangular inferior L y una permutación P tales que \n"
+     "una matriz triangular inferior L y una permutaciï¿œn P tales que \n"
      "  S = P'*L*L'*P\n"
-     "En este caso sólo se puede operar con L y P a través de la función "
+     "En este caso sï¿œlo se puede operar con L y P a travï¿œs de la funciï¿œn "
      "CholeskiSolve.\n"
      "En otro caso no se realiza ninguna operacion y se devuelve la matriz "
@@ -2259 +2259 @@
   I2("Applies the Cholesky decomposition to solve X in the linear "
      "regresion M*X=B+e ",
-     "Aplica la descomposición de Cholesky para resolver X en la "
-     "regresión lineal M*X=B+e."),
+     "Aplica la descomposiciï¿œn de Cholesky para resolver X en la "
+     "regresiï¿œn lineal M*X=B+e."),
     BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -2290 +2290 @@
      "sistema lineal M*X=B comenzando por el valor inicial <X0> y "
      "continuando hasta  que el error sea menor que <chop> o se "
-     "supere el número de iteraciones indicadas."),
+     "supere el nï¿œmero de iteraciones indicadas."),
     BOperClassify::MatrixAlgebra_);
 //--------------------------------------------------------------------
@@ -2412 +2412 @@
   "(VMatrix mat)",
   I2("Returns the number of cells of a matrix (rows x columns).",
-     "Devuelve el número de celdas de una matriz (filas x columnas)."),
+     "Devuelve el nï¿œmero de celdas de una matriz (filas x columnas)."),
      BOperClassify::Statistic_);
   void BDatVMatCount::CalcContens()
@@ -2426 +2426 @@
   "(VMatrix mat)",
   I2("Returns the number of cells of a matrix (rows x columns).",
-     "Devuelve el número de celdas de una matriz (filas x columnas)."),
+     "Devuelve el nï¿œmero de celdas de una matriz (filas x columnas)."),
      BOperClassify::Statistic_);
   void BDatVMatKnown::CalcContens()
@@ -2471 +2471 @@
   "(VMatrix mat)",
   I2("Returns the arithmetic average of all elements of a matrix.",
-     "Devuelve la media aritmética de todos los elementos de una matriz."),
+     "Devuelve la media aritmï¿œtica de todos los elementos de una matriz."),
      BOperClassify::Statistic_);
   void BDatVMatAvr::CalcContens()
@@ -2484 +2484 @@
   "(VMatrix mat)",
   I2("Returns the geometric average of all elements of a matrix.",
-     "Devuelve la media geométrica de todos los elementos de una matriz."),
+     "Devuelve la media geomï¿œtrica de todos los elementos de una matriz."),
      BOperClassify::Statistic_);
   void BDatVMatGeometricAvr::CalcContens()
@@ -2500 +2500 @@
   "(VMatrix mat)",
   I2("Returns the harmonic average of all elements of a matrix.",
-     "Devuelve la media armónica de todos los elementos de una matriz."),
+     "Devuelve la media armï¿œnica de todos los elementos de una matriz."),
      BOperClassify::Statistic_);
   void BDatVMatHarmonicAvr::CalcContens()
@@ -2695 +2695 @@
      "independent standard normal truncated into a polytope",
      "Devuelve una matriz virtual X cuyas columnas se distribuiran como "
-     "normales estándar independientes truncadas en un politopo")+
+     "normales estï¿œndar independientes truncadas en un politopo")+
      "\n X ~ TN(0, I, D*X<=d);\n\n"+
   I2("The number of rows of X is obviously the number of columns of D that "
      "must have at least one columns and one row, having also the same number "
      "of rows than d.",
-     "El número de filas de X será el de columnas de D, la cual ha de tener "
+     "El nￜmero de filas de X serￜ el de columnas de D, la cual ha de tener "
      "al menos una colmna y una fila, coincidiendo con las filas de d.")+"\n"+
   I2("The internal algorithm is a Gibbs sampler begining at a feasible point "
@@ -2734 +2734 @@
   I2("Calculates minimum and maximum values of j-th component of "
      "vector z inside the polytope D*z <= d",
-     "Calcula los valores mínimo y máximo de la j-ésima componente "
+     "Calcula los valores mï¿œnimo y mï¿œximo de la j-ï¿œsima componente "
      "del vector z dentro del politopo D*z <= d"),
 BOperClassify::MatrixAlgebra_);
@@ -2773 +2773 @@
      ,
      "En matematicas, el producto de Kronecker, denotado por una x dentro "
-     "de un circulo, es una operacion de dos matrices de tamaño arbitrario "
+     "de un circulo, es una operacion de dos matrices de tamaï¿œo arbitrario "
      "dando por resultado la matriz del bloque (aij*B).  "
      "Es un caso especial de un producto del tensor. El producto de "
@@ -2808 +2808 @@
      "Analiza un archivo ASCII escrito en lenguaje BSR (Bayesian "
      "Sparse Regression) y devuelve un Set con la estructura de "
-     "@BSR.ModelDef que contiene toda la información necesaria para "
-     "hacer estimación bayesian de un modelo de regresión lineal sujeto "
-     "a inecuaciones lineales utilizando métodos MCMC (MonteCarlo Markov "
+     "@BSR.ModelDef que contiene toda la informaciï¿œn necesaria para "
+     "hacer estimaciï¿œn bayesian de un modelo de regresiï¿œn lineal sujeto "
+     "a inecuaciones lineales utilizando mï¿œtodos MCMC (MonteCarlo Markov "
      "Chain):\n"
      "  Y = X*B + E \n"
      "  A*B <= a\n"
-     "El campo LinearBlock contiene información sobre las variables del "
+     "El campo LinearBlock contiene informaciï¿œn sobre las variables del "
      "vector b y debe tener la estructura de BSR.LinearBlock, que "
      "incluye valores iniciales B0 que cumplen las inecuaciones A * B0 "
      "<= a.\n"
-     "El campo NoiseDistrib contiene información sobre el "
+     "El campo NoiseDistrib contiene informaciï¿œn sobre el "
      "ruido del vector E y debe tener la estructura de BSR."
      "NoiseDistrib.\n"
@@ -2849 +2849 @@
      "columna de una matriz M:rxc y devuelve una matriz con c+1 columnas y p filas. "
      "La primera columna contiene el limite superior de cada intervalo. "
-     "Las siguientes columnas j=2..c+1 contienen la proporción de valores de "
-     "la columna (j-1)-ésima de M que pertenecen al intervalo correspondiente "
+     "Las siguientes columnas j=2..c+1 contienen la proporciï¿œn de valores de "
+     "la columna (j-1)-ï¿œsima de M que pertenecen al intervalo correspondiente "
      "a la fila.")+"\n"+
   I2("Defining the size of internal intervals as ",
-     "Definiendo el tamaño de los intervalos interiores como ")+"\n"+
+     "Definiendo el tamaï¿œo de los intervalos interiores como ")+"\n"+
      "  h = (max-min)/p\n"+
   I2("we will have the next p intervals",