//  CAFE2011.EXE is licensed under the terms of the CC-LGPL.
//  (CC-LGPL Version 3, 29 junio 2007 y CAFE2011 version 2011)
//  El objetivo es el libre uso comercial y no comercial del software.
//  Una copia de dicho documento se incluye en esta distribucion.
//  CWSDPMI.EXE, STREAMCO.PAS, el procedimiento TextOut
//  se tomaron de la distribucion FreePascal 2.4.2. con patente similar.
//        StreamCo.PAS es una contraccion conveniente a ocho letras del
//        nombre StreamColl.PAS en la distribucion FreePascal
  {$MODE                OBJFPC          }
  {$INCLUDEPATH         ..\INCLUDE      }
  {$INCLUDE             CAFE_INC.INC    }
  {$DEFINE              SILENCIAR       }
  {$INTERFACES          CORBA           }
UNIT CAFE_Ej4;

INTERFACE

USES SysUtils, DateUtils         , Classes , StreamCo           ,
     Math    , Variants, CAFE_Ej1, CAFE_Ej2, CAFE_Ej3, CAFE_Tu1 ,
     Types   ;

VAR
  CAFE_InicialBanderaSimularCalculo     : Boolean               = FALSE;
{
  CAFE_InicialBanderaSimularCalculo     :
        Valor inicial de ValorBanderaSimularCalculo
        TRUE Coloca la hoja de calculo en estado
        de simulacion, en donde los calculos no se propagan al
        resto de la hoja.  Muchos algoritmos, especialmente
        los mas complejos, daran resultados equivocados.
        Varios algoritmos internos, utilizan esta bandera
        en forma temporal.  El usuario tambien puede ubicar
        este estado en forma semipermanente.
  CUIDADO : CAFE escribe en SAVE unicamente TRUE, el FALSE no lo escribe
}

CONST
  CAFE_LetrasHoja               = [ 'A'..'Z' ];
{
  CAFE_LetrasHoja               : Contiene las letras para nombres
        de casillas de Hoja.
        CUIDADO: La modificacion probablemen resulte en inconsistencias.
        En tal caso, probablemente deberia desactivar
        los algoritmos assembler.
}

  CAFE_NumerosHoja              = [ '0'..'9' ];
{
  CAFE_NumerosHoja              : Contiene los numeros para nombres
        de casillas de Hoja.
        CUIDADO: La modificacion es casi seguro que resulte en
        inconsistencias.  i.e. El copiado de casillas.
}

  CAFE_StringFijarEnFila        = '$FILA';
{
  CAFE_StringFijarEnFila        : Variable de usuario, para el
        copiado de casillas.  Su valor es cero.
        $FILA --> ($FILA+DesplazadoColumna)
        DesplazadoColumna       : valor del desplazamiento en
        columnas.  Si es 0 no hay sustitucion.  Tambien
        podria ser un - en vez de +.
}

  CAFE_StringFijarEnColumna     = '$COLUMNA';
{
  CAFE_StringFijarEnColumna     : Variable de usuario, para el
        copiado de casillas.  Su valor es cero.
        $COLUMNA --> ($COLUMNA+DesplazadoFila)
        DesplazadoFila          : valor del desplazamiento en
        filas.  Si es 0 no hay sustitucion.  Tambien
        podria ser un - en vez de +.
}
  CAFE_CadenaIdentificadorSelf  = 'SELF';
{
  CAFE_CadenaIdentificadorSelf  : EJES utiliza esta cadena
        para referencia como registro al mismo manejador
}

VAR
  CAFE_4ErrorHojaTrabajoInactiva        : LongInt               = 1;
{
  CAFE_4ErrorHojaTrabajoInactiva        :
        Variable previa al CAFE_ErrorHojaTrabajoInactiva
        a definirse en el futuro, ver CAFE_Ej5;
        para evitar confusion en la numeracion
}

  CAFE_4ErrorOrdenRequiereHojaTrabajo   : LongInt               = 1;
{
  CAFE_4ErrorOrdenRequiereHojaTrabajo   :
        Variable previa al CAFE_ErrorOrdenRequiereHojaTrabajo
        a definirse en el futuro, ver CAFE_Ej5;
        para evitar confusion en la numeracion
}

  CAFE_4ErrorMecanismoUndoDesactivadoHojaTrabajo
                                        : LongInt               = 1;
{
  CAFE_4ErrorMecanismoUndoDesactivadoHojaTrabajo        :
        Variable previa al CAFE_ErrorMecanismoUndoDesactivadoHojaTrabajo
        a definirse en el futuro, ver CAFE_Ej5;
        para evitar confusion en la numeracion
}

  CAFE_4ErrorPosibleIncompatibilidadVersion
                                        : LongInt               = 1;
{
  CAFE_4ErrorPosibleIncompatibilidadVersion             :
        Variable previa al CAFE_ErrorPosibleIncompatibilidadVersion
        a definirse en el futuro, ver CAFE_Ej5;
        para evitar confusion en la numeracion
}

  CAFE_4ErrorDatoFueraRangoAdmisible    : LongInt               = 1;
{
  CAFE_4ErrorDatoFueraRangoAdmisible                    :
        Variable previa al CAFE_ErrorDatoFueraRangoAdmisible
        a definirse en el futuro, ver CAFE_Ej5;
        para evitar confusion en la numeracion
}

  CAFE_4ErrorDeterminanteNulo           : LongInt               = 1;
{
  CAFE_4ErrorDeterminanteNulo                           :
        Variable previa al CAFE_ErrorDeterminanteNulo
        a definirse en el futuro, ver CAFE_Ej5;
        para evitar confusion en la numeracion
}

  CAFE_4ErrorGramaticaOperadoresCadenaError
                                        : LongInt               = 1;
{
  CAFE_4ErrorGramaticaOperadoresCadenaError             :
        Proceso GramaticaOperadores genero un error sin RAISE,
        esta variable identifica el hecho.
        El error contiene identifica el operador, que lo produjo.
        Se asigna a CAFE_PosicionInfructuosoSintactico
}

  CAFE_4ErrorGramaticaOperadoresGeneral : LongInt               = 1;
{
  CAFE_4ErrorGramaticaOperadoresGeneral
        Proceso GramaticaOperadores genero un error sin RAISE,
        esta variable identifica el hecho.
        No indica naturaleza del error.
        Se asigna a CAFE_PosicionInfructuosoSintactico
}

  CAFE_4ErrorNudilladoGeneral           : LongInt               = 1;
{
  CAFE_4ErrorNudilladoGeneral           :
        Proceso de Nudillar fallido.  No se indica la naturaleza del hecho.
        Se asigna a CAFE_PosicionInfructuosoSintactico.
}

  CAFE_4ErrorAlEvaluarEnLugar           : LongInt               = 1;
{
  CAFE_4ErrorAlEvaluarEnLugar           :
        Genera un mensaje similar a 'Error al evaluar %s'
        Se supone que se puede localizar con algo de mayor precision,
        probablemente una funcion
}

  CAFE_4ErrorVarErrorEvaluar            : LongInt               = 1;
{
  CAFE_4ErrorVarErrorEvaluar            :
        Errores generales al evaluar sin mayores detalles
}

  CAFE_4ErrorVarErrorInterpretar        : LongInt               = 1;
{
  CAFE_4ErrorVarErrorInterpretar        :
        Errores generales al evaluar sin mayores detalles
}

  CAFE_4ErrorExcesoParentesisCerrados   : LongInt               = 1;
{
  CAFE_4ErrorExcesoParentesisCerrados   :
        Se introdujo un exceso de parentesis cerrados en la expresion
}

  CAFE_4ErrorLlamadaCiclica             : LongInt               = 1;
{
  CAFE_4ErrorLlamadaCiclica             :
        Se produjo un ciclo, estando prohibido
}

  CAFE_4ErrorMacroSinParametros         : LongInt               = 1;
{
  CAFE_4ErrorMacroSinParametros         :
        En la primera version de CAFE las macros deben tener al menos,
        un parametro.
}

  CAFE_4ErrorEstiloRecursivoIndefinido  : LongInt               = 1;
{
  CAFE_4ErrorEstiloRecursivoIndefinido  :
        Existe un error en la definicion del ciclo, probablemente
        no se definio accion a tomar.
}

  CAFE_4ErrorFinCicloPendiente          : LongInt               = 1;
{
  CAFE_4ErrorFinCicloPendiente          :
        Se ha repetido el ciclo varias veces y todavia no se llega al fin
}

  CAFE_4ErrorDescriptorDimensionalInconsistente : LongInt       = 1;
{
  CAFE_4ErrorDescriptorDimensionalInconsistente :
        Error de tamano en operaciones de vectores y matrices
}

  CAFE_4ErrorMatrizAnalisisNumericoMuyGrande    : LongInt       = 1;
{
  CAFE_4ErrorMatrizAnalisisNumericoMuyGrande    :
        La matriz supero el tamano permitido por el sistema
        de analisis numerico
}

  CAFE_4ErrorIntegralNoRealizada                : LongInt       = 1;
{
  CAFE_4ErrorIntegralNoRealidada                :
        Para indicar fracasos en procesos de integrales
}

  CAFE_4ErrorDefinirSectorRectangular           : LongInt       = 1;
{
  CAFE_4ErrorDefinirSectorRectangular           :
        Para indicar un error al definir zonas matriciales
        a aplicar a funciones matriciales
}

  CAFE_4ErrorMacroRecibeArgumentosReales        : LongInt       = 1;
{
  CAFE_4ErrorMacroRecibeArgumentosReales        :
        Esta version de CAFE unicamente permite parametros
        reales en macros
}

  CAFE_4ErrorCopiaProvocaRangoNoPermitido       : LongInt       = 1;
{
  CAFE_4ErrorCopiaProvocaRangoNoPermitido       :
        Para indicar que al copiar se produjo el acceso a zonas
        no permitidas por dimensiones de hoja
}

  CAFE_4ErrorCopiaNoPermitidaGeneral            : LongInt       = 1;
{
  CAFE_4ErrorCopiaNoPermitidaGeneral            :
        Mensaje general de error en copia, sin especificar causa
}

  CAFE_4ErrorNoPudoEvaluarValoresInicialesCopiaMacro
                                                : LongInt       = 1;
{
  CAFE_4ErrorNoPudoEvalaurValoresInicialesCopiaMacro
        Indica al usuario alguna dificultad en la copia de macros.
        Probablemente alguna inconsistencia surgida por las
        reglas de copia de referencias de casilla.
}

  CAFE_4ErrorIrregularAccesoCasilla             : LongInt       = 1;
{
  CAFE_4ErrorIrregularAccesoCasilla             :
        Por alguna causa no se pudo evaluar el acceso de una casilla,
        ya interpretada.  Probablemente algun cambio en la casilla
        referida.
}

  CAFE_4ErrorIntegralSuperoTotalCiclos          : LongInt       = 1;
{
  CAFE_4ErrorIntegralSuperoTotalCiclos          :
        Para indicar que el proceso de integral supero
        un limite establecido de ciclos
        Se controla por una variable general de CAFE_InterfaceManejador
}

  CAFE_4ErrorMacroResultadoNoReal       : LongInt               = 1;
{
  CAFE_4ErrorMacroResultadoNoReal       :
        En la primera version de CAFE.EXE unicamente se
        permiten resultados reales en macro
}

  CAFE_4ErrorParametrosSubOrden         : LongInt               = 1;
{
  CAFE_4ErrorParametrosSubOrden         :
        Para indicar un error al evaluar parametros de expresiones
        algebraicas variadas
}

  CAFE_MaximoNivelUndoHojaCalculo       : LongInt               = 3;
{
  CAFE_MaximoNivelUndoHojaCalculo       :
        Variable para establecer el maximo nivel de Undo en Hoja de
        Calculo
}

  CAFE_MaximoNivelUndoAdmisible         : LongInt               = 100;
{
  CAFE_MaximoNivelUndoAdmisible         :
        Maximo nivel de Undo que el programa admitira como asignacion
        de usuario en la pipa
}

CONST
  CAFE_DateSeparator            : Char  = '/';
{
  CAFE_DateSeparator            : Valor de inicializacion para
        DateSeparator que es el formato de fecha.
        Solo aplica en INITIALIZATION de CAFE_Ej4
}

  CAFE_FormatDateDefault        : String        = 'd" "mmm" "yyyy';
{
  CAFE_FormatDateDefault        : Formato Default a utilizar EJES.EXE
}

  CAFE_TamanoFormatDate         : Byte          = 11;
{
  CAFE_TamanoFormatDate         : Se intenta justificar Date agregando
        espacios vacios a la izquierda
        a este tamano.  Si vale cero no aplica.
        Aplica cuando se requiera
}

  CAFE_ShortMonthNames          : TMonthNameArray       =
        ( 'Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun',
          'Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dic' );
{
  CAFE_ShortMonthNames          : Nombres cortos para los meses
        Se sustituye al inicializar la unidad
}

  CAFE_LongMonthNames           : TMonthNameArray       =
        ( 'Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio',
          'Julio', 'Agosto', 'Septiembre', 'Octubre',
          'Noviembre', 'Diciembre' );
{
  CAFE_LongMonthNames           : Nombres largos para los meses
        Se sustituye al inicializar la unidad
}

  CAFE_ShortDayNames            : TWeekNameArray        =
        ( 'DOM', 'LUN', 'MAR', 'MIE', 'JUE', 'VIE', 'SAB' );
{
  CAFE_ShortDayNames            : Nombres cortos para los dias
        de la semana.  Se sustituye al inicializar la unidad
}

  CAFE_LongDayNames             : TWeekNameArray        =
        ( 'DOMINGO', 'LUNES', 'MARTES', 'MIERCOLES',
                'JUEVES', 'VIERNES', 'SABADO' );
{
  CAFE_LongDayNames             : Nombres largo para los dias
        de la semana.  Se sustituye al inicializar la unidad
}

  CAFE_TotalLetras              = Ord( 'Z' )-Ord( 'A' )+1;
{
  CAFE_TotalLetras              : Da el total de letras en la
        Hoja de Calculo, no deberia modificarse
}

  CAFE_ReferenciaAbsoluta       = '$';
{
  CAFE_ReferenciaAbsoluta       : Caracter usuario para la
        referencia de casillas de posicion absoluta en el copiado
        de hojas de calculo
}

  CAFE_TamanoHojaSeguridad      = 2000000;
{
  CAFE_TamanoHojaSeguridad      : Al determinar el nombre de una casilla
        este valor se toma como el valor maximo posible, de lo
        contrario se condicion de error.
}

  CAFE_CicloConteoMaximoDefault = 10;
{
  CAFE_CicloConteoMaximoDefault : Es el valor default para llamadas
        ciclicas en una hoja de calculo activa para ciclos con conteo,
        en la recurrencia.  Es decir un maximo de diez ciclos por
        recurrencia.
        NOTA: esto es muy bajo para cosas como 12!,
        definido por recurrencia, lo que es innecesario pues la hoja
        ya lo define.  NOTA:  por default se prohibe toda recurrencia.
}

  CAFE_MaximoConteoCicloSeguridad               : LongInt       = 1000;
{
  CAFE_MaximoConteoCicloSeguridad       : En ausencia de otra condicion
        de fin en una hoja de calculo.  La hoja genera error si
        llega a este conteo en alguna secuencia llamada por recurrencia
        ciclica. NOTA:  por default se prohibe toda recurrencia.
        La secuencia toma en cuenta todas las casillas involucradas,
        llamadas ciclicamente sin condicion bandera de fin.
        i.e. casillas con CicloConteoHCGM o CicloTomarVariantHCGM
        no son tomadas en cuenta.
        Cada casilla accesada por primera vez vuelve el conteo a cero.
}

  CAFE_StringSumatoria          = 'FORSUM()';
{
  CAFE_StringSumatoria                  : Operador de usuario para
        sumatorias FORSUM( Iü, I, 1, 3 ) = 1ü+2ü+3ü
}

  CAFE_StringProductoria        = 'FORMUL()';
{
  CAFE_StringProductoria                : Operador de usuario para
        productorias FORMUL( Iü, I, 1, 3 ) = 1ü*2ü*3ü
}

  CAFE_StringIntegral           = 'FORINT()';
{
  CAFE_StringIntegral                   : Operador de usuario para
        integrales FORINT( Iü, I, 1, 3 ) = 3**4/3-1**4/3 = 80/3
}

  CAFE_StringDerivada           = 'FORDER()';
{
  CAFE_StringDerivada                   : Operador de usuario para
        derivadas FORDER( Iü, I, 1 ) = 3*1ý = 3
}

  CAFE_StringSolve              = 'FORSOL()';
{
  CAFE_StringSolve                      : Operador de usuario para
        raiz FORSOL( Iü-8, I, 1, 3 ) = 2      NOTA: 2ü-8=0
}

  CAFE_StringSolveMaximo        = 'FORMAX()';
{
  CAFE_StringSolveMaximo                : Operador de usuario para
        x maximo FORMAX( -(I-2)ý, I, 1, 3 ) = 2 NOTA: maximo en (2,0)
}

  CAFE_StringSolveMinimo        = 'FORMIN()';
{
  CAFE_StringSolveMinimo                : Operador de usuario para
        x minimo FORMIN( (I-2)ý, I, 1, 3 ) = 2 NOTA: minimo en (2,0)
}

  CAFE_StringSumatoria2         = 'SUMATORIA()';
{
  CAFE_StringSumatoria2                 : Operador de usuario para
        sumatorias FORSUM( Iü, I, 1, 3 ) = 1ü+2ü+3ü
}

  CAFE_StringProductoria2       = 'PRODUCTORIA()';
{
  CAFE_StringProductoria2               : Operador de usuario para
        productorias FORMUL( Iü, I, 1, 3 ) = 1ü*2ü*3ü
}

  CAFE_StringIntegral2          = 'INTEGRAL()';
{
  CAFE_StringIntegral2                  : Operador de usuario para
        integrales FORINT( Iü, I, 1, 3 ) = 3**4/3-1**4/3 = 80/3
}

  CAFE_StringDerivada2          = 'DERIVADA()';
{
  CAFE_StringDerivada2                  : Operador de usuario para
        derivadas FORDER( Iü, I, 1 ) = 3*1ý = 3
}

  CAFE_StringSolve2             = 'RAIZCERO()';
{
  CAFE_StringSolve2                     : Operador de usuario para
        raiz FORSOL( Iü-8, I, 1, 3 ) = 2      NOTA: 2ü-8=0
}

  CAFE_StringSolveMaximo2       = 'RAIZMAX()';
{
  CAFE_StringSolveMaximo2               : Operador de usuario para
        x maximo FORMAX( -(I-2)ý, I, 1, 3 ) = 2 NOTA: maximo en (2,0)
}

  CAFE_StringSolveMinimo2       = 'RAIZMIN()';
{
  CAFE_StringSolveMinimo2               : Operador de usuario para
        x minimo FORMIN( (I-2)ý, I, 1, 3 ) = 2 NOTA: minimo en (2,0)
}

CONST
  CAFE_InicialToleranciaIntegral        = 0.001;
{
  CAFE_InicialToleranciaIntegral        : Valor inicial default
        de la tolerancia para integral FORINT de usuario
}

  CAFE_InicialToleranciaDerivada        = 0.001;
{
  CAFE_InicialToleranciaDerivada        : Valor inicial default
        de la tolerancia para derivada FORDER de usuario
}

  CAFE_InicialToleranciaSolve           = 0.001;
{
  CAFE_InicialToleranciaSolve           : Valor inicial default
        de la tolerancia para el solve FORSOL de usuario
}

  CAFE_InicialToleranciaFuncionalLento  = 0.001;
{
  CAFE_InicialToleranciaFuncionalLento  : Valor inicial de tolerancia
        para algunos procesos lentos.  Como la funcion ChiSquare, y
        otros.
}

  CAFE_InicialToleranciaFuncionalF      = 0.0001;
{
  CAFE_InicialToleranciaFuncionalF      : Debido a que la funcion F
        de Fisher, por limitaciones internas de EJES.EXE no
        admite la tolerancia como parametro;  se decidio
        crear esta constante por separado de otras funciones.
        NOTA: se tiene la intencion de corregir esto en el futuro.
}

  CAFE_InicialToleranciaDeterminante    = 1E-7;
{
  CAFE_InicialToleranciaDeterminante    : Valor inicial a
        asignar para considerar cero al evaluar un determinante.
        Esto es importante en ecuaciones lineales.
        En algunos aplicaciones este valor podria resultar muy elevado.
}

  CAFE_InicialEpsilonZero               = 1E-4;
{
  CAFE_InicialEpsilonZero               : Algunas aplicaciones
        prohiben negativos o similar, (-1e-7 es cero o negativo);
        para responder esta pregunta surge esta constante
        como valor inicial del parametro ValorEpsilonZero,
        su valor es muy elevado, asi que se utiliza
        para evitar generar
        condiciones de error, en raiz de negativo o similar.
}

  CAFE_InicialMaximoCiclosSolve         = 30;
{
  CAFE_InicialMaximoCiclosSolve         : Valor inicial a asignar
        como maximo para ciclos solve de punto medio usuario FORSOL
}

  CAFE_InicialMaximoCiclosFuncionalSolve        = 30;
{
  CAFE_InicialMaximoCiclosFuncionalSolve                : Valor inicial
        a asignar como maximo para ciclos solve de punto medio
        para muchas funcionales de evaluacion lenta.
}

  CAFE_InicialPreliminarSolve           = 10;
{
  CAFE_InicialPreliminarSolve           : Valor inicial de puntos
        de busqueda en el recorrido preliminar de FORSOL, antes
        de aplicar la tecnica de solve por punto medio.
}

  CAFE_InicialPreliminarSolveFuncional  = 10;
{
  CAFE_InicialPreliminarSolveFuncional  : Valor inicial de puntos
        de busqueda en el recorrido preliminar de solve, para
        muchas funciones de evaluarcion lenta, como ChiSquare integral
        inversa.
}

  CAFE_InicialMaximaIteracionIntegralOctavoImpar        = 10;
{
  CAFE_InicialMaximaIteracionIntegralOctavoImpar        :
        Valor inicial de iteracion para la integral de usuario
        FORINT, utiliza este valor como maxima iteracion a permitir
        mediante el metodo de IntegralOctavoImpar
}

  CAFE_InicialMaximaIteracionIntegralOctavoImparFuncion = 10;
{
  CAFE_InicialMaximaIteracionIntegralOctavoImparFuncion :
        Numero de iteraciones maximas para algunas funciones
        lentas de evaluacion que requieren integral.
        i.e. la integral inversa de ChiSquare
}

VAR
  CAFE_BanderaAlertaDominio             : Boolean;
{
  CAFE_BanderaAlertaDominio             : Se activa cuando una llamada
        a la funcion IfDominio() invoca un FALSE.
        Su objetivo mas proximo es la graficacion.
        Cuando CAFE_Ej4 asigna TRUE, se queda en ese
        estado indefinidamente en esta unidad.  La idea
        es que el graficador lo devuelva a estado FALSE
        antes de cada evaluacion si utiliza esta funcion.
        Ademas seria conveniente revisar las banderas
        AlertaDominioHCGM en las casillas pertinentes y borrarlas.
}

  CAFE_RedondeoFinalCalculoNITI         : Boolean       = TRUE;
  // para evitar raices como 2.00011 para X-2=0
{
  CAFE_RedondeoFinalCalculoNITI         : TRUE autoriza el redondeo
        en el calculo final, es decir al presentar en pantalla
        el resultado de funciones que aplican tolerancia
        como la integral, solve, etc...
}

  CAFE_TipoCollectionFormato            : TCollectionItemClass;
{
  CAFE_TipoCollectionFormato            :
        Referencia para el tipo de collection que se utiliza en el
        formato de hojas de calculo.  Se supone que se definiran con
        la maxima version disponible.
}

  CAFE_MaximoCiclosSolve                : Byte
                                        = CAFE_InicialMaximoCiclosSolve;
{
  CAFE_MaximoCiclosSolve                : Valor a asignar como maximo
        de ciclos para FORSOL de usuario
}

  CAFE_MaximoCiclosFuncionalSolve       : Byte
                        = CAFE_InicialMaximoCiclosFuncionalSolve;
{
  CAFE_MAximoCiclosFuncionalSolve       : Valor a asignar como maximo
        de ciclos para solve de algunos funcionales lentos como
        el ChiSquare
}

  CAFE_MaximaIteracionDerivadaContinuaInterpolada       : Byte          = 7;
{
  CAFE_MaximaIteracionDerivadaContinuaInterpolada       :
        Numero maximo de iteraciones para aproximar la derivada
        al ejecutar el usuario un FORSOL
}

  CAFE_PreliminarSolveFuncional         : LongInt       =
                                CAFE_InicialPreliminarSolveFuncional;
{
  CAFE_PreliminarSolveFuncional         : Numero de puntos de busqueda
        preliminar para aplicar solve, en algunas funciones internas
        de lenta evaluacion
}

  CAFE_DefaultToleranciaIntegral        : Double        =
                                CAFE_InicialToleranciaIntegral;
{
  CAFE_DefaultToleranciaIntegral        : FORINT permite especificar
        la tolerancia, cuando no se indica se asigna este valor
        de tolerancia a la integral
}

  CAFE_DefaultToleranciaDerivada        : Double        =
                                CAFE_InicialToleranciaDerivada;
{
  CAFE_DefaultToleranciaDerivada        : FORDER permite especificar
        la tolerancia, cuando no se indica se asigna este valor
        de tolerancia a la derivada
}

  CAFE_DefaultToleranciaSolve           : Double        =
                                CAFE_InicialToleranciaSolve;
{
  CAFE_DefaultToleranciaSolve           : FORSOL permite especificar
        la tolerancia, cuando no se indica se asigna este valor
        de tolerancia a la derivada
}

  CAFE_DefaultToleranciaFuncionalLento  : Double        =
                                CAFE_InicialToleranciaFuncionalLento;
{
  CAFE_DefaultToleranciaFuncionalLento  : a algunas funciones internas
        de evaluacion lenta, se utilizara este valor como una guia
        de la tolerancia solicitada.  Generalmente dichas funciones
        ofreceran un parametro opcional, para intentar otra tolerancia.
}

  CAFE_DefaultToleranciaFuncionalF      : Double        =
                                CAFE_InicialToleranciaFuncionalF;
{
  CAFE_DefaultToleranciaFuncionalF      : debido a que la funcion F
        de Fisher por deficiencias de EJES.EXE no ofrece un
        parametro de tolerancia.  Se agrega este parametro,
        para control interno de su exactitud.
}

  CAFE_DeltaInicialDerivada             : Double        = 0.01;
{
  CAFE_DeltaInicialDerivada             : FORDER ofrece como parametro
        opcional el Delta inicial para intentar estimar la derivada.
        En caso de no indicar, se utilizara este valor.
}

  CAFE_HabilitarUnCiclo                 : Boolean;
{
  CAFE_HabilitarUnCiclo                 : En condicion TRUE
        CAFE_HojaCalculoBase.EscribirMacroSimple y
        CAFE_HojaCalculoBase.EscribirFuncionSimple utilizan esta bandera
        en estado TRUE para marcar la casilla como
        [ BasicoStandardHCGM, ActivarCicloHCGM, CicloTomarVariantHCGM ]
        esto permitira introducir ciclos sin mensajes de error.
        Aunque probablemente requiera modificacion para que funcione
        bien.
        De salida de dichos metodos CAFE_HabilitarUnCiclo es FALSE.
        O sea solo dura un dato.
        Afortunadamente: EJES.EXE probablemente reparara muchas
        inconsistencias automaticamente, en cuanto tenga
        la informacion requerida si el usuario por descuido olvido el
        CAFE_HabilitarUnCiclo
}

TYPE
  CAFE_ParametroBasico          =
        (
          ActivoHCGM,
          BasicoStandardHCGM, Real1DHCGM, Real2DHCGM, Real3DHCGM,
          ActivarCicloHCGM,
          CicloTomarVariantHCGM, CicloEvaluarHCGM, CicloConteoHCGM,
          FinConteoErrorHCGM,
          CasillaIniciativaHCGM, AlertaDominioHCGM
        );
{
  CAFE_ParametroBasico          : Tipo ordenada que describe diferentes
        estados en los que puede estar una funcion o macro asignada
        a una hoja de calculo.
        HCGM : HojaCalculoGeneralManejador
  ActivoHCGM                    : Para indicar informacion util en el campo
  BasicoStandardHCGM            : Para indicar que sigue las reglas de
        la version 1.0 de EJES.EXE (version actual 2011)
  Real1DHCGM                    :
        Indica que la macro tiene solo un parametro y es real,
        solo uno debe marcarse.
  Real2DHCGM                    :
        Indica que la macro tiene dos parametros y son reales,
        solo uno debe marcarse.
  Real3DHCGM                    :
        Indica que la macro tiene tres parametros y son reales,
        solo uno debe marcarse.
  ActivarCicloHCGM              : bandera exigida si hay ciclos.
        De lo contrario al detectar un ciclo se genera
        un error de proceso con FUNCTION FALSE
  CicloTomarVariantHCGM         : en caso de ciclo, esto indica
        al programa que debe tomar el valor ya almacenado
        en la casilla
  CicloEvaluarHCGM              : en caso de ciclo, esto indica
        al programa que debe proceder a evaluar.  Se considera
        redundante si activa CicloConteoHCGM, y es innecesaria.
  CicloConteoHCGM               : en caso de ciclo, esto indica
        al programa que debe proceder a evaluar la casilla,
        hasta un numero maximo de veces, que se indica internamente
        en dicha casilla.
  FinConteoErrorHCGM            : en caso de CicloConteoHCGM
        llegue a cuenta cero, se toma el valor actual,
        esto se puede interpretar como un error FUNCTION FALSE
        si se activa esta bandera, si no esta activa
        devuelve FUNCTION TRUE
  CasillaIniciativaHCGM         : la casilla prohibe la evaluacion
        que no sea por iniciativa.  La iniciativa se detecta cuando la
        casilla recibe una clave de CicloSintactico = 0
        (o sea valor default del parametro).  Esto puede
        ser util con funciones de lenta evaluacion.
        NOTA: No aplica en macros, pues se considera que
                una macro es util por uso y no por iniciativa
  AlertaDominioHCGM             : bandera que se activa con la funcion
        IfDominio(), cuando produce false.  Por lo demas
        es identica a IfThen() en el caso double.  No hace nada mas,
        y deberia crearse en alguna otra unidad un proceso
        que la utilice y desactive, si es el caso.
        Si se activa, se mantiene en ese estado indefinidamente
        en CAFE_Ej4 sin otro efecto.
}

  CAFE_TipoInterprete           =
        (
          ActivoNITI, PredefinidoNITI, ConstNITI, VarNITI, OverloadNITI,
          ActivarDefaultNITI,
          PrimeroDefaultNITI, SegundoDefaultNITI, TerceroDefaultNITI,
          AnularDefaultNITI, TypeNITI, FuncionalNITI, FuncionalLentoNITI,
          CasillaHojaNITI,
          HojaDefaultNITI, AbsolutoColumnaNITI, AbsolutoFilaNITI,
          ParametroMacroNITI,
          Parametro1DNITI, Parametro2DNITI, Parametro3DNITI,
          OrdenCalculoNITI,
          SumatoriaNITI, ProductoriaNITI, IntegralNITI, DerivadaNITI,
          SolveNITI, SolveMaximoNITI, SolveMinimoNITI,
          ParametroCalculoNITI, Parametro1CalculoNITI,
          Parametro2CalculoNITI, Parametro3CalculoNITI,
          SectorNITI, OperadorSectorNITI, SilenciarSectorNITI,
          NudilladoNITI,
          OperadorRegistroNITI, RegistroAsociadoNITI,
          ManejadorPrincipalNITI, ManejadorSelfNITI
        );
{
  CAFE_TipoInterprete           : El interprete asociado a cada
        elemento sintactico, puede clasificarse para diversas caracteristicas.
  ActivoNITI                    : El interprete sintactico tiene
        informacion util y activa.
  PredefinidoNITI               : Son variables y operadores
        que se agregan a la Hoja de calculo automaticamente
        por el computador.
  ConstNITI                     : Se refiere a un tipo variante
        de lectura directa o funcion que no puede variar.
  VarNITI                       : unimplemented
        Se refiera a un interprete cuyo contenido puede variar
  OverloadNITI                  : Que el operador o funcion
        se ofrece con dos o mas variantes de parametros.
        Es diferente de DefaultNITI.
  ActivarDefaultNITI            : Que algunos parametros
        pueden asumirse, sin ser escritos por el usuario.
  PrimeroDefaultNITI            : Indica que el primer
        parametro es de tipo Default.
  SegundoDefaultNITI            : Indica que el segundo
        parametro es de tipo Default.
  TerceroDefaultNITI            : Indica que el tercer
        parametro es de tipo Default.
  AnularDefaultNITI             : Obligatoria en la primera
        version de EJES.EXE, establece como valor default,
        un valor nulo del variante respectivo.
  TypeNITI                      : unimplemented
        para declaracion de tipos
  FuncionalNITI                 : indica que es de tipo funcional,
        corriente como sin(X), etc...
  FuncionalLentoNITI            : no necesita FuncionalNITI, y declara
        el interprete como de evaluacion lenta.
        i.e., podria ordenarle a la computadora activar
        CasillaIniciativaHCGM para todo FuncionalLentoNITI
  CasillaHojaNITI               : Insica que el identificador
        hace referencia a una casilla de hoja de calculo,
        que bien podria ser macro o no.
  HojaDefaultNITI               : obligatorio en primera
        version de EJES.EXE, indica que se trata de una casilla
        de la Hoja por defecto.
  AbsolutoColumnaNITI           : Declara que la CasillaHojaNITI
        es fija en la copia de casillas, respecto a la columna.
  AbsolutoFilaNITI              : Declara que la CasillaHojaNITI
        es fija en la copia de casillas, respecto a la fila
  ParametroMacroNITI            : El interprete hace referencia
        a un identificador de parametro de macro en Hoja de Calculo
  Parametro1DNITI               : Con ParametroMacroNITI activo,
        hace referencia al primer parametro real (excluyente)
  Parametro2DNITI               : Con ParametroMacroNITI activo,
        hace referencia al segundo parametro real (excluyente)
  Parametro3DNITI               : Con ParametroMacroNITI activo,
        hace referencia al tercer parametro real (excluyente)
  OrdenCalculoNITI              : No requiere FuncionalNITI,
        indica que se trata de una orden de tipo FOR o calculo,
        como FORSUM, FORINT, FORSOL, para sumatoria, integral, solve...
  SumatoriaNITI                 : Con OrdenCalculoNITI activa
        indica que se trata de una sumatoria de usuario FORSUM
  ProductoriaNITI               : Con OrdenCalculoNITI activa
        indica que se trata de una productoria de usuario FORMUL
  IntegralNITI                  : Con OrdenCalculoNITI activa
        indica que se trata de una integral de usuario FORINT
  DerivadaNITI                  : Con OrdenCalculoNITI activa
        indica que se trata de una derivada de usuario FORDER
  SolveNITI                     : Con OrdenCalculoNITI activa
        indica que se trata de una orden solve de usuario FORSOL
  SolveMaximoNITI               : Con OrdenCalculoNITI activa
        indica que se trata de una orden solve maximo de usuario FORMAX
  SolveMinimoNITI               : Con OrdenCalculoNITI activa
        indica que se trata de una orden solve minimo de usuario FORMIN
  ParametroCalculoNITI          : Indica que el interprete se un
        identificador de parametro
        para un tipo OrdenCalculoNITI (bandera inactiva aqui)
  Parametro1CalculoNITI         : Con ParametroCalculoNITI,
        hace referencia a la variable de
        primer nivel de anidamiento (excluyente)
  Parametro2CalculoNITI         : Con ParametroCalculoNITI,
        hace referencia a la variable de
        segundo nivel de anidamiento (excluyente)
  Parametro3CalculoNITI         : Con ParametroCalculoNITI,
        hace referencia a la variable de
        tercer nivel de anidamiento (excluyente)
  SectorNITI                    : Indica que el FuncionalNITI, requiere
        una zona rectangular de Hoja de Calculo para evaluar.
        i.e. la suma de casillas.  No confundir con OperadorSectorNITI.
  OperadorSectorNITI            : Se refiere al operador ':' para
        identificar zonas rectangulares en Hoja de Calculo.
        Unicamente activar esta bandera en dicho operador.
        No en los nombres de casilla.
        No confundir con SectorNITI.
  SilenciarSectorNITI           : Solicita que el operador ':' no
        propague el calculo de casilla, sino que
        simplemente tome el valor ya existente.
        Deberia estar presente en el operador ':',
        y presente en un funcional tipo SectorNITI, solicita
        esta bandera al interpretar, i.e. DETERMINANTE()
  NudilladoNITI                 : El interprete actual se
        encuentra vinculado a la existencia del
        Nudillado de una orden,
        por tanteo debe destruirse con el
        ArbolSintactico respectivo pues no tiene existencia independiente
  OperadorRegistroNITI          : Se refiere al indicador
        de registro en sus diversas aplicaciones
  RegistroAsociadoNITI          : Se refiere a un antecedente Pascal
        valido del operador Registro
  ManejadorPrincipalNITI        : Indica que OperadorRegistroNITI
        se aplica en un ManejadorPrincipal, i.e. da
        acceso a una Hoja de Calculo en la raiz
  ManejadorSelfNITI             : Indica que se refiere al
        Manejador actual
}

  CAFE_ConjuntoParametroBasico          = SET OF CAFE_ParametroBasico;
{
  CAFE_ConjuntoParametroBasico  : Establece un tipo conjunto para
        manejar el tipo de dato CAFE_ParametroBasico, util en
        la descripcion de casillas funcionales o macros...
}

  CAFE_ConjuntoTipoInterprete           = SET OF CAFE_TipoInterprete;
{
  CAFE_ConjuntoTipoInterprete   : Establece un tipo conjunto para
        manejar el tipo de dato CAFE_TipoInterprete, util en
        la descripcion de interpretes de identificador u operador
}

CONST
  CAFE_GUIDInterfaceManejador   =  '{04000000-0000-0000-DEFA-BACA000000A0}';
{
  CAFE_GUIDInterfaceManejador   : GUID como ShortString
                        para CAFE_InterfaceManejador
}

TYPE
  CAFE_CharByte3Sintactico      = Packed CLASS ( CAFE_CharByte2Sintactico )
{
  La clase implementa el metodo GramaticaOperador que convierte
        un ShortString en una sintaxis de operadores.
        Util a nivel de renglon,
        no serviria en fines como declaracion de tipos, etc.
}

  Public
  // Actualizar siempre
CONSTRUCTOR Create
  (     Tamano          : LongInt                               ); override;
{
  Inicializa el CharByte para su buen funcionamiento,
  pero completamente vacio.
  Tamano es el nuevo TamanoVector. (no compatible FreeMem)
}

  // Actualizar siempre
CONSTRUCTOR Create
  ( CONST
        Msg             : ShortString;
        Tamano          : LongInt                               ); override;
{
  Inicializar el CharByte para su buen funcionamiento,
  con Msg como datos iniciales. No importa, utilizar Tamano "muy grande".
  Msg podria ser ''.
}

  // Actualizar siempre
CONSTRUCTOR Create
  (     Modelo          : CAFE_ClassCharByte                    ); override;
{
  Inicializa el CharByte, copiando completamente el dato
  CharByte de modelo, incluyendo su TamanoVector.
  No asigna el mismo nivel de clase.
}

FUNCTION    VerificarIdentificador
  ( CONST   CadenaIdentificador     : ShortString               ) : Boolean;
{
  FUNCTION      VerificarIdentificador
        Su objetivo es determinar si CadenaIdentificador es
        completamente un Identificador valido o no.
        Esta FUNCTION no aplica UpCase ni similar.  Utiliza
        los conjuntos CAFE_PrimerByteIdentificadorSintactico y sig.
  CadenaIdentificador   : String a revisa si se trata de identificador valido.
  FUNCTION VerificarIdentificadorValido         : TRUE indica si
        es identificador valido, FALSE no.
}

FUNCTION    GramaticaOperadores
  ( CONST Msg           : ShortString;
          Lista         : CAFE_TStringList      = NIL   ) : Boolean; virtual;
{
  FUNCTION GramaticaOperadores
        Convierte a Msg en gramatica de OperadoresBasicos,
        esto incluye operadores binarios, unarios, logicos,
        comentarios, string, zona rectangular de hoja calculo,
        asignacion :=
        Algunas de las traducciones no estan en realidad
        implementadas en EJES.EXE
  Msg                   : Cadena de texto a convertir a OperadorBasico
  Lista                 : Permite sugerir una lista de String,
        de no indicarse se utiliza CAFE_DefaultListaString
  FUNCTION GramaticaOperadores          : TRUE -> indica exito
        en la operacion, a este nivel
        no es segura la conversion completa.
        FALSE -> indica algun error sintactico, puede revisarse
        CAFE_IntentoInfructuosoSintactico
}

DESTRUCTOR  Destroy; override;
{
  DESTRUCTOR Destroy;
        Se produce la destruccion del CharByte.
}

                                  END;  { CLASS CAFE_CharByte2Sintactico }

     CAFE_Nudo2Sintactico       = Packed CLASS
                                        ( CAFE_NudoSintactico )
//    IdentificadorElemento       : LongInt;
//    DatoElemento                : Variant;
//    DescendienteHorizontal,
//    DescendienteVertical        : CAFE_NudoSintactico;
//    DatoInterpretado            : CAFE_InterpreteSintactico;
{
  Clase evolucionada para el Nudillado y evaluacion de hoja de calculo,
  aunque podria funcionar en forma independiente, para calculos
  mas simples. i.e. 3*2+SIN(PI).
  Contendria la casilla convertida en arbol sintactico,
  estos arboles estarian enlazados con tipos interpretes
  CAFE_Interprete2Sintactico
  CasillaHoja de Calculo
  CAFE_SintacticaHoja[i][j] = CAFE_DatoNudillado CLASS
                                 ...
                                 FuncionNudillado : CAFE_Nudo2Sintactico;
}

CONSTRUCTOR Create; override;
{
  Constructor de clase basico, genera un identificador unico interno
}

CONSTRUCTOR Create
  (     Ide                     : LongInt                       ); override;
{
  Constructor de clase basico, permite obligar el identificador Ide.
        Esto es util, por ejemplo, en procesos de copia
}

CONSTRUCTOR Create
  (     Ide                     : LongInt;
        NuevoDato               : Variant                       ); override;
{
  Constructor de clase basico, agrega el numero identificador, y
        ademas NuevoDato se asigna a DatoElemento
}

FUNCTION    NuevoArbol
  ( CONST VectorFuente          : CAFE_ClassCharbyte
                                                ) : CAFE_Nudo2Sintactico;
{
  FUNCTION NuevoArbol
        Genera un arbol sintactico a partir de una sintaxis correcta
        de OperadorBasico
  VectorFuente                  : CharByte a interpretar, acepta
        cadena de blancos, aunque devolveria un NIL
  FUNCTION NuevoArbol           : devuelve un arbol sintactico,
        utilizando Self como modelo para el tipo de dato,
        que deberia ser al menor CAFE_Nudo2Sintactico.
        Self no se modifica
}

FUNCTION    InterpretarFuncion
  (       Manejador             : CAFE_InterfaceBasico;
    OUT   FuncionReturn         : Variant;
    OUT   Msg                   : ShortString           ) : Boolean; virtual;
{
  FUNCTION InterpretarFuncion
        Interpreta un arbol sintactico a partir de Self,
        requiere el Manejador para reconocimiento de identificadores,
        hoja de calculo si existe y demas.
        Su mision es agregar CAFE_Interprete2Sintactico a
        los nodos pertinentes.
        (puede compartirse interpretes o pueden ser unicos)
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  FuncionReturn                 : Devuelve un resultado de correcto
        tipo, aunque su valor es dudoso, pues realiza simplificaciones
        que podrian errar el valor.
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  FUNCTION InterpretarFuncion   : TRUE indica exito, FALSE algun problema
        Se recomienda consultar en tal caso la bandera
        CAFE_IntentoInfructuosoSintactico
}

FUNCTION    InterpretarMacro
  (       Manejador             : CAFE_InterfaceBasico;
    OUT   Msg                   : ShortString;
    CONST NomParam1             : ShortString;
    CONST NomParam2             : ShortString   = '';
    CONST NomParam3             : ShortString   = ''    ) : Boolean; virtual;
{
  FUNCTION InterpretarMacro
        Interpreta una macro, con un maximo de
        tres parametros de tipo real.  Es obligatorio
        NomParam1 <> ''.  La salida de una macro en EJES.EXE es real,
        o a la sumo compatible.
        Interpreta un arbol sintactico a partir de Self,
        requiere el Manejador para reconocimiento de identificadores,
        hoja de calculo si existe y demas.
        Su mision es agregar CAFE_Interprete2Sintactico a
        los nodos pertinentes.
        (puede compartirse interpretes o pueden ser unicos)
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  NomParam1                     : Nombre valido de identificador
        del primer parametro, obligatorio
  NomParam2                     : (optativo), permite definir
        un segundo parametro para la macro
  NomParam3                     : (optativo), permite definir
        un tercer parametro para la macro
  FUNCTION InterpretarMacro     : TRUE indica exito, FALSE algun problema
        Se recomienda consultar en tal caso la bandera
        CAFE_IntentoInfructuosoSintactico
}

        Protected
FUNCTION    InterpretarMacroFuncion
  (       Manejador             : CAFE_InterfaceBasico;
    OUT   FuncionReturn         : Variant;
    OUT   Msg                   : ShortString;
    CONST NomParam1             : ShortString   = '';
    CONST NomParam2             : ShortString   = '';
    CONST NomParam3             : ShortString   = '';
    CONST NomFor1               : ShortString   = '';
    CONST NomFor2               : ShortString   = '';
    CONST NomFor3               : ShortString   = '';
          SubRegistro           : Boolean       = FALSE ) : Boolean; virtual;
{
  FUNCTION InterpretarMacroFuncion
        Interpreta un arbol sintactico a partir de Self,
        requiere el Manejador para reconocimiento de identificadores,
        hoja de calculo si existe y demas.
        Su mision es agregar CAFE_Interprete2Sintactico a
        los nodos pertinentes.
        (puede compartirse interpretes o pueden ser unicos)
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  FuncionReturn                 : Devuelve un resultado de correcto
        tipo, aunque su valor es dudoso, pues realiza simplificaciones
        que podrian errar el valor.  Las macros deberian
        devolver un resultado real, pero esto no se revisa aqui.
        Mejor utilice Self.InterpretarMacro para mayor seguridad.
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  NomParam1                     : Nombre valido de identificador
        del primer parametro, obligatorio si es tipo Macro.
  NomParam2                     : (optativo), permite definir
        un segundo parametro si se trata de tipo Macro
  NomParam3                     : (optativo), permite definir
        un tercer parametro si se trata de tipo Macro
  NomFor1                       : (no usar)
        no deberia utilizarse, existe
        internamente para permitir la recursividad
        y el anidamiento de ciclos
        FOR al estilo de FORMUL, FORSUM... etc.
        Primer parametro FOR de anidamiento.
  NomFor2                       : (no usar)
        no deberia utilizarse, existe
        internamente para permitir la recursividad
        y el anidamiento de ciclos
        FOR al estilo de FORMUL, FORSUM... etc.
        Segundo parametro FOR de anidamiento.
  NomFor3                       : (no usar)
        no deberia utilizarse, existe
        internamente para permitir la recursividad
        y el anidamiento de ciclos
        FOR al estilo de FORMUL, FORSUM... etc.
        Tercer parametro FOR de anidamiento.
  SubRegistro                   : Bandera para establecer prioridad
        de los nombres cuando exista confusion
        entre si se trata de un subregistro o un parametro for
        del mismo nombre.  Aplica para subregistro como TRUE.
        FORSUM(A1+SELF.A1,A1,0,5) SubRegistro = TRUE para .A1
  FUNCTION InterpretarMacroFuncion      : TRUE indica exito,
        FALSE algun problema
        Se recomienda consultar en tal caso la bandera
        CAFE_IntentoInfructuosoSintactico
}

        Public
FUNCTION    EvaluarFuncion
  ( OUT   VariantFuncion        : Variant;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          CicloSintactico       : LongInt       = 0     ) : Boolean; virtual;
{
  FUNCTION EvaluarFuncion
        Procede a intentar EvaluarFuncion, lo que requiere
        un llamado previo a Self.InterpretarFuncion o equivalente.
        Es decir, revisa el ArbolSintactico que se asume
        existe en Self, y genera un resultado que devuelve
        en VariantFuncion
        (varString, varDouble, varByte, varInteger, varBoolean)
  VariantFuncion                : OUTPUT -> el resultado de evaluacion
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  CicloSintactico               : No generar por el usuario
        si no sabe lo que hace,
        valor para control de Hojas de Calculo, su objetivo
        es detectar la formacion de un Ciclo en una Hoja de Calculo.
        No definir en evaluaciones externas, tipo Calcular expresion...,
        si la expresion accesa a al hoja, ella se encargara.
  FUNCTION EvaluarFuncion       : devuelve TRUE para indicar exito
        en el proceso, FALSE algun problema
        Se recomienda entonces consultar Msg y
        CAFE_IntentoInfructuosoSintactico
}

FUNCTION    EvaluarMacro
  ( OUT   ResultMacro           : Double;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          TotalParMacro         : LongInt;
          Param1                : Double        = 0.0;
          Param2                : Double        = 0.0;
          Param3                : Double        = 0.0;
          CicloSintactico       : LongInt       = 0     ) : Boolean; virtual;
{
  FUNCTION EvaluarMacro
        Procede a intentar Evaluar una macro, lo que requiere
        un llamado previo a Self.InterpretarMacro o equivalente.
        Es decir, revisa el ArbolSintactico que se asume
        existe en Self, y genera un resultado que devuelve
        en ResultMacro que deberia ser real, admitiendo
        entre uno y tres parametros de ingreso.
  ResultoMacro                  : OUTPUT -> el resultado de evaluacion
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  TotalParMacro                 : Valor entre uno y dos, para
        establecer el total de parametros de macro
  Param1                        : Permite ingresar el valor del
        primer parametro de macro
  Param2                        : Permite ingresar el valor del
        segundo parametro de macro
  Param3                        : Permite ingresar el valor del
        tercer parametro de macro
  CicloSintactico               : No generar por el usuario
        si no sabe lo que hace,
        valor para control de Hojas de Calculo, su objetivo
        es detectar la formacion de un Ciclo en una Hoja de Calculo.
        No definir en evaluaciones externas, tipo Calcular expresion...,
        si la expresion accesa a al hoja, ella se encargara.
  FUNCTION EvaluarMacro         : devuelve TRUE para indicar exito
        en el proceso, FALSE algun problema
        Se recomienda entonces consultar Msg y
        CAFE_IntentoInfructuosoSintactico
}

  Protected
FUNCTION    EvaluarMacroFuncion
  ( OUT   ResultMacro           : Variant;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          TotalParMacro         : LongInt       = 0;
          Param1                : Double        = 0.0;
          Param2                : Double        = 0.0;
          Param3                : Double        = 0.0;
          CicloSintactico       : LongInt       = 0;
          ForParam1             : Double        = 0.0;
          ForParam2             : Double        = 0.0;
          ForParam3             : Double        = 0.0   ) : Boolean; virtual;
{
  FUNCTION EvaluarMacroFuncion
        Procede a intentar Evaluar una macro o una funcion, lo que requiere
        un llamado previo a Self.InterpretarMacroFuncion o equivalente.
        Es decir, revisa el ArbolSintactico que se asume
        existe en Self, y genera un resultado que devuelve
        en ResultMacro
        (varString, varDouble, varByte, varInteger, varBoolean)
  ResultMacro                   : OUTPUT -> el resultado de evaluacion
        por compatibilidad con funciones no macro, permite
        cualquier tipo de salida definida en EJES.EXE
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  TotalParMacro                 : Valor entre uno y dos, para
        establecer el total de parametros de macro
  Param1                        : Permite ingresar el valor del
        primer parametro de macro
  Param2                        : Permite ingresar el valor del
        segundo parametro de macro
  Param3                        : Permite ingresar el valor del
        tercer parametro de macro
  CicloSintactico               : No generar por el usuario
        si no sabe lo que hace,
        valor para control de Hojas de Calculo, su objetivo
        es detectar la formacion de un Ciclo en una Hoja de Calculo.
        No definir en evaluaciones externas, tipo Calcular expresion...,
        si la expresion accesa a al hoja, ella se encargara.
  ForParam1                     : (no usar)
        no deberia utilizarse, existe
        internamente para permitir la recursividad
        y el anidamiento de ciclos
        FOR al estilo de FORMUL, FORSUM... etc.
        Primer parametro FOR de anidamiento.
  ForParam2                     : (no usar)
        no deberia utilizarse, existe
        internamente para permitir la recursividad
        y el anidamiento de ciclos
        FOR al estilo de FORMUL, FORSUM... etc.
        Segundo parametro FOR de anidamiento.
  ForParam3                     : (no usar)
        no deberia utilizarse, existe
        internamente para permitir la recursividad
        y el anidamiento de ciclos
        FOR al estilo de FORMUL, FORSUM... etc.
        Tercer parametro FOR de anidamiento.
  FUNCTION EvaluarMacroFuncion  : devuelve TRUE para indicar exito
        en el proceso, FALSE algun problema
        Se recomienda entonces consultar Msg y
        CAFE_IntentoInfructuosoSintactico
}

  Public
FUNCTION    TotalDescendientesDirectos
  (       PunteroActual         : CAFE_NudoSintactico  = NIL    ) : LongInt;
{
  FUNCTION TotalDescendientesDirectos
        A partir de PunteroActual o Self, se determina cuantos
        descendientes directos posee
        DescendienteDirecto     : En lazado
                por medio de PunteroActual.DescendienteVertical,
                en linea horizontal totalmente.
                Es decir, todos los descendienteHorizontal
                a partir de PunteroActual.DescendienteVertical (inclusive)
        En sintaxis de OperadorBasico,
        TotalDescendienteDirecto equivale al total de parametros.
  PunteroActual                 : Es el puntero a analizar
        si es NIL, indica self.
  FUNCTION TotalDescendientesDirectos   : Devuelve el numero solicitado.
}

  Private
FUNCTION    ReescribirEnCopiaCasilla
  (       Fila, Columna         : LongInt;
          NuevaFila, NuevaColumna               : LongInt;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
    CONST FuncionLiteral        : ShortString;
    OUT   CopiaLiteral          : ShortString;
          FilaProtegida         : LongInt       = 0;
          ColumnaProtegida      : LongInt       = 0;
          DolarValido           : Boolean       = TRUE;
          BanderaSuperposicion  : Boolean       = FALSE         ) : Boolean;
{
  FUNCTION ReescribirEnCopiaCasilla
        El objetivo de FUNCTION es preparar la copia de casillas en
        Hoja de Calculo su objetivo es modificar FuncionLiteral,
        cambiando las referencias de casillas en forma
        relativa o absoluta segun el origen y el destino
        i.e.  A1+sum($A3:B$5)
        si la copia va desde C3 a D5 se cambiaria en
              B3+sum($A5:C$5)
        FUNCTION solo opera sobre String no realiza ninguna copia
        ni consulta de casillas
        Es sensible a algunos errores sintacticos devolviendo FALSE,
        y CopiaLiteral indefinida.  Tambien algunos desplazamientos
        ficticios exagerados, provocaran FALSE.  Aunque tolerara
        salirse levemente del rango valido.
  Fila                          : para indicar una pretendida
        Fila de origen de la copia (no se consulta).
  Columna                       : para indicar una pretendida
        Columna de origen de la copia (no se consulta).
  NuevaFila                     : para indicar una pretendida
        Fila de destino en la copia (no se consulta ni escribe).
  NuevaColumna                  : para indicar una pretendida
        Columna de destino en la copia (no se consulta ni escribe).
  Msg                           : para mensajes de error,
        podria ser util para explicar algunas respuestas FALSE.
  Manejador                     : necesario para algunas
        caracteristicas sintacticas y de la hoja.
  FuncionLiteral                : String original a ser analizado.
  CopiaLiteral                  : Modificacion de FuncionLiteral
        incluyendo el desplazamiento ficticio.
  FilaProtegida                 : Para procesos de borrado e insercion,
        algunas filas no sufren cambio.
        FilaReferencia < FilaProtegida no se modifica.
  ColumnaProtegida              : Para procesos de borrado e insercion,
        algunas filas no sufren cambio.
        ColumnaReferencia < ColumnaProtegida no se modifica.
  DolarValido                   : No prohibe el uso del dolar,
        simplemente se ignora.  Esto ocurre en procesos
        de borrado e insercion, que deberia indicarse FALSE.
        Si no se indica, generalmente se calcula solo,
        pero falla en casillas como A1, etc...
  BanderaSuperposicion          : Las variables $Fila y $Columna
        solo sufren transformacion en la Copia de Casillas con
        superposicion, para ello existe esta bandera.
  FUNCTION ReescribirEnCopiaCasilla             : devuelve TRUE
        para indicar exito (podria no haber hecho ninguna
        modificacion), FALSE indica algun tipo de error en el
        proceso.
}

  Public
CONSTRUCTOR Create
  (     Modelo                  : CAFE_NudoSintactico           ); override;
{
  Constructor de clase, que utiliza un modelo para adquirir datos,
        incluyendo el numero identificador.
}

DESTRUCTOR  Destroy; override;
{
  DESTRUCTOR Destroy
        Destructor de clase
}

                                  END;  { CLASS CAFE_Nudo2Sintactico }

TYPE
  CAFE_ReferenciaDatoExtendido  = CLASS OF CAFE_DatoExtendido;
{
  CAFE_ReferenciaDatoExtendido  : Genera una clase de referencia
        para el tipo CAFE_DatoExtendido.
}

  CAFE_DatoExtendido            = PACKED CLASS
{
  CAFE_DatoExtendido            : Es el tipo fundamental que se
        enlaza para interpretacion de casillas
        CAFE_HojaCalculoBase.SintacticaHoja[i][j] -> CAFE_DatoExtendio
        Aunque este tipo probablemente siempre carezca de utilidad.
        La unica descendencia util actual
        es CAFE_DatoNudillado,
        no se ha probado otros tipos de descendencia, pero
        no deberia ser problemas;  a parte de las obvias.
        Deberia probar
        SintacticaHoja[i][j] is CAFE_DatoNudillado para evitar
        errores en el futuro.
}

    ModeloExtendido             : CAFE_ReferenciaDatoExtendido;
{
  ModeloExtendido               : Para determinar una referencia interna.
        Actualmente no funciona bien, y probablemente se
        modifique en el futuro.
}

    DescriptorExtendido         : TVarRec unimplemented;
{
  DescriptorExtendido           : Para agregar caracteristicas adicionales
        cuando se requiera en forma simple.
}

CONSTRUCTOR Create; virtual;
{
  Constructor de clase fundamental
}

DESTRUCTOR  Destroy; override;
{
  DESTRUCTOR Destroy
        Destructor de clase
}

FUNCTION    PeticionSimilar             : CAFE_DatoExtendido; virtual;
{
  FUNCTION PeticionSimilar
        Intenta generar un dato muy parecido al actual,
        o con funcionalidad similar
  FUNCTION PeticionSimilar              : El dato similar
}

FUNCTION    AsimilarDescriptor          : TVarRec; virtual;
{
  FUNCTION AsimilarDescriptor
        Intenta generar una copia del descriptor para uso,
        probablemente en algun dato gemelo o parecido
        CUIDADO: futuras versiones probablemente no sirva
        la copia simple como esta implementada
  AsimilarDescriptor                    : El dato de DescriptorExtendido
}

                                  END;  { CLASS CAFE_DatoExtendido }

  CAFE_DatoNudillado            = PACKED CLASS ( CAFE_DatoExtendido )
{
  Clase cuyo objetivo es darle funcionamiento de funcion o macro
  a una casilla de Hoja de Calculo
  CAFE_HojaCalculoBase.SintacticaHoja[i][j] -> CAFE_DatoExtendido
  Pero CAFE_DatoExtendido no sirve de mucho...,
  Self es la primera descendencia util que deberia revisarse con
  IS o similar.
  Self, contiene basicamente informacion util,
  su capacidad de procesamiento radica en
  FuncionNudillado, y alguna Manejador que se pase de parametro,
  con HojaDefault identica a la actual.
  Para el usuario externo, le interesarian:
  Self.BanderaPeticionCalculo   : para controlar si quiere un recalculo
  Self.BanderaPeticionNudillar  : para pedir reinterpretacion
        si se sospecha de error
  Self.MacroParametro           : para describir las caracteristicas
  Self.CicloConteoMaximo        : para control de recursividad
}

    BanderaStandard             : Boolean;
{
  BanderaStandard               :
        En EJES.EXE en su primera version, se supone que todo deberia
  ser BanderaStandard = TRUE;  previsto para modificaciones futuras
}

    BanderaMacroFuncional       : Boolean;
{
  BanderaMacroFuncional         : Establece que el dato
        es una macro, es decir recibe parametros segun reglas Standard
}

    BanderaPeticionNudillar     : Boolean;
{
  BanderaPeticionNudillar       : Solicita interpretacion o
        reinterpretacion de dato en algun momento.
        El String se tomara
        de CAFE_HojaCalculoBase.VariantHoja[i][j] respectivo.
        Se supone que CAFE_HojaCalculoBase.SintacticaHoja[i][j] = Self
        Se activa automaticamente en muchas condiciones de error.
}

    BanderaPeticionCalculo      : Boolean;
{
  BanderaPeticionCalculo        : Solicita que el dato se calcule
        o recalcule.  Existen varias reglas para limitar la propagacion
        de datos.
        Cuando se solicita el valor de una casilla existen varias
        reglas a aplicar:
        A. Hay iniciativa?  Si hay iniciativa CicloSintactico = 0
                NO-> Si activa CasillaIniciativaHCGM y no es ciclico
                        entonces no se ejecuta y toma el valor
        B. BanderaPeticionCalculo = FALSE
                PeticionCalculoObligadoCVDH -> Si se recalculo
           NOTA: tiene prioridad ForzarRecalculoTodalCVDH y
           las reglas ciclicas modifican ligeramente las reglas
           anteriores.
        C. Caso contrario se recalcula
        NOTA : las reglas de ciclos cambian algo el esquema anterior
        La idea, tambies es que la hoja, revie al final de cada
        cierto ciclo esta bandera, y realiza el recalculo
        pertienente, etc...
}

    TipoReturn                  : Variant;
{
  TipoReturn                    : Contiene el resultado de la
        ultima evaluacion, en macros inclusive.
        Su funcion principal es reportar
        el tipo de resultado.
        Su valor se tomara cuando se impida propagacion del
        calculo a otras casillas, etc...
}

    FuncionNudillado            : CAFE_Nudo2Sintactico;
{
  FuncionNudillado              : Contiene el arbol sintactico
        correspondiente al String funcional o de macro
}

    MacroParametro              : CAFE_ConjuntoParametroBasico;
{
  MacroParametro                : Caracteristicas de la macro
        o funcion, como total de parametros, autorizacion
        de ciclo, etc...
}

  Protected
    MarcaCicloSintactico        : LongInt;
      // Para prevenir llamadas ciclicas
{
  MarcaCicloSintactico          : Cuando se realiza un calculo
        se genera un numero o CicloSintactico, que se
        escribe en las casillas utilizadas.  Esto
        sirve para control de ciclos y otros fines.
        El numero de CicloSintactico se escribe aqui
}

  Protected
    CicloConteo,
{
  CicloConteo                   : En un ciclo sintactico la
        primera vez que se ejecuta una casilla se asigna
        CicloConteo := CicloConteoMaximo,
        esto permite llevar una cuenta de recursividad,
        si esta modalidad se activa con CicloConteoHCGM y
        ActivarCicloHCGM
}

    CicloConteoMaximo           : Word;
{
  CicloConteoMaximo             : En la modalidad CicloConteoHCGM
        es el valor inicial de CicloConteo, en la recursividad.
        Cuenta regresiva y finalmente toma TipoReturn
        con o sin error si esta activa FinConteoErrorHCGM es error
        de tipo FUNCTION FALSE, caso contrario TRUE sin error
}

  Public
    NombreParametroUno,
{
  NombreParametroUno            : Contiene el nombre si existe,
        del primera parametro de Macro
}

    NombreParametroDos,
{
  NombreParametroDos            : Contiene el nombre si existe,
        del segundo parametro de Macro
}

    NombreParametroTres         : CAFE_CadenaSintactica;
{
  NombreParametroTres           : Contiene el nombre si existe,
        del tercer parametro de Macro
}

    ValorPruebaUno,
{
  ValorPruebaUno                : Asigna un valor de prueba al
        primer parametro de la macro,
        para aplicar cuando se requiera.  (cero por default)
}

    ValorPruebaDos,
{
  ValorPruebaDos                : Asigna un valor de prueba al
        segundo parametro de la macro,
        para aplicar cuando se requiera.  (cero por default)
}

    ValorPruebaTres             : Double;
{
  ValorPruebaTres               : Asigna un valor de prueba al
        tercer parametro de la macro,
        para aplicar cuando se requiera.  (cero por default)
}

CONSTRUCTOR Create; override;
{
  Constructor de clase fundamental
}

FUNCTION    PeticionSimilar             : CAFE_DatoExtendido; override;
{
  FUNCTION PeticionSimilar
        Intenta generar un dato muy parecido al actual,
        o con funcionalidad similar
        FuncionNudillado se copia como NIL,
        y se activan las banderas
        BanderaPeticionCalculo   a TRUE
        BanderaPeticionNudillado a TRUE
        Es decir la copia, requiere Reinterpretacion
        CUIDADO : Self.DescriptorExtendido se copia
        con AsimilarDescriptor que simplemente
        recurre a la copia simple
  FUNCTION PeticionSimilar              : El dato similar
}

  Strict
  Private
FUNCTION    Leer_CantidadParametros             : LongInt; virtual;

  Strict
  Private
PROCEDURE   Escribir_CantidadParametros
  (       TotPar                : LongInt                       ); virtual;

  Public
DESTRUCTOR  Destroy; override;
{
  DESTRUCTOR Destroy
        Destructor de clase
}

  Public
  Property
    CantidadParametros          : LongInt
                                  READ Leer_CantidadParametros
                                  WRITE Escribir_CantidadParametros;
{
  CantidadParametros            :
        De tratarse de una macro de vuelve la cantida de parametros
        solicitada, que se asume un numero fijo.  Si no es
        macro devuelve cero.
}

                                  END;  { CLASS CAFE_DatoNudillado }

  CAFE_Interprete2Sintactico    = Packed CLASS ( CAFE_InterpreteSintactico )
{
  Clase cuyo objetivo es la evaluacion de funcionales sencillas,
  de esta primera version de EJES.EXE, tambien contiene herramientas
  para inicializar, interpretar algunos identificadores, y
  otras herramientas de interpretacion de hoja de calculo
  La idea es que Self describe y evalua el funcional,
  pero el valor del parametro debe aportarse externamente.
}

//    { Campos de Herencia selectos }
//    NombreIdentificador         : ShortString;
//    ValorInterpretado           : Variant;
//    BanderaVariant,
//    BanderaSimple               : Boolean;
    TotalParametros             : Byte;
{
  TotalParametros               : Indica el total de parametros
        pertinente para algunas funciones
}

    ProfundidadSintactica       : Byte                          unimplemented;
{
  ProfundidadSintactica         : Previsto para el anidamiento
        de procedimientos y funciones.
}

    ClaveInterpretado           : LongInt;
{
  ClaveInterpretado             : Numero utilizado como sustituto
        del NombreIdentificador, u otros fines, para identificar
        el interprete.
}

    SiguienteIdentificador      : CAFE_Interprete2Sintactico;
{
  SiguienteIdentificador        : Los identificadores mas simples
        puden simplemente enlazarse en cadena, formando
        paquetes de los mismos
}

    DescriptorInterprete        : CAFE_ConjuntoTipoInterprete;
{
  DescriptorInterprete          : Conjunto de banderas, para darle
        versatilidad al interprete en multiples aplicaciones.
}

    ResultadoPrincipal,
{
  ResultadoPrincipal            : Para indicar el tipo de resultado
        esperado, cuando se trata de evaluar un funcional o similar
}

    ParametroUno,
{
  ParametroUno                  : Para indicar el tipo de valor
        solicitado en el parametro uno.  Puede asignar varNull
        cuando no se requiera.  El caso OverloadNITI, se maneja
        con varios interpretes.  En el DefaultNITI simplemente
        asigne el valor apropiado.
}

    ParametroDos,
{
  ParametroDos                  : Para indicar el tipo de valor
        solicitado en el parametro dos.  Puede asignar varNull
        cuando no se requiera.  El caso OverloadNITI, se maneja
        con varios interpretes.  En el DefaultNITI simplemente
        asigne el valor apropiado.
}

    ParametroTres               : SizeInt;
{
  ParametroTres                 : Para indicar el tipo de valor
        solicitado en el parametro tres.  Puede asignar varNull
        cuando no se requiera.  El caso OverloadNITI, se maneja
        con varios interpretes.  En el DefaultNITI simplemente
        asigne el valor apropiado.
}

    Parametrizacion             : CAFE_Interprete2Sintactico    unimplemented;
{
  Parametrizacion               : Previsto para complicar el
        identificador, i.e., asociar un registro con sus
        campos o aumentar el numero de parametros, etc...
}

CONSTRUCTOR Create; override;
{
  Constructor fundamental de la clase
}

CONSTRUCTOR Create
  ( CONST Nombre                : ShortString;
          NuevoValor            : Variant                       ); override;
{
  Constructor que permite asignar un nombre y un Nuevo Valor a la clase
  asume que se trata de un tipo VarNITI o sea modificable por el
  usuario.  Para declarar predefinidos mejor AnexarPredefinidoVariant.
}

PROCEDURE   VaciarDatos; virtual;
{
  Constructor para vaciar el interprete, incluyendo secuencias
  conectadas.  Simplemente asigna NIL.
}

PROCEDURE   EstablecerCasillaHojaDefault
  (       FilaAbsoluta          : Boolean;
          Fila                  : LongInt;
          ColumnaAbsoluta       : Boolean;
          Columna               : LongInt                               );
{
  PROCEDURE EstablecerCasillaHojaDefault
        Vacia Self y lo establece como interprete que hace referencia
        a una casilla de la HojaDefault,
        i.e.
        $A23+A2
        Tanto $A23 como A2 se declaran como String en el arbol sintactico
        y se les asigna un interprete de este tipo
        Caracteristicas :
        BanderaVariant es FALSE
        BanderaSimple  es TRUE
        DescriptorInterprete es
          [ ActivoNITI, CasillaHojaNITI, HojaDefaultNITI, NudilladoNITI ]
        y opcionalmente AbsolutoFilaNITI o AbsolutoColumnaNITI
        NombreIdentificador con $ y regla usual
        ValorInterpretado es un varArray
                  ValorInterpretado[ 1 ]        := Fila;
                  ValorInterpretado[ 2 ]        := Columna;
  FilaAbsoluta                  : Se refiere al $ usual en hoja de calculo,
        de copiado sin modificacion de Fila
  Fila                          : Numero de fila a partir de 0,
        La fila es el numero i.3. $A22, la fila es 22
  ColumnaAbsoluta               : Se refiere al $ usual en hoja de calculo,
        de copiado sin modificacion de columna
  Columna                       : Numero de columna a partir de 0,
        LA fila es la letra
  NOTA: casi no se revisan errores de rango ni otros, deberia
  hacerlo previamente
}

PROCEDURE   DefaultPredefinidos
  (       Manejador             : CAFE_InterfaceBasico;
          Quimico               : Boolean;
          Graficador            : Boolean       = FALSE         ); virtual;
{
  PROCEDURE DefaultPredefinidos
        Tiene la funcion de definir un paquete basico de funciones e
        identificadores, asociados en secuencia horizontal a partir
        de Self que corresponde al string nulo.
  Manejador                     : la version actual lo utiliza
        para traducciones y errores.
  Quimico                       : TRUE activa lista de identificadores
        utiles a gusto del autor del programa.  Utiliza reglas
        que no corresponde con el Standard.
  Graficador                    : TRUE desactiva algunos procesos
        para ahorra velocidad, probablemente no muy utiles
        en la programacion del graficador de EJES.EXE
}

FUNCTION    BusquedaNombreIdentificador
  ( CONST Nombre                : ShortString;
          Actual                : CAFE_Interprete2Sintactico    = NIL;
          BanderaActivo         : Boolean                       = TRUE
                                ) : CAFE_Interprete2Sintactico;
{
  FUNCTION BusquedaNombreIdentificador
        Busca un operador (debe incluir parentesis) o identificador
        a partir de Actual sin incluirlo, siguiendo la lista establecida
        en Actual.SiguienteIdentificador y sucesivos...
        NIL comienza en Self
  Nombre                        : La busqueda busca exactamente el
        mismo Nombre, llamadas sucesivas pueden servir
        para localizar operadores OverloadNITI
  Actual                        : Punto de partica no elegible.
        Utilice NIL para comenzar en Self
  BanderaActivo                 : TRUE exige la condicion ActivoNITI
        FALSE no la exige, esto es util en la activacion/desactivacion
  FUNCTION BusquedaNombreIdentificador  : devuelve el Interprete encontrado
        o NIL si no encuentra ninguno.
}

FUNCTION    EvaluarPredefinidoFuncionalSimple
  ( OUT   Msg                   : ShortString;
    OUT   ResultadoFuncional    : Variant;
    CONST Param1                : Variant;
    CONST Param2                : Variant;
    CONST Param3                : Variant;
          Manejador             : CAFE_InterfaceBasico;
          CicloSintactico       : LongInt               ) : Boolean; virtual;
{
  FUNCTION EvaluarPredefinidoFuncionalSimple
        Su objetivo es evaluar un FuncionalSimple en Self a partir
        de sus parametros.  Este funcional deberia estar
        asignado a Self en forma consistente y
        con su Self.ClaveInterpretado correcto.
        Evalua la mayoria de los predefinidos,
        inclusive funciones de arreglos, en tal caso
        el parametro varArray se pasa como un numero entero
        de clave para aplicar en
        i.e. varArray como entero en Param1
        CAFE_PaqueteListaRectangular[ Param1 ].ArregloDoubleSector
        contiene el arreglo respectivo, previamente creado.
        No evalua ciertos procesos como la integracion FORINT, ni
        identificadores, etc...
  Msg                           : auxiliar en caso FUNCTION FALSE
        para indicar pistas para localizar el error
  ResultadoFuncional            : devuelve el resultado de la
        funcion en caso de exito
  Param1                        : Contiene el primer parametro
        puede utilizar varNull si no se requiere
  Param2                        : Contiene el segundo parametro
        puede utilizar varNull si no se requiere
  Param3                        : Contiene el tercer parametro
        puede utilizar varNull si no se requiere
  FUNCTION EvaluarPredefinidoFuncionalSimple    : TRUE indica
        exito en el proceso, FALSE algun tipo de error,
        es probable que Msg contenga alguna pista
}

  Protected
PROCEDURE   AnexarPredefinidoVariant
  (     Nombre                  : ShortString;
        NuevoValor              : Variant                               );
{
  PROCEDURE AnexarPredefinidoVariant
        Util para anexar predefinidos.  No lo utilice para tipo VarNITI,
        unicamente ActivoNITI, PredefinidoNITI, ConstNITI identificadores.
        Un identificador simple, por lo regular no requerira ninguna
        correccion adicional, se agregaria al final de la lista
        siguiente Self.SiguienteIdentificador
  Nombre                        : Nombre del identificador a asignar
  NuevoValor                    : Valor a devolver, del tipo adecuado,
        admisible unicamente en esta version
        (varInteger, varByte, varBoolean, varDouble, varString)
}

  Protected
PROCEDURE   AnexarManejadorPrincipal
  (     NombreManejador         : ShortString;
        ControlID               : LongInt;
        BanderaSelf             : Boolean       = FALSE                 );
{
  PROCEDURE AnexarManejadorPrincipal
        Util para anexar manejadores principales.
        Es decir se utiliza para permitir
        el acceso como identificador de otras manejadores
        u hojas de calculo
  NombreManejador               : Nombre con que el usuario
        identificara como registro u hoja al dato
  ControlID                     : Clave interna para ubicar
        el Manejador se refiere al TStreamCollectionItem.ID respectivo
  BanderaSelf                   : si true agrega
        la bandera ManejadorSelfNITI, para indicar
        que el nombre indica a si mismo (en el interior de un manejador)
        O bien para indicar propiamente al indicar el identificador
        Self aplicar a Manejador
}

  Protected
PROCEDURE   AnexarPredefinidoFuncion
  (     Nombre                  : ShortString;
        ValorInicial            : Variant;
        P1, P2, P3              : SizeInt                               );
{
  PROCEDURE AnexarPredefinidoFuncion
        Util para anexar predefinidos.  No lo utilice para tipo VarNITI,
        unicamente ActivoNITI, PredefinidoNITI, ConstNITI, FuncionalNITI
        identificadores de operador basico.
        Un operador simple,
        por el momento Funcion no tendria capacidad de ejecucion,
        simplemente lo identifica.
  Nombre                        : Nombre del identificador a asignar
  ValorInicial                  : Indica un tipo de resultado,
        y un valor que podria ser util en algun proceso.
  P1                            : Tipo de parametro 1
  P2                            : Tipo de parametro 2
  P3                            : Tipo de parametro 3
  NOTA : PROCEDURE utiliza varNull para saber si el parametro
  existe o no, y asi asignar el total de parametros.
  Si un parametro no existe DEBE asignar varNull
}

  Private
FUNCTION    ReadUltimoLista                     : CAFE_Interprete2Sintactico;

  Public
DESTRUCTOR  Destroy; override;
{
  DESTRUCTOR Destroy
        Destructor de clase
}

  Public
  Property
    UltimoLista         : CAFE_Interprete2Sintactico READ ReadUltimoLista;
{
  UltimoLista           : devuelve el ultimo elemento de la
        lista a partir de Self, siguiente la secuencia segun
        Self.SiguienteIdentificador
}

                                  END;  { CLASS CAFE_Interprete2Sintactico }

TYPE
  CAFE_VariantesDescriptoresHoja                =
                ( ActivoCVDH, TodoCicloProhibidoCVDH, HojaAisladaCVDH,
                  PeticionCalculoObligadoCVDH, ForzarRecalculoTotalCVDH,
                  AlertaDominioCVDH, VerFuncionalCVDH,
                  VerValorPruebaCVDH, BloquearCasillasCVDH );
{
  CAFE_VariantesDescriptoresHoja                : Tipo ordenado
        para darle caracteristicas especiales a la hoja
        CVDH : ConjuntoVariantesDescriptoresHoja
  ActivoCVDH                    : Grupo y dato activo y con sentido.
        Se revisa al traducir la casilla, pues se supone
        que el usuario de pipa, recurrira casi siempre a este proceso.
  TodoCicloProhibidoCVDH        : Bandera prioritaria, para prohibir
        todo ciclo en una hoja.
  HojaAisladaCVDH               : Para prohibir las comunicaciones
        de la hoja con otros interpretes;  aunque se aplica
        SAVE de conjunto.
  PeticionCalculoObligadoCVDH   : Cuando se realiza un calculo
        exige la presencia de BanderaPeticionCalculo, de lo contrario
        intenta tomar valor.  Admite excepciones al activar ciclos.
        NOTA: No aplica en macros, pues se considera que
                una macro es de hecho una Peticion de Calcular
  ForzarRecalculoTotalCVDH      : Su objetivo es ordenar
        ocasionalmente el calculo completo de la Hoja, y
        tiene prioridad sobre PeticionCalculoObligadoCVDH,
        y tambien sobre CasillaIniciativaHCGM.  Pues se asume
        que el computador recorrera la hoja completa
        y generara la iniciativa en cada casilla que requiera
  AlertaDominioCVDH             : Bandera de existencia
        temporal para pasar mensajes de problemas
        de dominio en la evaluacion, el usuario no
        deberia utilizarla, ni consultarla.
        (Ver CAFE_BanderaAlertaDominio y AlertaDominioHCGM)
  VerFuncionalCVDH              : Solicitud de display de casillas,
        como funciones y no como resultado de las mismas
  VerValorPruebaCVDH            : Solicitud de display de casilla,
        como valor de prueba y no como macro estilo String
  BloquearCasillasCVDH          : Para impedir la escritura.
        Interfiere en la pipa.
}

  CAFE_ConjuntoVariantesDescriptoresHoja        =
                                SET OF CAFE_VariantesDescriptoresHoja;
{
  CAFE_ConjuntoVariantesDescriptoresHoja        : Conjunto para
        agrupar el tipo ordenado CAFE_VariantesDescriptoresHoja
}

CONST
  CAFE_DescriptoresDefaultHoja  = [ ActivoCVDH, TodoCicloProhibidoCVDH ];
{
  CAFE_DescriptoresDefaultHoja  : Descriptores a asignar en la
        inicializacion o similar de hoja
}

TYPE
  CAFE_RGBRec                   = PACKED RECORD
    Red                         : SmallInt;
    Green                       : SmallInt;
    Blue                        : SmallInt;
  END;  { RECORD CAFE_RGBRec }
{
  CAFE_RGBRec                   : Tipo RECORD para almacenar colores
        de tipo RGB, consiste en un metodo similar al de unit graph.
        Se utiliza CAFE_RGBRec, para evitar conflictos con otras
        unidades graficas, a este nivel.
}

CONST
  CAFE_RGBNegro                 : CAFE_RGBRec
                                = ( Red :   0; Green :   0; Blue :   0 );
{
  CAFE_RGBNegro                 : Para el color negro.  Puede servir
        para inicializar datos de color
}

TYPE
  CAFE_PFormatSettings          = ^TFormatSettings;
{
  CAFE_PFormatSettings          :
        Puntero a un tipo TFormatSettings, util en el formato de Display
}

  CAFE_ReferenciaItemFormatoCasilla    =
                CLASS OF CAFE_TCollectionItemFormatoCasilla;
{
  CAFE_ReferenciaItemFormatoCasilla             :
        referencia para la clase CAFE_TCollectionItemFormatoCasilla,
        util en varios procesos.
}

  CAFE_TCollectionItemFormatoCasilla   = CLASS ( TCollectionItem )
{
  Se trata de una clase ficticia, pues por el momento el programa,
  no es capaz de manejar interface grafica.
  Prevista para uso futuro.
}

  Protected
    NombreFormato                               : String;
{
  NombreFormato                 : Nombre para identificar el formato
        en algunos procesos.  Por ejemplo, en formatos
        definidos por el usuario.
}

    BanderaProteccionEscrituraItem,
{
  BanderaProteccionEscrituraItem                : Bandera para impedir
        la escritura en la casilla
}

    BanderaVisibleHoja,
{
  BanderaVisibleHoja            : Para volver
        invisibles casillas.  Se trata del Display.
}

    BanderaVisibleImpresionItem,
{
  BanderaVisibleImpresionItem   : Para volver
        invisibles las casillas en la impresion
}

    BanderaFormatoBorrableUso                   : Boolean;
{
  BanderaFormatoBorrableUso     : Para indicar
        que el formato deberia de borrase, en cuanto se detecte
        que no se utilice.
}

    ColorLetra                                  : CAFE_RGBRec;
{
  ColorLetra                    : Para indicar color de letra en casilla
}

    ColorFondo                                  : CAFE_RGBRec;
{
  ColorFondo                    : Para indicar el color de la casilla
}

    ParametroReal1                              : Single;
{
  ParametroReal1                : Uso diverso, relacionado con datos
        ajustables como fraccion de unidad.  i.e. tamano de casilla.
        Probablemente su uso sea: tamano de letra en casilla,
        tamano de columna o fila, en descriptores de columna o fila.
}

    StringFormato                               : String;
{
  StringFormato                 : String para aplicar formato
        en la casilla indicada.  Probablemente el String, pertenezca
        a alguna lista de opciones.
}

    EnterosDescriptores                         : TByteDynArray;
{
  EnterosDescriptores           : El String Formato, probablemente
        requiere descriptores
}

    ConjuntoFormato                             : TSysCharSet;
{
  ConjuntoFormato               : Conjunto de selectores adicionales
        de Display.  Aqui se indica bold, italica, tipo de letra, etc...
}

  Protected
    MoldeGeneradorItemFormato   : CAFE_ReferenciaItemFormatoCasilla;
{
  MoldeGeneradorItemFormato     : Hace las veces de ClassType,
        probablemente se elimine en el futuro.
}

  Public
CONSTRUCTOR Create
  (       ACollection           : TCollection                   ); override;
{
  Herencias de TStreamCollectionItem nunca deberian crearse en forma
  independiente (ver Manual Classes)
}

FUNCTION    PeticionItemFormatoSimilar
                                : CAFE_TCollectionItemFormatoCasilla; virtual;
{
  FUNCTION PeticionItemFormatoSimilar
        En este virtual la copia generada es identica en lo que a
        campos se refiere.
  FUNCTION PeticionItemFormatoSimilar           : devuelve una copia
        en RAM identica en valores de campos a la actual.
}

DESTRUCTOR  Destroy; override;
{
  Destructor de clase de la unidad
}

FUNCTION    ObtenerTFormatSettings      : CAFE_PFormatSettings; virtual;
{
  FUNCTION  ObtenerTFormatSettings              :
        Permite obtener un Custom TFormatSettings a pasar en
        format.
        CUIDADO: Es posible que se devuelva un NIL, y en tal caso
        no deberia enviarse a Format
}

FUNCTION    AplicarFormatFloat
  (       ValorFloat            : Double                ) : ShortString;
{
  FUNCTION ApicarFormatFloat
        Aplica a ValorFloat el StringFormato segun Format,
        toma en cuenta ObtenerTFormatSettings si aplica
        (se llama y si devuelve NIL no aplica),
        y los valores en EnterosDescriptores
  ValorFloat                    : Valor Double al aplicar el formato.
  FUNCTION AplicarFormatFloat           : devuelve el String luego del format.
        NOTA: errores seguramente se ignoraran y simplemente se llama
                FlotaToStr corriente
}

FUNCTION    CompatibleFormat
  ( CONST ValorVariant          : Variant               ) : Boolean; virtual;
{
  FUNCTION CompatibleFormat
        El objetivo es que en el futuro FUNCTION determine si
        el ItemFormat actual es compatible con ValorVariant,
        en esta version siempre devuelve TRUE.
  ValorVariant                  : Valor variant a determinar compatibilidad
  FUNCTION CompatibleFormat             : TRUE compatible FALSE no lo es.
}

  Strict
  Private
FUNCTION    Read_ProteccionEscritura                            : Boolean;

  Strict
  Private
PROCEDURE   Write_ProteccionEscritura
  (       NuevoBoolean          : Boolean                               );

  Public
  Property
    ProteccionEscritura         : Boolean
                                  READ  Read_ProteccionEscritura
                                  WRITE Write_ProteccionEscritura;
{
  ProteccionEscritura           : Indica si la casilla tiene proteccion
        de escritura.  El formato si puede afectarse.  Indica TRUE,
        tanto si la proteccion proviene del interior del tipo,
        o de una proteccion general de hoja.
}

                                  END;  { CLASS CAFE_TCollectionItemSave }

  CAFE_TCollectionUndo          = CLASS ( TOwnedCollection )
{
  Clase para relizar operaciones UNDO en un Manejador,
  en esta version solo aplica a casillas de Hojas de Calculo.
  Internamente contiene una lista de copias de seguridad de hojas.
  Estas copias, probablemente no esten interpretadas pues
  la mayoria no se utilizaran del todo.
  La idea:
  Cada vez que se le solicite se agrega una hoja a la lista con
  Self.CopiaActualHojaCalculo, la copia se agrega al FINAL.
  Si es necesario se borran elementos en exceso al inicio.
  Self.UndoHojaCalculo(Nivel)
  Restituye como default la copia en Nivel MOD Self.Count,
  destruyendo la actual
  sin precauciones, y la lista UNDO no se modifica.
  Sugerencia, para aplicar un undo:
        Self.CopiaActualHojaCalculo
        Self.UndoHojaCalculo(Self.Count-2)
}

  Protected
    MaximoNivelUndo             : LongInt;
{
  MaximoNivelUndo               :
        Valor maximo de copias de seguridad a permitir en
        el Manejador actual.  Se utiliza la variable global
        CAFE_MaximoNivelUndoHojaCalculo para inicializarlo.
}


  Public
CONSTRUCTOR Create
  (       AOwner        : TPersistent;
          AItemClass    : TCollectionItemClass                  ); virtual;
{
  Metodo que inicializa el objeto a la manera de TCollection.
  MaximoNivelUndo se establece en CAFE_MaximoNivelUndoHojaCalculo
}

PROCEDURE   CopiaActualHojaCalculo;
{
  PROCEDURE CopiaActualHojaCalculo
        Coloca una copia no interpretada de HojaDefault del manejador
        propietario, en la Collection al FINAL.  Probablemente
        se destruyan elementos viejos de la lista Undo.
}

PROCEDURE   UndoHojaCalculo
  (       NivelUndo     : LongInt                                       );
{
  PROCEDURE UndoHojaCalculo
        Ubica la copia undo en NivelUndo MOD Self.Count de la lista,
        en HojaDefault del manejador propietario.
  NivelUndo             : Numero a partir de cero, de hoja a reestablecer
        de la coleccion Undo.
}

PROCEDURE   AjustarMaximoNivelUndo;
{
  PROCEDURE AjustarMaximoNivelUndo
        Probablemente el usuario no deba utilizarlo nunca.
        Se llama cada vez que se requiere verificar que no se
        supera el tamano de lista permitido.  Destruyendo las
        copias excesivas, comenzando por las de mayor antiguedad.
}

PROCEDURE   ClearUndo; virtual;
{
  PROCEDURE ClearUndo
        Sustituye al Clear para ser utilizado por esta TCollection
}

  Strict
  Private
PROCEDURE   Escribir_NivelUndo
  (       NuevoNivel    : LongInt                                       );

  Public
DESTRUCTOR  Destroy; override;
{
  Destructor basico de la clase
}

  Public
  Property
    NivelUndo                   : LongInt
                                  READ MaximoNivelUndo
                                  WRITE Escribir_NivelUndo;
{
  NivelUndo                     : propiedad relacionada
        con MaximoNivelUndo, devuelve su valor o lo modifica
        llamando a AjustarMaximoNivelUndo si necesario.
}

                                  END;  { CLASS CAFE_TCollectionUndo }

  CAFE_ReferenciaTCollectionFormatoCasilla              =
                CLASS OF CAFE_TCollectionFormatoCasilla;

  CAFE_TCollectionFormatoCasilla       = CLASS ( TOwnedCollection )
{
  Clase ficticia para manejar lista de formatos de casilla,
  se considera ficticia pues todavia no se ha implementado mucha
  de su funcionalidad.
}

  Private
    MoldeGeneradorFormato       : CAFE_ReferenciaTCollectionFormatoCasilla;
{
  MoldeGeneradorFormato         : Hace las veces de ClassType, probablemente
        se elimine en el futuro cercano
}

  Public
CONSTRUCTOR Create
  (       AOwner                : TPersistent                   ); virtual;
{
  Constructor de clase.
}

FUNCTION    PeticionFormatoSimilar
                                : CAFE_TCollectionFormatoCasilla; virtual;
{
  FUNCTION PeticionFormatoSimilar
        Realiza una copia similar a Self y la devuelve en FUNCTION
  FUNCTION PeticionFormatoSimilar       : devuelve una clase
        similar al actual
}

FUNCTION    BuscarNombreFormato
  ( CONST NombreBuscado         : String                                )
                                        : CAFE_TCollectionItemFormatoCasilla;
{
  FUNCTION BuscarNombreFormato
        Se supone que el nombre de formato deberia ser unico.  Busca
        en la lista un formato con dicho NombreFormato o devuelve NIL
        si no lo encuentra
  NombreBuscado                 : Nombre de formato a buscar en lista
  FUNCTION BuscarNombreFormato  : Devuelve el item solicitada o NIL
        si no encuentra ninguno
}

FUNCTION    GenerarNuevoNombreFormato                           : String;
{
  GenerarNuevoNombreFormato     : Su objetivo es simplemente generar
        un nombre de formato que se pueda asegurar que es unico en
        lista.  Se supone que los nombres son de poca utilidad;
        asi que el nombre generado es simplemente F seguido
        de un numero.
}

DESTRUCTOR  Destroy; override;
{
  Destructor principal de clase
}

  END;  { CLASS CAFE_TCollectionFormatoCasilla }

TYPE
  CAFE_ReferenciaHojaCalculo    = CLASS OF CAFE_HojaCalculoBase;
{
  CAFE_ReferenciaHojaCalculo    : Clase de referencia de
                                        CAFE_HojaCalculoBase
}

  CAFE_HojaCalculoBase          = CLASS ( TStreamCollectionItem )
{
  Clase principal de informacion de Hoja de Calculo.
  NOTA: la hoja no es requisito para la funcionalidad de CAFE_Ej4,
  Sin embargo, EJES.EXE esta orientado a Hoja de Calculo
  Fila y Columna se numeran a partir de cero.
  i.e. A1 es Fila 0 y Columna 0
       C8 es Fila 7 y Columna 2
       F2 es Fila 1 y Columna 5
}

  Protected
    FormatosDefinidosCasilla    : CAFE_TCollectionFormatoCasilla;
{
  FormatosDefinidosCasilla      : Contiene la lista de formatos
        definidos para la hoja
}

  Protected
    FormatoFila                 : ARRAY OF
                         CAFE_TCollectionItemFormatoCasilla unimplemented;
{
  FormatoFila                   : previsto para
        dar caracteristicas esteticas a la fila
        en caso de conflicto, la prioridad de mayor a menor
        es FormatoHoja --> FormatoColumna --> FormatoFila
        Se supone que deberian evitarse los conflictos con
        asignacion consistente
}

  Protected
    FormatoColumna              : ARRAY OF
                         CAFE_TCollectionItemFormatoCasilla unimplemented;
{
  FormatoColumna                : previsto para
        dar caracteristicas esteticas a la columna
        en caso de conflicto, la prioridad de mayor a menor
        es FormatoHoja --> FormatoColumna --> FormatoFila
        Se supone que deberian evitarse los conflictos
}

  Protected
    FormatoHoja                 : ARRAY OF
                ARRAY OF CAFE_TCollectionItemFormatoCasilla unimplemented;
{
  FormatoHoja                   : previsto para
        dar caracteristicas esteticas al dato
        EJES.EXE reserva el espacio
        con NIL, pero por el momento su informacion
        es inutil
}

    SintacticaHoja              : ARRAY OF ARRAY OF CAFE_DatoExtendido;
{
  SintacticaHoja                : utilizado en la interpretacion
        "Util" del dato, es decir para generar funciones,
        macros o similar
}

    VariantHoja                 : ARRAY OF ARRAY OF Variant;
{
  VariantHoja                   : Contiene el dato, en el caso
        de funciones o similar, contiene el String que
        genera dicha funcion
}

  Public
    FilasEnHoja,
{
  FilasEnHoja                   : Numero de filas en la Hoja
}

    ColumnasEnHoja              : LongInt;
{
  ColumnasEnHoja                : Numero de columnas en la Hoja
}

    DescriptoresHoja            : CAFE_ConjuntoVariantesDescriptoresHoja;
{
  DescritoresHoja               : Conjunto para dar caracteristicas
        especiales a la hoja, al menor activar ActivoCVDH
}

  Protected
    MoldeGeneradorHoja          : CAFE_ReferenciaHojaCalculo deprecated;
{
  MoldeGeneradorHoja            : Referencia de funcionalidad similar
        a ClassType
}

  Public
CONSTRUCTOR Create
  (       ACollection           : TCollection                   ); override;
{
  CONSTRUCTOR Mejor eliminar su uso
        y programar una nueva version del TStreamCollection.ADD con
        parametros
        TStreamCollection.Add( Filas, Columnas )
}

  Public
CONSTRUCTOR Create
  (       ACollection           : TStreamCollection;
          Filas, Columnas       : LongInt                       ); virtual;
{
  Constructor fundamental de Hoja de calculo
  En CAFE_Ej4 no se asocia con ninguna colecction particular, y
  se puede pasar un NIL
  Esta previsto, para operaciones UNDO
}

FUNCTION    PeticionHojaSimilar         : CAFE_HojaCalculoBase; virtual;
{
  FUNCTION PeticionHojaSimilar
        Genera Una hoja de calculo similar a Self.
        Las funciones y macros no se interpretan.
        Este algoritmo puede ser util en operaciones tipo UNDO.
        Se asigna TRUE a las BanderaPeticionNudillar,
        BanderaPeticionCalculo, NIL a FuncionNudillado,
        y para la visualizacion rapida podria
        utilizarse TipoReturn de CAFE_DatoNudillado que se
        copia igual.
  FUNCTION PeticionHojaSimilar          : Una copia similar a Self
        (Ver Arriba) diferencias
}

FUNCTION    PeticionHojaSimilar
  (       NuevoTamanoFila       : LongInt;
          NuevoTamanoColumna    : LongInt       ) : CAFE_HojaCalculoBase;
                                                virtual;
{
  FUNCTION PeticionHojaSimilar
        Genera Una hoja de calculo similar a Self.
        Las funciones y macros no se interpretan.
        Este algoritmo puede ser util en operaciones tipo UNDO.
        Se asigna TRUE a las BanderaPeticionNudillar,
        BanderaPeticionCalculo, NIL a FuncionNudillado,
        y para la visualizacion rapida podria
        utilizarse TipoReturn de CAFE_DatoNudillado que se
        copia igual.
        El cambio de tamano se hace casi sin precauciones,
        asi que simplemente se perderan los datos
        que se pierdan, o se agregaran casillas
        vacias
  NuevoTamanoFila               : Nuevo tamano fila a solicitar para la hoja
  NuevoTamanoColumna            : Nuevo tamano columna a solicitar en hoja
  FUNCTION PeticionHojaSimilar          : Una copia similar a Self
        (Ver Arriba) diferencias
}

FUNCTION    IdentificadorValidoCasilla
  ( CONST Nombre                : ShortString;
    OUT   FilaAbsoluta          : Boolean;
    OUT   Fila                  : LongInt;
    OUT   ColumnaAbsoluta       : Boolean;
    OUT   Columna               : LongInt                       ) : Boolean;
{
  FUNCTION IdentificadorValidoCasilla
        Determina si Nombre corresponde o no a un identificador
        valido de casilla para Self, tomando en cuenta
        su estado actual.
        i.e. $AB13, B3, etc...
  Nombre                        : Debe estar en mayusculas y
        corresponder a un nombre o no de casilla de Hoja de Calculo
  FilaAbsoluta                  : Indica la condicion de dolar para
        la fila (es decir el numero)
  Fila                          : Indica la fila a que hace
        referencia el nombre (el numero)
        i.e. $AB13 es Fila 12
  ColumnaAbsoluta               : Indica la condicion de dolar para
        la columna (es decir la letra)
  Columna                       : Indica la columna a que hace
        referencia el nombre (la letra)
        i.e. $D4 es Columna 3
  FUNCTION IdentificadorValidoCasilla   : devuelve TRUE para indicar
        que si es un identificador valido, FALSE en caso contrario
        NOTA: de entrada no debe tener blancos, ni parentesis, y
        en mayusculas.
}

FUNCTION    CasillaNull
  (       Fila, Columna         : LongInt                       ) : Boolean;
{
  FUNCTION CasillaNull
        Determina si una casilla tiene asignado el valor varNull
        VariantHoja[ Fila ][ Columna ] = varNull
        Esto probablemente indica casilla sin usar o borrada
        En aplicacion matematica representa un cero varDouble,
        podrian surgir inconsistencias de tipo debido a ello,
        utilice en tal caso conversiones i.e. Trunc( A1 ),
        aunque la mayoria de las veces sera innecesario
  Fila                          : Numero de fila a consultar
  Columna                       : Numero de columna a consultar
  FUNCTION CasillaNull          : TRUE indica que el dato es varNull
                                  FALSE caso contrario
}

FUNCTION    CompatibilidadSimple
  (       Fila, Columna         : LongInt;
          TypeVariant           : SizeInt               ) : Boolean; virtual;
{
  FUNCTION CompatibilidadSimple
        Para indicar si el dato reportado por la casilla,
        podria ser compatible con TypeVariant.
        Este no es el algoritmo utilizado para la interpretacion y
        evaluacion, pero podria ser util en alguna ocasion
        Las Macros se consideran siempre incompatibles en esta
        FUNCTION, pues se consideran algoritmos y no valores
        En cuanto a las funciones tipo SIN(A1+A3), si pueden
        ser compatibles
  Fila                          : Indica la fila a buscar
  Columna                       : Indica la columna a buscar
  TypeVariant                   : Es el tipo requerido por el usuario
  FUNCTION CompatibilidadSimple : TRUE  si es compatible
                                  FALSE si no lo es
}

FUNCTION    LecturaTipo
  (       Fila, Columna         : LongInt;
    OUT   BanderaNudillado      : Boolean;
    OUT   BanderaMacro          : Boolean;
    OUT   CaracterMacro         : CAFE_ConjuntoParametroBasico  ) : SizeInt;
                                        virtual;
{
  FUNCTION LecturaTipo
        Utilizado para obtener el tipo de dato en una casilla,
        que se reporta en FUNCTION,
        en el caso de macros y funciones
        FUNCTION = CAFE_TipoVariante( TipoReturn )
        Para diferenciarlas se utilizan los otros parametros de salida
        FUNCTION = varDouble para cualquier cosa no funcional
                        compatible con Double
        Esto por seguridad, pues se considera que los valores
        en las casillas cambian constantemente
        Esta regla podria obligar a cambios de tipo innecesarios
  Fila                          : Se refiere a la fila a buscar
  Columna                       : Se refiere a la columna a buscar
  BanderaNudillado              : Indica que es funcional (puede ser macro)
  BanderaMacro                  : Indica que es macro
  CaracterMacro                 : En el caso funcional o macro
        devuelve el conjunto de parametros MacroParametro
  FUNCTION LecturaTipo          : Devuelve el tipo requerido
        con la regla de que intentara
        reportar varDouble si es compatible
}

FUNCTION    LecturaTipo
  (       Fila, Columna         : LongInt;
    OUT   BanderaNudillado      : Boolean;
    OUT   BanderaMacro          : Boolean;
    OUT   CaracterMacro         : CAFE_ConjuntoParametroBasico;
    OUT   DatoVariante          : Variant;
    OUT   DatoResultado         : Variant                       ) : SizeInt;
{
  FUNCTION LecturaTipo
        Utilizado para obtener el tipo de dato en una casilla,
        que se reporta en FUNCTION,
        en el caso de macros y funciones
        FUNCTION = CAFE_TipoVariante( TipoReturn )
        Para diferenciarlas se utilizan los otros parametros de salida
        FUNCTION = varDouble para cualquier cosa no funcional
                        compatible con Double
        Esto por seguridad, pues se considera que los valores
        en las casillas cambian constantemente
        Esta regla podria obligar a cambios de tipo innecesarios
  Fila                          : Se refiere a la fila a buscar
  Columna                       : Se refiere a la columna a buscar
  BanderaNudillado              : Indica que es funcional (puede ser macro)
  BanderaMacro                  : Indica que es macro
  CaracterMacro                 : En el caso funcional o macro
        devuelve el conjunto de parametros MacroParametro
  DatoVariante                  : Retorna el dato en VariantHoja
  DatoResultado                 : Retorna Null o TipoReturn si aplica
        como funcional o macro
  FUNCTION LecturaTipo          : Devuelve el tipo requerido
        con la regla de que intentara reportar varDouble si
        es compatible
}

PROCEDURE   ModificarMacroParametro
  (       Fila, Columna         : LongInt;
          AgregarCaracterMacro,
          RestarCaracterMacro   : CAFE_ConjuntoParametroBasico;
          ContadorMaximo        : LongInt               = -1            );
{
  PROCEDURE ModificarMacroParametro
        Modifica por suma y resta de conjunto
        SintacticaHoja[ Fila ][ Columna ].MacroParametro si existe
        Si no aplica por alguna razon, no hay problema
        La sustitucion es
        MacroParametro := ( MacroParametro+AgregarCaracterMacro )
                                        -RestarCaracterMacro
        El orden es importante
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  AgregarCaracterMacro          : Paquete de banderas a agregar
        a MacroParametro cuando aplique
  RestarCaracterMacro           : Paquete de banderas a restar
        a MacroParametro cuando aplique
}

PROCEDURE   EstablecerMacroParametro
  (       Fila, Columna         : LongInt;
          CaracterMacro         : CAFE_ConjuntoParametroBasico;
          ContadorMaximo        : LongInt                               );
{
  PROCEDURE EstablecerMacroParametro
        Asigna sobreescribiendo y borrando
        CaracterMacro y CicloConteoMaximo
        en SintacticaHoja[ Fila ][ Columna ], cuando sea posible;
        sin error si no se logra por inexistencia del dato apropiado
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  CaracterMacro                 : Valor a asignar a CaracterMacro
        en SintacticaHoja[ Fila ][ Columna ] cuando aplique
  ContadorMaximo                : Valor a asignar a CicloConteoMaximo
        en SintacticaHoja[ Fila ][ Columna ] cuando aplique.
        Cuando no se llama a PROCEDURE
        se asigna CAFE_CicloConteoMaximoDefault aunque no se utilice
}

FUNCTION    LiberarCasilla
  (       Fila, Columna         : LongInt               ) : Boolean; virtual;
{
  FUNCTION LiberarCasilla
        Destruye SintacticaHoja[ Fila ][ Columna ]
        y FormatoHoja[ Fila ][ Columna ]
        y asigna
        VariantHoja[ Fila ][ Columna ]  = Null
        CUIDADO: No se ha verificado el buen funcionamiento
        de la destruccion de FormatoHoja unimplemented;
        probablemente sea buena idea definir un override para FUNCTION
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  FUNCTION LiberarCasilla       : TRUE  para indicar exito en proceso
                                  FALSE para indicar fracaso
}

FUNCTION    AnularCasilla
  (       Fila, Columna         : LongInt               ) : Boolean; virtual;
        // Sin perdida de formato estetico
{
  FUNCTION AnularCasilla
        Funcion de anular la casilla, sin perdida de formato
        SintacticaHoja[ Fila ][ Columna ]       := NIL
        VariantHoja[ Fila ][ Columna ]          := Null
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  FUNCTION AnularCasilla        : TRUE indica exito, FALSE algun error
}

FUNCTION    EscribirReal
  (       Fila, Columna         : LongInt;
          ValorReal             : Real                          ) : Boolean;
{
  FUNCTION EscribirReal
        Luego de anular la casilla, asigna ValorReal a
        VariantHoja[ Fila ][ Columna ]          := ValorReal
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  ValorReal                     : Numero a asignar a la casilla
  FUNCTION EscribirReal         : TRUE si exito, FALSE si fracaso
}

FUNCTION    EscribirEntero
  (       Fila, Columna         : LongInt;
          ValorEntero           : LongInt                       ) : Boolean;
{
  FUNCTION EscribirEntero
        Luego de anular la casilla, asigna ValorEntero a
        VariantHoja[ Fila ][ Columna ]          := ValorEntero
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  ValorEntero                   : Numero a asignar a la casilla
  FUNCTION EscribirEntero       : TRUE si exito, FALSE si fracaso
}

FUNCTION    EscribirDate
  (       Fila, Columna         : LongInt;
          ValorFecha            : TDateTime                     ) : Boolean;
{
  FUNCTION EscribirDate
        Luego de anular la casilla, asigna ValorFecha a
        VariantHoja[ Fila ][ Columna ]          := ValorFecha como varDate
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  ValorFecha                    : Fecha a asignar a la casilla
  FUNCTION EscribirEntero       : TRUE si exito, FALSE si fracaso
}

FUNCTION    EscribirString
  (       Fila, Columna         : LongInt;
    CONST Msg                   : ShortString                   ) : Boolean;
{
  FUNCTION EscribirString
        Luego de anular la casilla, asigna Msg a
        VariantHoja[ Fila ][ Columna ]          := Msg
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  Msg                           : ShortString a asignar a la casilla
  FUNCTION EscribirString       : TRUE si exito, FALSE si fracaso
}

FUNCTION    EscribirBoolean
  (       Fila, Columna         : LongInt;
          ValorBoolean          : Boolean                       ) : Boolean;
{
  FUNCTION EscribirBoolean
        Luego de anular la casilla, asigna ValorBoolean a
        VariantHoja[ Fila ][ Columna ]          := ValorBoolean
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  ValorBoolean                  : Numero a asignar a la casilla
  FUNCTION EscribirBoolean      : TRUE si exito, FALSE si fracaso
}

FUNCTION    EscribirFuncionSimple
  (       Fila, Columna         : LongInt;
    CONST FuncionLiteral        : ShortString;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          BanderaPendiente      : Boolean       = FALSE         ) : Boolean;
                                        virtual;
{
  FUNCTION EscribirFuncionSimple
        Escribe en la hoja de calculo, luego de anular la casilla,
        el ShortString
        VariantHoja[ Fila ][ Columna ]  := FuncionLiteral
        Ademas procede a nudillar e interpretar, y quiza intente
        una evaluacion no segura preliminar
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  FuncionLiteral                : Funcion a insertar en la hoja
        i.e. 'sum( A1:A3 )/$B$12*LaplaceInversa( 0.8 )'
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  BanderaPendiente              : si FALSE intenta interpretar,
        si TRUE no interpreta y activa
        BanderaPeticionNudillar y BanderaPeticionCalculo
  FUNCTION EscribirFuncionSimple                : devuelve TRUE
        para indicar exito en el proceso, y FALSE fracaso.
        Podria ser util consultar CAFE_IntentoInfructuosoSintactico
}

FUNCTION    EscribirMacroSimple
  (       Fila, Columna         : LongInt;
    CONST MacroLiteral          : ShortString;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
    CONST NomParam1             : ShortString;
          Valor1                : Double;
    CONST NomParam2             : ShortString   = '';
          Valor2                : Double        = 0.0;
    CONST NomParam3             : ShortString   = '';
          Valor3                : Double        = 0.0;
          BanderaPendiente      : Boolean       = FALSE         ) : Boolean;
{
  FUNCTION EscribirMacroSimple
        Escribe en la hoja de calculo, luego de anular la casilla,
        el ShortString
        VariantHoja[ Fila ][ Columna ]  := MacroLiteral
        Ademas procede a nudillar e interpretar, y quiza intente
        una evaluacion no segura preliminar con Valores de prueba
        de la macro.  Estos valores son importantes,
        pues se utilizaran para investigacion de coherencia, y
        otros fines.
        Las macros son siempre de salida real, y admiten
        enter uno y tres parametros.
        CUIDADO : FUNCTION determina el numero de parametros
        determinando los Nombres de parametros que no sean ''
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  MacroLiteral                  : Macro a insertar en la hoja
        i.e. con X y Y de parametros
        'FORINT( Xü, X, 0, Y )'
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  NomParam1                     : El nombre del primer parametro
  Valor1                        : Valor1, sera el valor de prueba
        para NomParam1, cuando se requiera.
        Tomar en cuenta que el algoritmo asigna TipoReturn como
        Valor1, casi al inicio del proceso.
        Este sera el valor anotado en caso de error.
  NomParam2                     : optativo para dar nombre a
        un segundo parametro
  Valor2                        : optativo para asignar un
        valor de prueba a NomParam2
  NomParam3                     : optativo para dar nombre a
        un segundo parametro
  Valor3                        : optativo para asignar un
        valor de prueba a NomParam3
  BanderaPendiente              : si FALSE intenta interpretar,
        si TRUE no interpreta y activa
        BanderaPeticionNudillar y BanderaPeticionCalculo
  FUNCTION EscribirMacroSimple                  : devuelve TRUE
        para indicar exito en el proceso, y FALSE fracaso.
        Podria ser util consultar CAFE_IntentoInfructuosoSintactico
}

FUNCTION    CopiarCasilla
  (       Fila, Columna                 : LongInt;
          NuevaFila, NuevaColumna       : LongInt;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          BanderaPendiente      : Boolean       = FALSE;
          BanderaForzarCopia    : Boolean       = FALSE;
          FilaProtegida         : LongInt       = 0;
          ColumnaProtegida      : LongInt       = 0;
          DolarIgnorar          : Boolean       = FALSE;
          BanderaSuperposicion  : Boolean       = FALSE ) : Boolean; virtual;
{
  FUNCTION CopiarCasilla
        Su objetivo es copiar el contenido en (Fila,Columna) hacia
        (NuevaFila,NuevaColumna) siguiendo las reglas usuales
        de una hoja de calculos.  Algunos comentarios:
        A.  Los nombres de macros que hacen referencia a
        posiciones de casilla, se copian sin cambio;
        en esta version de EJES.EXE es admisible
        el dolar, pero es indiferente
        B.  En copias de casillas corrientes, el dolar si funciona
        como usual.
        C.  $FILA, y $COLUMNA, se copian con el desplazamiento adecuado
        i.e.
        'CasillaInversa(A1:C3,$COLUMNA+1,$FILA+1)'
        al copiarse en cada casilla respectiva
        genera la matriz inversa total
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  NuevaFila                     : Nueva fila para la copia
  NuevaColumna                  : Nueva columna para la copia
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  BanderaPendiente              : si FALSE intenta interpretar,
        si TRUE no interpreta y activa
        BanderaPeticionNudillar y BanderaPeticionCalculo
  FilaProtegida                 : Para procesos de borrado e insercion,
        algunas filas no sufren cambio.
        FilaReferencia < FilaProtegida no se modifica.
        Fila < FilaProtegida no se mueve pero sufre cambio interno,
        en tal caso se permite NuevaFila negativa.
        ADVERTENCIA: unicamente debe proteger la fila o la columna.
        Ambas resultados impredecibles.
  ColumnaProtegida              : Para procesos de borrado e insercion,
        algunas filas no sufren cambio.
        ColumnaReferencia < ColumnaProtegida no se modifica.
        Columna < ColumnaProtegida no se mueve pero sufre cambio interno,
        en tal caso se permitido NuevaColumna negativa.
        ADVERTENCIA: unicamente debe proteger la fila o la columna.
        Ambar resultados impredecibles.
  DolarIgnorar                  : En los procesos de eliminacion
        y de insertar Filas y Columnas, el signo dolar se ignora.
  BanderaSuperposicion          : Las variables $Columna y $Fila
        se modifican unicamente cuando existe superposicion
        de la zona de copia
  FUNCTION CopiarCasilla        : TRUE si exito y FALSE si fracaso
  NOTA  : se pierde el contenido de destino, la copia
  en origen y destino identico no hace nada con FUNCTION TRUE
}

FUNCTION    LiberarTodaCasilla                            : Boolean; virtual;
{
  FUNCTION LiberarTodaCasilla
        Recorre la hoja completa liberando toda la hoja,
        con el formato sus definiciones.
  FUNCTION LiberarTodaCasilla   : TRUE indica exito en el proceso
}

FUNCTION    LeerCasilla
  ( OUT   MyRec                 : CAFE_DatoExtendido;
          Fila, Columna         : LongInt                       ) : Variant;
{
  FUNCTION LeerCasilla
        Devuelve el contenido en VariantHoja[ Fila ][ Columna ],
        ademas MyRec    := SintacticaHoja[ Fila ][ Columna ]
  MyRec                         : Para devolver el contenido
        para la casilla de SintacticaHoja
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  FUNCTION LeerCasilla          : lee el variante asignado
        (recordar que es ShortString para funcionales y macros)
}

FUNCTION    EscribirCasilla
  ( CONST MyVariant             : Variant;
    CONST MyRec                 : CAFE_DatoExtendido;
          Fila, Columna         : LongInt               ) : Boolean; virtual;
{
  FUNCTION EscribirCasilla
        Escribe por asignacion simple (destruye formato)
        VariantHoja[ Fila ][ Columna ]          := Variant
        SintacticaHoja[ Fila ][ Columna ]       := MyRec
        FormatoHoja[ Fila ][ Columna ]          := NIL
        Aplica primero un LiberarCasilla (consultar)
  MyVariant                     : Nuevo variante a asignar a la casilla
  MyRec                         : Nuevo CAFE_DatoExtendido a asignar
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  FUNCTION EscribirCasilla      : TRUE indica exito, FALSE fracaso
}

FUNCTION    LeerFormato
  (       Fila, Columna         : LongInt                               )
                                        : CAFE_TCollectionItemFormatoCasilla;
{
  FUNCTION LeerFormato
        Para leer FormatHoja, simple...
        LeerFormato     := FormatoHoja[ Fila ][ Columna ]
        NOTA: FormatoHoja unimplemented
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  FUNCTION LeerFormato          : TRUE indica exito, FALSE fracaso
}

FUNCTION    EscribirFormato
  ( CONST MyFormato             : CAFE_TCollectionItemFormatoCasilla;
          Fila, Columna         : LongInt               ) : Boolean; virtual;
{
  FUNCTION EscribirFormato
        Luego de destruir el formato previo (cuidado, no se ha probado)
        asigna el nuevo formato
        FormatoHoja[ Fila ][ Columna ]  := MyFormato
        NOTA: FormatoHoja unimplemented
  MyFormato                     : Valor de formato a asignar
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  FUNCTION EscribirFormato      : TRUE indica exito, FALSE fracaso
}

FUNCTION   EvaluarFuncionSimple
  (       Fila, Columna         : LongInt;
    OUT   ResultFuncion         : Variant;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          CicloSintactico       : LongInt       = 0     ) : Boolean; virtual;
{
  FUNCTION EvaluarFuncionSimple
        Trata de obtener el valor Variant reportada por la casilla,
        con evaluacion completa si fuera el caso.
        Compatible con datos simples y NULL.
        Consultar banderas para el grado de evaluacion.
        Conviene leer:
        CAFE_HojaCalculoBase.DescriptoresHoja
        WITH SintacticaHoja[ Fila, Columna ] as CAFE_DatoNudillado
                BanderaPeticionNudillar
                        esta bandera generalmente obliga al calculo
                        pues reinterpreta
                BanderaPeticionCalculo
                MacroParametro
        NOTA: No es compatible con macros, y genera FUNCTION False
                y Msg similar a 'Macro indefinida'
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  ResultFuncion                 : Resultado de la operacion
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  CicloSintactico               : Usar cero (default), cuando la casilla
        tiene la iniciativa.  Mejor nunca generarlo, y dejar
        que la computadora se encargue.
        Su objetivo, es llevar el control de la recursividad y ciclos
        en Hojas de Calculo.
  FUNCTION EvaluarFuncionSimple : TRUE si exito, FALSE si fracaso
        NOTA: el fracaso produce casi seguramente
        BanderaPeticionCalculo  = TRUE
        BanderaPeticionNudillar = TRUE
        Esto provoca reinterpretacion, lo que muchas veces sera
        en realidad necesario.
        Podria el programador ahorra algo de tiempo en el futuro,
        tomando en cuenta que el Arbol Sintactico en
        CAFE_DatoNudillado.FuncionNudillado no se ha destruido
        al salir en FUNCTION, pero pronto lo sera
}

FUNCTION   EvaluarMacroSimple
  (       Fila, Columna         : LongInt;
    OUT   ResultMacro           : Double;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          TotalParMacro         : LongInt;
          Param1                : Double        = 0.0;
          Param2                : Double        = 0.0;
          Param3                : Double        = 0.0;
          CicloSintactico       : LongInt       = 0     ) : Boolean; virtual;
{
  FUNCTION EvaluarMacroSimple
        Trata de obtener el valor Double reportada por la
        macro funcional asignada a la casilla.
        NOTA: No es compatible con nada que no sea macro
                y genera FUNCTION FALSE, Null inclusive
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  ResultMacro                   : Resultado de la operacion
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  TotalParMacro                 : Total de parametros de la macro
  Param1                        : Valor a pasar al primer parametro
  Param2                        : Valor a pasar al segundo parametro
  Param3                        : Valor a pasar al tercer parametro
  CicloSintactico               : Usar cero (default), cuando la casilla
        tiene la iniciativa.  Mejor nunca generarlo, y dejar
        que la computadora se encargue.
        Su objetivo, es llevar el control de la recursividad y ciclos
        en Hojas de Calculo.
  FUNCTION EvaluarMacroSimple   : TRUE si exito, FALSE si fracaso
        NOTA: el fracaso produce casi seguramente
        BanderaPeticionCalculo  = TRUE
        BanderaPeticionNudillar = TRUE
}

  Protected
FUNCTION   EvaluarMacroFuncionSimple
  (       Fila, Columna         : LongInt;
    OUT   ResultMacro           : Variant;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          TotalParMacro         : LongInt       = 0;
          Param1                : Double        = 0.0;
          Param2                : Double        = 0.0;
          Param3                : Double        = 0.0;
          CicloSintactico       : LongInt       = 0     ) : Boolean; virtual;
{
  FUNCTION EvaluarMacroFuncionSimple
        Trata de obtener el valor para cualquier tipo
        de casilla, Null inclusive.
        Deberia sin embargo; cuidar que
        TotalParMacro tenga el valor correcto en el
        caso de macros, y DEBE valer cero (default) si no es macro.
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  ResultMacro                   : Resultado Variant de la operacion,
        Double en el caso de macros funcionales.
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  TotalParMacro                 : Total de parametros de la macro si aplica,
        cero en otro caso.
  Param1                        : Valor a pasar al primer parametro si aplica
  Param2                        : Valor a pasar al segundo parametro si aplica
  Param3                        : Valor a pasar al tercer parametro si aplica
  CicloSintactico               : Usar cero (default), cuando la casilla
        tiene la iniciativa.  Mejor nunca generarlo, y dejar
        que la computadora se encargue.
        Su objetivo, es llevar el control de la recursividad y ciclos
        en Hojas de Calculo.
  FUNCTION EvaluarMacroFuncionSimple    : TRUE si exito, FALSE si fracaso
        NOTA: el fracaso produce casi seguramente
        BanderaPeticionCalculo  = TRUE
        BanderaPeticionNudillar = TRUE
}

  Public
FUNCTION   PeticionNudillarMacroFuncionSimple
  (       Fila, Columna         : LongInt;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico          ) : Boolean;
{
  FUNCTION PeticionNudillarMacroFuncionSimple
        Creada para responder a BanderaPeticionNudillar;
        por tanto, todo deberia estar en estado 'aceptable' de ingreso
        FALSE si no detecta condiciones aceptables
        A. Tipo de dato funcional o macro, con estructura y
                banderas apropiadas
                Son tolerables,
                CAFE_DatoNudillado.FuncionNudillado = cualquier...
                pues sera destruido y creara uno nuevo
        B. VariantHoja[ Fila ][ Columna ] DEBE ser String, de lo
                contrario podria tener Graves consecuencias
                de ejecucion, estado de HALT...
        C. Aunque no se revisa deberia responder a un estado
                de BanderaPeticionNudillar      = TRUE
        De salida se genera
        BanderaPeticionCalculo          = TRUE
        NOTA: Valores y Parametros de macro se dejan sin cambio.
  Fila                          : Fila a buscar en la hoja
  Columna                       : Columna a buscar en la hoja
  Msg                           : Para ayudar en reporte de errores,
        deberia consultarse unicamente si FUNCTION es FALSE
  Manejador                     : Requiere acceso a CAFE_InterfaceManejador
        adecuado, que podria reportar NIL en HojaDefault y en PaqueteVisible
  FUNCTION PeticionNudillarMacroFuncionSimple   :
        TRUE si exito en el proceso, FALSE en caso contrario
}

  Public
DESTRUCTOR  Destroy; override;
{
  DESTRUCTOR Destroy
        Destructor de clase
}

                                  END;  { CAFE_HojaCalculoBase }

CONST
  CAFE_DefaultTamanoArregloString               : LongInt       = 1000;
{
  CAFE_DefaultTamanoArregloString               :
        Para el arreglo interprete de funciones, se reserva
        este espacio para los tipo String internos a Operadores,
        el tamano se duplica;  cada vez que se supera el limite.
        No se guardan en el arreglo, los String simples,
        asignados a casillas.
}

  CAFE_MaximoTamanoArregloString                : LongInt       = 1000000;
{
  CAFE_MaximoTamanoArregloString                :
        Por seguridad se asigna un maximo al tamano del arreglo
        de String generados por operadores sintacticos.
}

TYPE
  CAFE_ArregloString            = ARRAY OF PChar;
{
  CAFE_ArregloString            : Tipo de arreglo de PChar
        para almacenar String generados por el usuario
        para Operadores basicos
}

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  {$INTERFACES  CORBA           }
  CAFE_InterfaceManejador       = INTERFACE ( CAFE_InterfaceBasico )
                                  [CAFE_GUIDInterfaceManejador]
{
  CAFE_InterfaceManejador       : Interface base principal para
        Manejador en Hojas de Calculo e interpretacion de funciones
        CAFE_InterpreteBasico es la 'raiz' de los
        elementos que recibe el usuario programador,
        CAFE_InterfaceManejador desarrolla la modalidad Sintactica primitiva,
        a nivel de Property.
        Se planea sustituir a nivel de programador por
        PROCEDURE Simple( Manejador, etc... )
        o similar...
}

FUNCTION    Leer_HojaDefault                    : CAFE_HojaCalculoBase;
{
  FUNCTION Leer_HojaDefault
        Property HojaDefault requiere el READ declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_HojaDefault     : devuelve una Hoja de Calculo Default
                        o NIL si no existe.
}

FUNCTION    Leer_GramaticaCharByte              : CAFE_CharByte3Sintactico;
{
  FUNCTION Leer_GramaticaCharByte
        Property GramaticaCharByte requiere el READ declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_GramaticaCharByte               :
                        devuelve un tipo CAFE_ChayByte3Sintactico
                        apropiado para la traduccion
                        String --> sintaxis OperadorBasico
}

FUNCTION    Leer_GeneradorArbolSintactico       : CAFE_Nudo2Sintactico;
{
  FUNCTION Leer_GeneradorArbolSintactico
        Property GeneradorArbolSintactico requiere el READ declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_GeneradorArbolSintactico        :
                        devuelve un tipo CAFE_Nudo2Sintactico
                        capaz de la conversion
                        OperadorBasico --> Arbol Sintactico
                        con capacidad de interpretacion y ejecucion
                        condicionada a la INTERFACE
}

FUNCTION    Leer_NudilladoManejador             : CAFE_DatoNudillado;
{
  FUNCTION Leer_NudilladoManejador
        Property NudilladoManejador requiere el READ declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_NudilladoManejador              :
                        devuelve un tipo CAFE_DatoNudillado
                        apropiado para asignar (copias)
                        a CAFE_HojaCalculoBase.SintacticaHoja[i][j]
                        en la interpretacion funcional
                        y controlar parametricamente
                        el desempeno de las casillas
                        funcionales y macro
}

FUNCTION    Leer_PaquetePredefinido             : CAFE_Interprete2Sintactico;
{
  FUNCTION Leer_PaquetePredefinido
        Property PaquetePredefinido requiere el READ declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_PaquetePredefinido              :
                        devuelve una secuencia (primer elemento)
                        de CAFE_Interprete2Sintactico,
                        de OperadoresBasicos(), e Identificadores
                        no exhaustiva
                        reconocidos por la INTERFACE
}

FUNCTION    Leer_PaqueteVisible                 : CAFE_Interprete2Sintactico;
                                                unimplemented;
{
  FUNCTION Leer_PaqueteVisible
        Property PaqueteVisible requiere el READ declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_PaqueteVisible  :
                        Paquete previsto para controlar la visibilidad
                        de existencia de identificadores
                        condicionada a profundidad, anidamiento, entorno, etc.
                        NIL en esta version
}

FUNCTION    Leer_PaqueteIdioma                  : CAFE_TStringList;
{
  FUNCTION Leer_PaqueteIdioma
        Property PaqueteIdioma requiere el READ declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_PaqueteIdioma   :
                        Paquete para traducir comandos
                        o agregar alias de los mismos
}

FUNCTION    Leer_PaqueteUndo                    : CAFE_TCollectionUndo;
{
  FUNCTION Leer_PaqueteUndo
        Property PaqueteUndo requiere el READ declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_PaqueteUndo     :
                        Paquete para operaciones Undo
}

FUNCTION    Leer_ValorBanderaSimularCalculo     : Boolean;
{
  FUNCTION Leer_ValorBanderaSimularCalculo
        Property ValorBanderaSimularCalculo requiere el READ declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_ValorBanderaSimularCalculo :
                        TRUE para acelerar los calculos por
                        simple toma de valor
}

PROCEDURE   Escribir_ValorBanderaSimularCalculo
  (       NuevoValor            : Boolean                               );
{
  FUNCTION Escribir_ValorBanderaSimularCalculo
        Property ValorBanderaSimularCalculo requiere el WRITE declarado
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Escribir_ValorBanderaSimularCalculo :
                        TRUE para acelerar los calculos por
                        simple toma de valor
}



FUNCTION    Leer_ValorMaximaIteracionIntegralOctavoImpar        : LongInt;
{
  FUNCTION Leer_MaximaIteracionIntegralOctavoImpar
        Para leer property ValorMaximaIteracionIntegralOctavoImpar
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_MaximaIteracionIntegralOctavoImpar      :
        Valor inicial de iteracion para la integral de usuario
        FORINT, utiliza este valor como maxima iteracion a permitir
        mediante el metodo de IntegralOctavoImpar
}

PROCEDURE   Escribir_ValorMaximaIteracionIntegralOctavoImpar
  (       NuevoValor            : LongInt                               );
{
  FUNCTION Escribir_MaximaIteracionIntegralOctavoImpar
        Para escribir property ValorMaximaIteracionIntegralOctavoImpar
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Escribir_MaximaIteracionIntegralOctavoImpar      :
        Valor inicial de iteracion para la integral de usuario
        FORINT, utiliza este valor como maxima iteracion a permitir
        mediante el metodo de IntegralOctavoImpar
}

FUNCTION    Leer_ValorMaximaIteracionIntegralOctavoImparFuncion : LongInt;
{
  FUNCTION Leer_MaximaIteracionIntegralOctavoImparFuncion
        Para leer property ValorMaximaIteracionIntegralOctavoImparFuncion
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Leer_MaximaIteracionIntegralOctavoImparFuncion       :
        Numero de iteraciones maximas para algunas funciones
        lentas de evaluacion que requieren integral.
        i.e. la integral inversa de ChiSquare
}

PROCEDURE   Escribir_ValorMaximaIteracionIntegralOctavoImparFuncion
  (       NuevoValor            : LongInt                               );
{
  FUNCTION Escribir_MaximaIteracionIntegralOctavoImparFuncion
        Para Escribir property ValorMaximaIteracionIntegralOctavoImparFuncion
        para el buen funcionamiento y debe ser metodo.
  FUNCTION Escribir_MaximaIteracionIntegralOctavoImparFuncion   :
        Numero de iteraciones maximas para algunas funciones
        lentas de evaluacion que requieren integral.
        i.e. la integral inversa de ChiSquare
}

FUNCTION    Leer_ValorPreliminarSolve                           : LongInt;
{
  FUNCTION Leer_ValorPreliminarSolve
        Para leer en la Property ValorPreliminarSolve
  FUNCTION Leer_ValorPreliminarSolve : Numero de puntos de busqueda
        preliminar al aplica el usuario un FORSOL
}

PROCEDURE   Escribir_ValorPreliminarSolve
  (       NuevoValor            : LongInt                               );
{
  FUNCTION Escribir_ValorPreliminarSolve
        Para escribir en la Property ValorPreliminarSolve
  FUNCTION Escribir_ValorPreliminarSolve        : Numero de puntos
        de busqueda preliminar al aplica el usuario un FORSOL
}

FUNCTION    Leer_ValorDefaultToleranciaDeterminante             : Double;
{
  FUNCTION Leer_ValorDefaultToleranciaDerminante
        Para escribir en la Property ValorDefaultToleranciaDeterminante
  FUNCTION Leer_ValorDefaultToleranciaDeterminante      :
        Valor para considerar cero al evaluar un determinante.
        Esto es importante en ecuaciones lineales.
}

PROCEDURE   Escribir_ValorDefaultToleranciaDeterminante
  (       NuevoValor            : Double                                );
{
  FUNCTION Escribir_ValorDefaultToleranciaDerminante
        Para escribir en la Property ValorDefaultToleranciaDeterminante
  FUNCTION Escribir_ValorDefaultToleranciaDeterminante  :
        Valor para considerar cero al evaluar un determinante.
        Esto es importante en ecuaciones lineales.
}

FUNCTION    Leer_ValorEpsilonZero                               : Double;
{
  FUNCTION Leer_ValorEpsilonZero
        Para leer en la Property ValorEpsilonZero
  FUNCTION Leer_ValorEpsilonZero     : Numero que sera reconocido
        como zero, para evitar errores, como raices falsas negativas
}

PROCEDURE   Escribir_ValorEpsilonZero
  (       NuevoValor            : Double                                );
{
  FUNCTION Escribir_ValorEpsilonZero
        Para leer en la Property ValorEpsilonZero
  FUNCTION Escribir_ValorEpsilonZero    :
        Numero que sera reconocido
        como zero, para evitar errores, como raices falsas negativas
}


FUNCTION    VincularPaquete
  ( CONST NuevoNombre           : CAFE_CadenaSintactica;
          NumeroControl         : LongInt                       ) : Boolean;
{
  FUNCTION  VincularPaquete
        Permite comunicacion entre varios paquetes de variables
        CUIDADO: una hoja que se comunique con otra, deberia
        estar activa simultaneamente para no reportar error
  NuevoNombre                   : Nombre del otro paquete segun
        Property NombrePaquete
  NumeroControl                 : El numero asignado a la lista
        de CAFE_ManejadorBasico
  FUNCTION VincularPaquete      : TRUE para indicar exito,
        FALSE si fracaso, probablemente se deba a que
        el nombre de Manejador debe ser exclusivo
}

FUNCTION    DesVincularPaquete
  ( CONST NombreBorrar          : CAFE_CadenaSintactica;
          NumeroControl         : LongInt                       ) : Boolean;
{
  FUNCTION  DesVincularPaquete
        Para desactivar comunicacion con este paquetes de variables
        Una hoja que se comunique con otra, deberia
        estar activa simultaneamente para no reportar error;
        pero puede tambien desvincularse con este PROCEDURE
  NombreBorrar                  : Nombre del otro paquete segun
        Property NombrePaquete
  NumeroControl                 : El numero asignado a la lista
        de CAFE_ManejadorBasico
  FUNCTION DesvincularPaquete                   : devuelve TRUE para indicar
        exito y FALSE algun problema
}

FUNCTION    EstablecerNombrePaquete
  ( CONST NuevoNombre           : CAFE_CadenaSintactica         ) : Boolean;
{
  PROCEDURE EstablecerNombrePaquete
        Procedimiento para establecer el nombre para reconocer
        la hoja y comunicacion entre varias hojas y similar
  NuevoNombre                   : El nuevo nombre a asignar
        a la hoja actual
  FUNCTION EstablecerNombrePaquete              : devuelve TRUE
        para indicar exito y FALSE algun problema
}

  Property
    HojaDefault                 : CAFE_HojaCalculoBase
                                  READ Leer_HojaDefault;
{
    HojaDefault                 : devuelve una Hoja de Calculo Default
                        o NIL si no existe.
}

  Property
    GramaticaCharByte           : CAFE_CharByte3Sintactico
                                  READ Leer_GramaticaCharByte;
{
    GramaticaCharByte           : devuelve un tipo CAFE_ChayByte3Sintactico
        apropiado para la traduccion String --> sintaxis OperadorBasico
}

  Property
    GeneradorArbolSintactico    : CAFE_Nudo2Sintactico
                                  READ Leer_GeneradorArbolSintactico;
{
    GeneradorArbolSintactico    : devuelve un tipo CAFE_Nudo2Sintactico
        capaz de la conversion OperadorBasico --> Arbol Sintactico
        con capacidad de interpretacion y ejecucion
        condicionada a la INTERFACE
}

  Property
    NudilladoManejador          : CAFE_DatoNudillado
                                  READ Leer_NudilladoManejador;
{
    NudilladoManejador          : devuelve un tipo CAFE_DatoNudillado
        apropiado para asignar (copias)
        a CAFE_HojaCalculoBase.SintacticaHoja[i][j]
        en la interpretacion funcional y controlar parametricamente
        el desempeno de las casillas funcionales y macro
}

  Property
    PaquetePredefinido          : CAFE_Interprete2Sintactico
                                  READ Leer_PaquetePredefinido;
{
    PaquetePredefinido          : devuelve una secuencia (primer elemento)
        de CAFE_Interprete2Sintactico, de OperadoresBasicos(),
        e Identificadores no exhaustiva reconocidos por la INTERFACE
}

  Property
    PaqueteVisible              : CAFE_Interprete2Sintactico
                                  READ Leer_PaqueteVisible; unimplemented;
{
    PaqueteVisible              : Paquete previsto para controlar
        la visibilidad de existencia de identificadores
        condicionada a profundidad, anidamiento, entorno, etc.
        NIL en esta version
}

  Property
    PaqueteIdioma               : CAFE_TStringList
                                  READ Leer_PaqueteIdioma;
{
    PaqueteIdioma               : Paquete para introducir alias
        y versiones en otros idiomas de los comandos
}

  Property
    PaqueteUndo                 : CAFE_TCollectionUndo
                                  READ Leer_PaqueteUndo;
{
    PaqueteUndo                 : Paquete para contener copias
        de seguridad de los procesos y realizar operaciones Undo
}

  Property
    ValorBanderaSimularCalculo  : Boolean
                                  READ Leer_ValorBanderaSimularCalculo
                                  WRITE Escribir_ValorBanderaSimularCalculo;
{
    ValorBanderaSimularCalculo  : Para acelerar los calculos
        por simple toma de valor, cuando se pueda.
}

  Property
    ValorMaximaIteracionIntegralOctavoImpar             : LongInt
                READ Leer_ValorMaximaIteracionIntegralOctavoImpar
                WRITE Escribir_ValorMaximaIteracionIntegralOctavoImpar;
{
  ValorMaximaIteracionIntegralOctavoImpar               :
        Valor inicial de iteracion para la integral de usuario
        FORINT, utiliza este valor como maxima iteracion a permitir
        mediante el metodo de IntegralOctavoImpar
}

  Property
    ValorMaximaIteracionIntegralOctavoImparFuncion      : LongInt
        READ Leer_ValorMaximaIteracionIntegralOctavoImparFuncion
        WRITE Escribir_ValorMaximaIteracionIntegralOctavoImparFuncion;
{
  ValorMaximaIteracionIntegralOctavoImparFuncion        :
        Numero de iteraciones maximas para algunas funciones
        lentas de evaluacion que requieren integral.
        i.e. la integral inversa de ChiSquare
}

  Property
    ValorPreliminarSolve        : LongInt
                                  READ Leer_ValorPreliminarSolve
                                  WRITE Escribir_ValorPreliminarSolve;
{
  ValorPreliminarSolve                  : Numero de puntos de busqueda
        preliminar al aplica el usuario un FORSOL
}

  Property
    ValorDefaultToleranciaDeterminante          : Double
                READ Leer_ValorDefaultToleranciaDeterminante
                WRITE Escribir_ValorDefaultToleranciaDeterminante;
{
    ValorDefaultToleranciaDeterminante          :
        Valor para considerar cero al evaluar un determinante.
        Esto es importante en ecuaciones lineales.
}

  Property
    ValorEpsilonZero            : Double
                                  READ Leer_ValorEpsilonZero
                                  WRITE Escribir_ValorEpsilonZero;
{
    ValorEpsilonZero            :
        Numero que sera reconocido
        como zero, para evitar errores, como raices falsas negativas
}

  END experimental;  { CAFE_InterfaceManejador }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

TYPE
  CAFE_ReferenciaManejador      = CLASS OF CAFE_ManejadorBasico;
{
  CAFE_ReferenciaManejador      :
        Referencia para la clase CAFE_ManejadorBasico
}

  CAFE_ManejadorBasico          = CLASS
                ( CAFE_Manejador0, CAFE_InterfaceManejador )
{
  Clase que implementa a CAFE_InterfaceManejador,
  y le agrega algunas pocas herramientas utiles de diseno
}

  Public
    HojaDefaultI                : CAFE_HojaCalculoBase;
{
    HojaDefaultI                : Hoja de Calculo Default, admisible NIL
}

    GramaticaCharByteI          : CAFE_CharByte3Sintactico;
{
    GramaticaCharByteI          : para la traduccion
                String --> sintaxis OperadorBasico
}

    GeneradorArbolSintacticoI   : CAFE_Nudo2Sintactico;
{
    GeneradorArbolSintacticoI   : Para conversion
        OperadorBasico --> Arbol Sintactico
        con capacidad de interpretacion y ejecucion
        condicionada a la INTERFACE
}

    NudilladoManejadorI         : CAFE_DatoNudillado;
{
    NudilladoManejadorI         : Apropiado para asignar (copias)
        a CAFE_HojaCalculoBase.SintacticaHoja[i][j]
        en la interpretacion funcional y controlar parametricamente
        el desempeno de las casillas funcionales y macro
}

    PaquetePredefinidoI         : CAFE_Interprete2Sintactico;
{
    PaquetePredefinidoI         : Secuencia (primer elemento)
        de CAFE_Interprete2Sintactico, de OperadoresBasicos(),
        e Identificadores no exhaustiva reconocidos por la INTERFACE
}

    PaqueteVisibleI             : CAFE_Interprete2Sintactico unimplemented;
{
    PaqueteVisibleI             : Paquete previsto para controlar
        la visibilidad de existencia de identificadores
        condicionada a profundidad, anidamiento, entorno, etc.
        NIL en esta version
}

    PaqueteUndoI                : CAFE_TCollectionUndo;
{
    PaqueteUndoI                : Paquete previsto para controlar
        las operaciones Undo de seguridad rapida.
}

  Strict Private
    PaqueteIdiomaI              : CAFE_TStringList;
{
    PaqueteIdiomaI              : Paquete previsto para controlar
        traduccion y alias de identificadores
}

  Protected
    ValorBanderaSimularCalculoI : Boolean;
{
    ValorBanderaSimularCalculoI : Para acelerar los calculos
        por simple toma de valor, cuando se pueda.
}

    ValorMaximaIteracionIntegralOctavoImparFuncionI,
{
  ValorMaximaIteracionIntegralOctavoImparFuncionI       :
        Numero de iteraciones maximas para algunas funciones
        lentas de evaluacion que requieren integral.
        i.e. la integral inversa de ChiSquare
}

    ValorMaximaIteracionIntegralOctavoImparI,
{
  CAFE_InicialMaximaIteracionIntegralOctavoImparI       :
        Valor inicial de iteracion para la integral de usuario
        FORINT, utiliza este valor como maxima iteracion a permitir
        mediante el metodo de IntegralOctavoImpar
}

    ValorPreliminarSolveI       : LongInt;
{
  ValorPreliminarSolveI                 : Numero de puntos de busqueda
        preliminar al aplica el usuario un FORSOL
}

    ValorDefaultToleranciaDeterminanteI,
{
    ValorDefaultToleranciaDeterminanteI         :
        Valor para considerar cero al evaluar un determinante.
        Esto es importante en ecuaciones lineales.
}

    ValorEpsilonZeroI           : Double;
{
    ValorEpsilonZeroI           :
        Numero que sera reconocido
        como zero, para evitar errores, como raices falsas negativas
}

  Public
CONSTRUCTOR Create
  (       ACollection           : TCollection                   ); override;
{
  Herencias de TStreamCollectionItem nunca deberian crearse en forma
  independiente (ver Manual Classes)
}

PROCEDURE   ActivarModoBasico
  (     Hoja                    : CAFE_HojaCalculoBase;
        BanderaQuimico          : Boolean                               );
{
  PROCEDURE ActivarModoBasico
        Activa CAFE_ManejadorBasico agregandole funciones e
        identificadores predefinidos.  Ademas permite
        adicionar una hoja de calculo al paquete.
  Hoja                          : Admisible NIL.  Hoja default del paquete
  BanderaQuimico                : TRUE agrega identificadores con unidades
        especiales de uso personal del autor original de EJES.EXE
}

FUNCTION    SustitucionHojaDefault
  (     NuevaHoja               : CAFE_HojaCalculoBase
                                                ) : CAFE_HojaCalculoBase;
{
  FUNCTION SustitucionHojaDefault
        Sustituye HojaDefaultI, por esta nueva hoja.  La hoja anterior
        se devuelve en FUNCTION.  NIL es admisible.
  NuevaHoja                     : Nueva hoja (admisible NIL) a vincular
        con CAFE_ManejadorBasico
  FUNCTION SustitucionHojaDefault       : Valor anterior de hoja.
        Esta FUNCTION se creo originalmente pensando en operaciones UNDO
}

FUNCTION    VincularPaquete
  ( CONST NuevoNombre           : CAFE_CadenaSintactica;
          NumeroControl         : LongInt                       ) : Boolean;
{
  FUNCTION  VincularPaquete
        Permite comunicacion entre varios paquetes de variables
        CUIDADO: una hoja que se comunique con otra, deberia
        estar activa simultaneamente para no reportar error
  NuevoNombre                   : Nombre del otro paquete segun
        Property NombrePaquete
  NumeroControl                 : El numero asignado a la lista
        de CAFE_ManejadorBasico
  FUNCTION VincularPaquete      : TRUE para indicar exito,
        FALSE si fracaso, probablemente se deba a que
        el nombre de Manejador debe ser exclusivo
}

FUNCTION    DesVincularPaquete
  ( CONST NombreBorrar          : CAFE_CadenaSintactica;
          NumeroControl         : LongInt                       ) : Boolean;
{
  FUNCTION  DesVincularPaquete
        Para desactivar comunicacion con este paquetes de variables
        Una hoja que se comunique con otra, deberia
        estar activa simultaneamente para no reportar error;
        pero puede tambien desvincularse con este PROCEDURE
  NombreBorrar                  : Nombre del otro paquete segun
        Property NombrePaquete
  NumeroControl                 : El numero asignado a la lista
        de CAFE_ManejadorBasico
  FUNCTION DesvincularPaquete                   : devuelve TRUE para indicar
        exito y FALSE algun problema
}

FUNCTION    EstablecerNombrePaquete
  ( CONST NuevoNombre           : CAFE_CadenaSintactica         ) : Boolean;
{
  PROCEDURE EstablecerNombrePaquete
        Procedimiento para establecer el nombre para reconocer
        la hoja y comunicacion entre varias hojas y similar
  NuevoNombre                   : El nuevo nombre a asignar
        a la hoja actual
  FUNCTION EstablecerNombrePaquete              : devuelve TRUE
        para indicar exito y FALSE algun problema
}

DESTRUCTOR  Destroy; override;
{
  Destructor de clase de la unidad
}

  Private
FUNCTION    Leer_HojaDefault                    : CAFE_HojaCalculoBase;

  Private
FUNCTION    Leer_GramaticaCharByte              : CAFE_CharByte3Sintactico;

  Private
FUNCTION    Leer_GeneradorArbolSintactico       : CAFE_Nudo2Sintactico;

  Private
FUNCTION    Leer_NudilladoManejador             : CAFE_DatoNudillado;

  Private
FUNCTION    Leer_PaquetePredefinido             : CAFE_Interprete2Sintactico;

  Private
FUNCTION    Leer_PaqueteVisible                 : CAFE_Interprete2Sintactico;

  Private
FUNCTION    Leer_PaqueteIdioma                  : CAFE_TStringList;

  Private
FUNCTION    Leer_PaqueteUndo                    : CAFE_TCollectionUndo;

  Private
FUNCTION    Leer_ValorBanderaSimularCalculo     : Boolean;

  Private
PROCEDURE   Escribir_ValorBanderaSimularCalculo
  (       NuevoValor            : Boolean                               );

  Private
FUNCTION    Leer_ValorMaximaIteracionIntegralOctavoImpar        : LongInt;

  Private
PROCEDURE   Escribir_ValorMaximaIteracionIntegralOctavoImpar
  (       NuevoValor            : LongInt                               );

  Private
FUNCTION    Leer_ValorMaximaIteracionIntegralOctavoImparFuncion : LongInt;

  Private
PROCEDURE   Escribir_ValorMaximaIteracionIntegralOctavoImparFuncion
  (       NuevoValor            : LongInt                               );

  Private
FUNCTION    Leer_ValorPreliminarSolve                           : LongInt;

  Private
PROCEDURE   Escribir_ValorPreliminarSolve
  (       NuevoValor            : LongInt                               );

  Private
FUNCTION    Leer_ValorDefaultToleranciaDeterminante             : Double;

  Private
PROCEDURE   Escribir_ValorDefaultToleranciaDeterminante
  (       NuevoValor            : Double                                );

  Private
FUNCTION    Leer_ValorEpsilonZero                               : Double;

  Private
PROCEDURE   Escribir_ValorEpsilonZero
  (       NuevoValor            : Double                                );

  Public
  Property
    HojaDefault                 : CAFE_HojaCalculoBase
                                  READ Leer_HojaDefault;
{
    HojaDefault                 : devuelve una Hoja de Calculo Default
                        o NIL si no existe.
}

  Public
  Property
    GramaticaCharByte           : CAFE_CharByte3Sintactico
                                  READ Leer_GramaticaCharByte;
{
    GramaticaCharByte           : devuelve un tipo CAFE_ChayByte3Sintactico
        apropiado para la traduccion String --> sintaxis OperadorBasico
}

  Public
  Property
    GeneradorArbolSintactico    : CAFE_Nudo2Sintactico
                                  READ Leer_GeneradorArbolSintactico;
{
    GeneradorArbolSintactico    : devuelve un tipo CAFE_Nudo2Sintactico
        capaz de la conversion OperadorBasico --> Arbol Sintactico
        con capacidad de interpretacion y ejecucion
        condicionada a la INTERFACE
}

  Public
  Property
    NudilladoManejador          : CAFE_DatoNudillado
                                  READ Leer_NudilladoManejador;
{
    NudilladoManejador          : devuelve un tipo CAFE_DatoNudillado
        apropiado para asignar (copias)
        a CAFE_HojaCalculoBase.SintacticaHoja[i][j]
        en la interpretacion funcional y controlar parametricamente
        el desempeno de las casillas funcionales y macro
}

  Public
  Property
    PaquetePredefinido          : CAFE_Interprete2Sintactico
                                  READ Leer_PaquetePredefinido;
{
    PaquetePredefinido          : devuelve una secuencia (primer elemento)
        de CAFE_Interprete2Sintactico, de OperadoresBasicos(),
        e Identificadores no exhaustiva reconocidos por la INTERFACE
}

  Public
  Property
    PaqueteVisible              : CAFE_Interprete2Sintactico
                                  READ Leer_PaqueteVisible; unimplemented;
{
    PaqueteVisible              : Paquete previsto para controlar
        la visibilidad de existencia de identificadores
        condicionada a profundidad, anidamiento, entorno, etc.
        NIL en esta version
}

  Public
  Property
    PaqueteIdioma               : CAFE_TStringList
                                  READ Leer_PaqueteIdioma;
{
    PaqueteIdioma               : Paquete para introducir alias
        y versiones en otros idiomas de los comandos
}

  Public
  Property
    PaqueteUndo                 : CAFE_TCollectionUndo
                                  READ Leer_PaqueteUndo;
{
    PaqueteUndo                 : Paquete para contener copias
        de seguridad de los procesos y realizar operaciones Undo
}

  Public
  Property
    ValorBanderaSimularCalculo  : Boolean
                                  READ Leer_ValorBanderaSimularCalculo
                                  WRITE Escribir_ValorBanderaSimularCalculo;
{
    ValorBanderaSimularCalculo  : Para acelerar los calculos
        por simple toma de valor, cuando se pueda.
}

  Public
  Property
    ValorMaximaIteracionIntegralOctavoImpar             : LongInt
                READ Leer_ValorMaximaIteracionIntegralOctavoImpar
                WRITE Escribir_ValorMaximaIteracionIntegralOctavoImpar;
{
  ValorMaximaIteracionIntegralOctavoImpar               :
        Valor inicial de iteracion para la integral de usuario
        FORINT, utiliza este valor como maxima iteracion a permitir
        mediante el metodo de IntegralOctavoImpar
}

  Public
  Property
    ValorMaximaIteracionIntegralOctavoImparFuncion      : LongInt
                READ Leer_ValorMaximaIteracionIntegralOctavoImparFuncion
                WRITE Escribir_ValorMaximaIteracionIntegralOctavoImparFuncion;
{
  ValorMaximaIteracionIntegralOctavoImparFuncion        :
        Numero de iteraciones maximas para algunas funciones
        lentas de evaluacion que requieren integral.
        i.e. la integral inversa de ChiSquare
}

  Public
  Property
    ValorPreliminarSolve        : LongInt
                                  READ Leer_ValorPreliminarSolve
                                  WRITE Escribir_ValorPreliminarSolve;
{
  ValorPreliminarSolve                  : Numero de puntos de busqueda
        preliminar al aplica el usuario un FORSOL
}

  Public
  Property
    ValorDefaultToleranciaDeterminante          : Double
                READ Leer_ValorDefaultToleranciaDeterminante
                WRITE Escribir_ValorDefaultToleranciaDeterminante;
{
    ValorDefaultToleranciaDeterminante          :
        Valor para considerar cero al evaluar un determinante.
        Esto es importante en ecuaciones lineales.
}

  Public
  Property
    ValorEpsilonZero            : Double
                                  READ Leer_ValorEpsilonZero
                                  WRITE Escribir_ValorEpsilonZero;
{
    ValorEpsilonZero            :
        Numero que sera reconocido
        como zero, para evitar errores, como raices falsas negativas
}

                                  END;  { CAFE_ClassManejadorBasico }

VAR
  CAFE_TipoManejadorAsignado    : CAFE_ReferenciaManejador;
{
  CAFE_TipoManejadorAsignado    : Establece el tipo de manejador
        a asignar a la coleccion principal, que probablemente sea uniforme
}

TYPE
  CAFE_ReferenciaCollectionManejador    =
                                  CLASS OF CAFE_TCollectionManejador0;
{
  CAFE_ReferenciaCollectionManejador            :
        Define una referencia de clase para las colecciones de
        manejadores
}

  CAFE_TCollectionManejador0    = CLASS ( TOwnedCollection )
{
  CAFE_TCollectionManejador0    : Se creo la herencia para facilitar
        el acceso mediante ID a CAFE_ManejadorBasico
}

CONSTRUCTOR Create; virtual;
{
  Sustituye al Create de TStreamCollection, pues ya el tipo esta decidido
}

  Public
DESTRUCTOR  Destroy; override;
{
  Destructor basico de la unidad
}

  Public
  Class
PROCEDURE   Activar; virtual;
{
  PROCEDURE Activar
        Se supone que solo existe una instancia Raiz
        de CAFE_TCollectionManejador0; aunque en el futuro
        probablemente se convierta en arbol.  Activar inicializa
        esta instancia y otros elementos para darle
        la funcionabilidad inicial a CAFE.EXE
}

  Public
  Class
PROCEDURE   Desactivar; virtual;
{
  PROCEDURE Desactivar
        Desactiva el sistema CAFE.EXE.  Eliminando los recursos
        de memoria.  Esta disenado para facilitar el "pasar" las pruebas de
        punteros.  Aunque deberia tomar en cuenta las previsiones
        de FPC sobre ampliacion de recursos de memoria RAM.
}

  Public
PROCEDURE   AtFreeID
  (       Ide                   : LongInt;
          BorrarHoja            : Boolean       = FALSE                 );
{
  PROCEDURE AtFreeID
        Amplia la funcionalidad del Delete de TCollection, para
        permitir opcionalmente eliminar la HojaDefault o no.  El Delete
        no lo haria.
  Ide                           : Numero de identificador del
        Manejador a eliminar.
  BorrarHoja                    : TRUE solicita FreeAndNIL para HojaDefault,
        FALSE simplemente asigna NIL, antes de destruir.
}

  Private
FUNCTION    ReadItemID
  (     Ide                     : LongInt       ) : CAFE_ManejadorBasico;

  Public
  Property
    ID[ ide : Integer ]         : CAFE_ManejadorBasico
                                  Read  ReadItemID;
{
  ID                            : Acceso estilo array
        Instance.ID[ Clave ] a los elementos CAFE_ManejadorBasico del array
}

                                  END;  { CLASS CAFE_TCollectionManejador0 }

VAR
  CAFE_TipoCollectionPrincipal  : CAFE_ReferenciaCollectionManejador;
{
  CAFE_TipoCollectionPrincipal  : Establece el tipo de la coleccion
        principal de manejadores.  Probablemente unica;  en el futuro
        probablemente asuma estructura de arbol.
}

CONST
  CAFE_DefaultTamanoInicialCharByte     = 1000;
{
  CAFE_DefaultTamanoInicialCharByte             : tamano maximo
        de cadena admisible en la interpretacion interna
        de ordenes de CAFE_Ej4.  Incluido el procesamiento.
}

VAR
  CAFE_RaizManejadores          : CAFE_TCollectionManejador0;
{
  CAFE_RaizManejadores          : Contiene la raiz de loa manejadores
        de Hoja de Calculo y similar
        en EJES.EXE;  se supone que no se accesa directamente.
        Probablemente requerira cambio de tipo posterior
}

VAR
  CAFE_DefaultListaString       : CAFE_TStringList;
{
  CAFE_DefaultListaString       : Para contener String de los procesos
        de nudillado
}

TYPE
  CAFE_ArregloDouble            = ARRAY OF Double;
{
  CAFE_ArregloDouble            : Tipo para arreglo de reales,
        su aplicacion principal actual es definir zonas rectangulares,
        de existencia transitorio en las operaciones de matriz.
        El tipo se define como lineal simple
}

  CAFE_ItemRectangular          = CLASS ( TCollectionItem )
{
  CAFE_ItemRectangular          : Clase para almacenar rectangulos
        de valores reales.  Extraidos en forma transitoria
        de hojas de calculo en aplicaciones diversas
        Esta planeado para interpretarse como un arreglo
        binario o lineal simultaneamente, porque?
        para evitar confusiones con la unidad FreePascal.Math
}

  Public
    ArregloDoubleSector         : CAFE_ArregloDouble;
{
  ArregloDoubleSector           : Contiene el dicho arreglo extraido
        como cadena lineal
}

    FilasDouble,
{
  FilasDouble                   : Filas del ArregloDoubleSector
        interpretado como bidimensional (el arreglo en si
        se define lineal)
        FilasDouble*ColumnasDouble = Length( ArregloDoubleSector )
}

    ColumnasDouble              : LongInt;
{
  ColumnasDouble                : Columnas del ArregloDoubleSector
        interpretado como bidimensional (el arreglo en si
        se define lineal)
        FilasDouble*ColumnasDouble = Length( ArregloDoubleSector )
}

    ClaveCicloRectangular       : LongInt;
{
  ClaveCicloRectangular         : almacena el numero de ciclo sintactico
        que origino la ejecucion del paquete.
        En la actualidad se ordena la destruccion
        del paquete
        cada nuevo ciclo sintactico que genera un paquete.
}

    BanderaRectangular          : Boolean;
{
  BanderaRectangular            : TRUE indica activo;  FALSE que
        se encuentra inactivo, y lista para sobreescribirse.
}

  Public
CONSTRUCTOR Create
  (       ACollection           : TCollection                   ); override;
{
  Herencias de TStreamCollectionItem nunca deberian crearse en forma
  independiente (ver Manual Classes)
}

  Public
DESTRUCTOR  Destroy; override;
{
  Unica forma para remover Items desde una TStreamCollection, deje que
  ella se encargue
}

  Public
PROCEDURE   EscribirDoubleItemRectangular
  (       ValorDouble           : Double;
          FilaPaquete, ColumnaPaquete           : LongInt               );
{
  PROCEDURE EscribirDoublePaqueteRectangular
        Este Procedure interpreta los datos
        como una matriz bidimensional
        La idea es simular la asignacion invalida
          ArregloDoubleSector[ FilaPaquete ][ ColumnaPaquete ] := ValorDouble
        En realidad esta asignacion es Invalida,
        pues ArregloDoubleSector se declara lineal
  ValorDouble           : Se le asigna el valor al arreglo
  FilaPaquete           : Numero a partir de cero, para representar
        el numero de fila equivalente
  ColumnaPaquete        : Numero a partir de cero, para representar
        el numero de columna equivalente
        ADVERTENCIA : la asignacion es inmediata, asi que
        es probable un error de ejecucion
}

  Public
FUNCTION    LeerDoubleItemRectangular
  (       FilaPaquete, ColumnaPaquete           : LongInt       ) : Double;
{
  FUNCTION LeerDoubleItemRectangular
        Esta FUNCTION interpreta los datos en
        como una matriz bidimensional
        La idea es simular la asignacion invalida double
           Result :=    ArregloDoubleSector[ FilaPaquete ][ ColumnaPaquete ]
        En realidad esta asignacion es Invalida,
        pues entre otras razones, ArregloDoubleSector se declara lineal
  FilaPaquete           : Numero a partir de cero, para representar
        el numero de fila equivalente
  ColumnaPaquete        : Numero a partir de cero, para representar
        el numero de columna equivalente
  FUNCTION LeerDoubleItemRectangular            : devuelve el
        valor double solicitado
        ADVERTENCIA : la asignacion es inmediata, asi que
        es probable un error de ejecucion
}

  Strict Private
FUNCTION    ReadItems
  (     Ide                     : LongInt                       ) : Double;

  Strict Private
PROCEDURE   WriteItems
  (     Ide                     : LongInt;
        MyDouble                : Double                                );

  Public
  Property
    Items[ ide : LongInt ]      : Double
                                  Read  ReadItems
                                  Write WriteItems; Default;
{
  Items                         : Permite accesar los elementos
        de ArregloDoubleSector en forma ordinaria a un array
}

                                  END;  { CLASS CAFE_ItemRectangular }

  CAFE_TCollectionRectangular   = CLASS ( TCollection )
{
  CAFE_TCollectionRectangular   : Se creo la herencia para facilitar
        el acceso mediante ID a CAFE_ItemRectangular
}

CONSTRUCTOR Create; virtual;
{
  Sustituye al Create de TStreamCollection, pues ya el tipo esta decidido
}

  Private
FUNCTION    ReadItemID
  (     Ide                     : LongInt       ) : CAFE_ItemRectangular;

  Public
  Property
    ID[ ide : Integer ]         : CAFE_ItemRectangular
                                  Read  ReadItemID;
{
  ID                            : Acceso estilo array
        Instance.ID[ Clave ] a los elementos CAFE_ItemRectangular del array
}

                                  END;  { CLASS CAFE_TCollectionRectangular }

  CAFE_PaqueteRectangular       = RECORD
{
  CAFE_PaqueteRectangular       : Tipo creado para almacenar rectangulos
        de valores reales.  Extraidos en forma transitoria
        de hojas de calculo en aplicaciones diversas.
}

    ArregloDoubleSector         : CAFE_ArregloDouble;
{
  ArregloDoubleSector           : Contiene el dicho arreglo extraido
        como cadena lineal
}

    FilasDouble,
{
  FilasDouble                   : Filas del ArregloDoubleSector
        interpretado como bidimensional (el arreglo en si
        se define lineal)
        FilasDouble*ColumnasDouble = Length( ArregloDoubleSector )
}

    ColumnasDouble              : LongInt;
{
  ColumnasDouble                : Columnas del ArregloDoubleSector
        interpretado como bidimensional (el arreglo en si
        se define lineal)
        FilasDouble*ColumnasDouble = Length( ArregloDoubleSector )
}

    ClaveCicloRectangular       : LongInt;
{
  ClaveCicloRectangular         : almacena el numero de ciclo sintactico
        que origino la ejecucion del paquete.
        En la actualidad se ordena la destruccion
        del paquete
        cada nuevo ciclo sintactico que genera un paquete.
}

    BanderaRectangular          : Boolean;
{
  BanderaRectangular            : TRUE indica activo;  FALSE que
        se encuentra inactivo, y lista para sobreescribirse.
}

                                  END;  { CAFE_PaqueteRectangular }

  CAFE_ListaRectangular         = ARRAY OF CAFE_PaqueteRectangular;
{
  CAFE_ListaRectangular         : Define un tipo de lista
        de paquetes de datos rectangulares extraidos de hoja de calculo
}

CONST
  CAFE_CeroPaqueteRectangular   : CAFE_PaqueteRectangular       =
        (
          ArregloDoubleSector   : NIL;
          FilasDouble           : 0;
          ColumnasDouble        : 0;
          ClaveCicloRectangular : 0;
          BanderaRectangular    : FALSE;
        );
{
  CAFE_CeroPaqueteRectangular   : Define un dato nulo para
        CAFE_PaqueteRectangular.  Valor establecido al deshacer un paquete
}

  CAFE_TamanoListaRectangular   = 100;
{
  CAFE_TamanoListaRectangular   : Define el total de paquetes
        rectangulares maximo.  Puede verse como el limite
        por calculo individual.
        NOTA: cada nuevo ciclo sintactico tiende a destruir los paquetes
}

VAR
  CAFE_ItemListaRectangular     : CAFE_TCollectionRectangular;
{
  CAFE_ItemListaRectangular     : contiene la lista de CAFE_ItemRectangular
        de vida transitoria que se han extraido en la ejecucion
        de EJES.EXE
}

 VAR
  CAFE_IdentificadorCicloSintactico             : LongInt = 0;
{
  CAFE_IdentificadorCicloSintactico             : Cada vez que se
        inicia un calculo de casilla, se genera un numero de
        CicloSintactico, este es el valor actual asignado.
        No iniciamos en cero, para evitar posible confusion con la
        ausencia de ciclo que es cero.
        Tambien se genera un numero por iniciativa
        de CAFE_Nudo2Sintactico cuando lo requiera, por no encontrar
        un valor asignado. i.e. calculo semiindependiente
}

  CAFE_IncrementoIdentificadorCicloSintactico   : LongInt = 1;
{
  CAFE_IncrementoIdentificadorCicloSintactico   : Cada vez que se
        inicia un calculo de casilla, se genera un nuevo numero
        aplicando
        Inc( CAFE_IdentificadorCicloSintactico,
                CAFE_IncrementoIdentificadorCicloSintactico )
        Como se ve el numero es secuencial;  segun el valor
        de CAFE_IncrementoIdentificadorCicloSintactico
}

CONST
  TVarRecNull           : TVarRec       =
        ( VType                         : vtVariant;
          VVariant                      : Pointer( NIL )                );
{
  TVarRecNull           : Valor a interpretar como No asignado en el
        tipo TVarRec
}

TYPE
  CAFE_FuncionUnSingle                  =
                FUNCTION  ( X : Double; P : Pointer ) : Double;
{
  CAFE_FuncionUnSingle                  : Tipo de funcion base unidimensional
        util en muchos algoritmos de la unidad
}

OPERATOR    = ( CONST Left, Right       : TVarRec                       )
MyResult    : Boolean; experimental;
{
  Operator =
        Para definir la igualdad del operador =.
        OPERATOR no se ha probado
  Left                                  : Termino izquiero de la igualdad
  Right                                 : Termino dereco de la igualdad
  OPERATOR =                            : TRUE si se considera cumplida
        la igualdad de TVarRec
}

FUNCTION    NombreCasillaHoja
  ( CONST NombrePrueba                  : ShortString           ) : Boolean;
{
  FUNCTION NombreCasillaHoja
        Indica si NombrePrueba es un nombre valido de casilla
        Se utilizan como limites maximo CAFE_TamanoHojaSeguridad
        Esta es una funcion Overload
  NombrePrueba                  : Nombre de casilla a probar,
        que deberia estar en mayuscula.  Se admite el simbolo
        dolar como indicador de direccionamiento absoluto en el copiado
  FUNCTION NombreCasillaHoja            : devuelve TRUE para indicar
        nombre valido y FALSE para nombre invalido
}

  { DOBLE CODIGO }
  {$IFDEF CPUI386_CPU32}
FUNCTION    NombreCasillaHoja
  ( CONST NombrePrueba                  : ShortString;
    OUT   DolarColumna                  : Boolean;
    OUT   Columna                       : LongInt;
    OUT   DolarFila                     : Boolean;
    OUT   Fila                          : LongInt               ) : Boolean;
                                pascal; assembler;
  {$ELSE}
FUNCTION    NombreCasillaHoja
  ( CONST NombrePrueba                  : ShortString;
    OUT   DolarColumna                  : Boolean;
    OUT   Columna                       : LongInt;
    OUT   DolarFila                     : Boolean;
    OUT   Fila                          : LongInt               ) : Boolean;
  {$ENDIF}
  { DOBLE CODIGO }
{
  FUNCTION NombreCasillaHoja
        Indica si NombrePrueba es un nombre valido de casilla
        Se utilizan como limites maximo CAFE_TamanoHojaSeguridad
        El nombre descifrado, se puede accesar en
        las variables OUT
        Esta es una funcion Overload
  NombrePrueba                  : Nombre de casilla a probar,
        que deberia estar en mayuscula.  Se admite el simbolo
        dolar como indicador de direccionamiento absoluto en el copiado
  DolarColumna                  : Indica si la columna
        tiene indicador dolar de direccionamiento absoluto i.e.$AA12
  Columna                       : Numero a partir de 0
        que corresponde a la Columna. i.e. B12 tiene Columna = 1
  DolaFila                      : Indica si la fila
        tiene indicador dolar de direccionamiento absoluto i.e. AA$12
  Fila                          : Numero a partir de 0
        que corresponde a la Fila i.e. B12 tiene Fila = 11
  FUNCTION NombreCasillaHoja            : devuelve TRUE para indicar
        nombre valido y FALSE para nombre invalido
}


  { DOBLE CODIGO }
  {$IFDEF CPUI386_CPU32}
PROCEDURE   GenerarNombreCasillaHoja
  ( OUT   NombreCasilla                 : ShortString;
          DolarColumna                  : Boolean;
          Columna                       : LongInt;
          DolarFila                     : Boolean;
          Fila                          : LongInt                       );
                                pascal; assembler;
  {$ELSE}
PROCEDURE   GenerarNombreCasillaHoja
  ( OUT   NombrePrueba                  : ShortString;
          DolarColumna                  : Boolean;
          Columna                       : LongInt;
          DolarFila                     : Boolean;
          Fila                          : LongInt                       );
  {$ENDIF}
  { DOBLE CODIGO }
{
  PROCEDURE GenerarNombreCasilla
        A partir de la descripcion de la casilla,
        se genera un nombre valido en mayuscula
        i.e. Columna 0 Fila 4 --> A3
  NombrePrueba                          :
        Nombre generado a partir de la descripcion
  DolarColumna                          : TRUE le agrega el signo
        dolar de direccionamiento absoluto a la Columna (letra)
  Columna                               : numero a partir de cero,
        que identifica la columna.  En el nombre final se
        traduce en letras, a partir de A
  DolarFila                             : TRUE le agrega el signo
        dolar de direccionamiento absoluto a la Fila (numero)
  Fila                                  : numero a partir de cero,
        que identifica la fila.  En el nombre final
        se traduce en un numero a partir de 1.
}

FUNCTION    CAFE_GenerarPaqueteRectangular
  (       TamanoFila, TamanoColumna             : LongInt;
          ClaveSintactico                       : LongInt       ) : LongInt;
{
  CAFE_GenerarPaqueteRectangular
        Genera un nuevo paquete de Double rectangular
        El nuevo paquete es de tipo CAFE_PaqueteRectangular
        y se almacena en CAFE_PaqueteListaRectangular
        El paquete rectangular contiene una lista
        lineal Double.  Pero se interpreta
        similar a una matriz bidimensional
        TamanoFila*TamanoColumna = Length( Lista de datos... )
        Los elementos lineales se accesan segun la regla
        (numerado a partir de cero)
                Fila*TamanoColumna+Columna
  TamanoFila                    : Total de filas de una matriz
        bidimensional equivalente a la lista Double lineal que contiene
        el paquete.
  TamanoColumna                 : Total de columnas de una
        matriz bidimensional equivalente a la lista Double
  ClaveSintactico               : La orden de generacion de lista
        probablemente responda a una orden de evaluacion
        en Hoja de Calculo.  Este seria el numero ClaveSintactico
        que corresponda a dicha evaluacion, admisible cero si no aplica
}

FUNCTION    CAFE_VariantValorCompatible
  ( CONST MyVar1, MyInput       : Variant                       ) : Boolean;
{
  FUNCTION CAFE_VariantValorCompatible
        Determina si MyInput es de tipo compatible para asignar
        a MyVar1, sin necesidad de cambio de tipo actual.
        Las reglas aqui diferiran un poco, en la Hoja de Calculo
        Algunas curiosidades:
        A. Null es compatible con todo en ambos parametros
        B. varInteger es compatible con varByte y visceversa
        C. varByte es compatible con varString y es interpretado como Char
        NOTA : La asignacion seria compatible via CAFE_VarCast,
        pero no una asignacion corriente
  MyVar1                        : El variant que recibe la asignacion,
        sin embargo su tipo actual es determinante en FUNCTION
  MyInput                       : El variant que se desea probar
        como asignacion posible a MyVar1
  FUNCTION CAFE_VariantValorCompatible  : TRUE para indicar compatibilidad
        y FALSE no es compatible
}

FUNCTION    CAFE_TypeSimpleValorCompatible
  (       MyVar1, MyInput       : SizeInt                       ) : Boolean;
{
  FUNCTION CAFE_TypeSimpleValorCompatible
        Trata de determinar compatibilidad con dos tipos de variantes
        Se solicita MyVar1 y se recibe MyInput.
        varNull es compatible con todo en cualquier parametro.
        varByte en MyInput es compatible con varString en MyVar1
        y se interpreta como CHAR.
        ADVERTENCIA: varByte en MyVar1 es unicamente compatible
           con varByte en MyInput
           esto difiere de FUNCTION CAFE_VariantValorCompatible
           y en muchos casos no resultara conveniente.
           Se eligio esta regla por comodidad para asignar
           la sobrecarga OverloadNITI.
  MyVar1                        : Tipo Solicitado
  MyInput                       : Tipo hipotetico que se recibe
  CAFE_TypeSimpleValorCompatible        : TRUE indica compatibilidad
        FALSE indica incompatibilidad
}

FUNCTION    CAFE_DefaultNuloVariant ( MyTipo    : SizeInt       ) : Variant;
{
  FUNCTION CAFE_DefaultNuloVariant
        Intenta asignar el valor nulo correspondiente al tipo
        de variante adecuado.  Sirve por ejemplo para
        interpretar el Null cuando se requiera traduccion,
        y en inicialzacion de variables y casillas.
        NOTA: varBoolean --> FALSE
              varString  --> ''
              varNull    --> Null
  MyTipo                        : Tipo solicitado
  FUNCTION CAFE_DefaultNuloVariante     : devuelve el nulo requerido
}

FUNCTION    CAFE_DefaultNuloCasilla ( MyTipo    : SizeInt       ) : Variant;
{
  FUNCTION CAFE_DefaultNuloVariant
        Intenta asignar el valor nulo correspondiente al tipo
        de variante adecuado.
        Pero previsto para TipoReturn en la definicion de funcionales
        y macros de casilla.  Es decir es un valor nulo y
        auxiliar de inicializacion para visualizar y ejecutar funcionales
        de casilla.  La diferencia unica con CAFE_DefaultNuloVariante
        es el tipo varNull.  Pues en una hoja de calculo la
        casilla nula se interpreta generalmente como valor real.
        NOTA: varBoolean --> FALSE
              varString  --> ''
              varNull    --> 0.0 varDouble
  MyTipo                        : Tipo solicitado
  FUNCTION CAFE_DefaultNuloCasilla      : devuelve el nulo requerido
}

FUNCTION    CAFE_VarCast
  ( OUT   MyVar                 : Variant;
    CONST MyInput               : Variant;
          NuevoType             : SizeInt                       ) : Boolean;
{
  FUNCTION CAFE_VarCast
        Intenta asignar MyInput a MyVar con probable cambio de tipo
        variante.  La compatibilidad previa puede determinarse
        con CAFE_VariantValorCompatible
        Algunas reglas:
        A. Null MyInput se transforma en
                CAFE_DefaultoNuloVariant( NuevoType )
        B. MyInput como varByte es compatible con NuevoType varString
                y se interpreta como un Char --> varString
        C. En el caso genera se trata de aplicar VarCast de FreePascal
  MyVar                         : MyInput transformado
  MyInput                       : Valor a transformar
  NuevoType                     : Tipo solicitado
  FUNCTION CAFE_VarCast         : devuelve TRUE para exito y FALSE para
        fracaso sin error
}

FUNCTION    CAFE_IntegralOctavoImpar
  ( OUT   ResultadoFuncion      : Double;
          X1  , X2              : Double;
          Func                  : CAFE_FuncionUnSingle;
          PunteroParametros     : Pointer;
          DiferenciaConsecutiva : Double;
          Manejador             : CAFE_InterfaceManejador       = NIL   )
                                                                : Boolean;
{
  FUNCTION CAFE_IntegralOctavoImpar
        Devuelve el valor de la integral requerida segun el metodo
        IntegralOctavoImpar (asi le llamo yo, a un polinomio
        de grado 8 recursivo hacia mitades)
  ResultadoFuncion              : Devuelve el resultado de integracion
  X1                            : Limite inferior de integracion
  X2                            : Limite superior de integracion
  Func                          : Funcion a evaluar
  PunteroParametros             : parametro auxiliar que se pasa a Func
        sin modificiones internas
  DiferenciaConsecutiva         : Se ejecuta FUNCTION hasta que
        dos estimaciones sucesivas difieran como maximo en este valor.
        O se supere alguno de los criterios de seguridad.
  FUNCTION CAFE_IntegralOctavoImpar             : TRUE indica exito en
        el proceso.  FALSE indica fracaso.
        NOTA: Errores se intentan atrapar con ON Exception DO...
        que devolveran un FALSE.  Si desea un mensaje de usuario
        mas informativo, podra intentar un RAISE previo en Func.
}

FUNCTION  CAFE_SolvePuntoMedioZonaNula
  ( OUT ResultadoFuncion        : Double;
        X1, X2                  : Double;
        Func                    : CAFE_FuncionUnSingle;
        PunteroParametros       : Pointer;
        ToleranciaPermitida     : Double                        ) : Boolean;
{
  FUNCTION CAFE_SolvePuntoMedioZonaNula
        Intenta obtener un valor X pertenece [X1,X2] que cumpla
        F(X) = 0
        El nombre de FUNCTION se refiere al hecho, que
        ante la presencia de una ZonaNula intentara encontrar
        el limite de la misma.
        Utiliza un metodo de punto medio, asi que resultara muy lento;
        en comparacion con casi cualquier metodo.
        Se considera TRUE cualquier resultado de busqueda;
        unicamente el error de dominio o similar provoca FALSE
  ResultadoFuncion              : Devuelve el resultado solicitado
        en caso de fracaso probablemente sera un extremo
  X1                            : Limite inferior de busqueda
  X2                            : Limite superior de busqueda
  Func                          : Funcion a evaluar
  PunteroParametros             : Puntero libre a pasar a Func
  ToleranciaPermitida           : Exactitud en X del valor reportado
  FUNCTION CAFE_SolvePuntoMedioZonaNula : TRUE como resultado
        de cualquier busqueda, incluyendo las inutiles.
        FALSE si error de ejecucion
}

FUNCTION  CAFE_RedondeoTolerancia
  (     Input                   : Double;
        Tolerancia              : Double                        ) : Double;
{
  FUNCTION CAFE_RedondeoTolerancia
        Intenta redondear Input al total de decimales requerido
        por el valor de Tolerancia.  La idea es que el primer
        digito significativo de Tolerancia, sea tambien
        el ultimo digito significativo de Input.  Esto
        no necesariamente se cumplira en todo parametro.
        Se sugiere pues utilizar valores que comiencen en 5, como tolerancia.
        Tolerancia 0 o dificultades devolveran Input sin cambio.
        No se permiten tolerancia negativa, si redondea decenas,
        centenas, etc.
        i.e.
        Input = 645.341
        Tolerancia = 0.02
        --> 645.34
  Input                         : Valor a corregir por redondeo
  Tolerancia                    : Como  valor Double, la idea
        es obtener un total de digitos apropiados al primer
        digito significativo en Tolerancia
  FUNCTION CAFE_RedondeoTolerancia      : Valor requerido
}

FUNCTION  CAFE_ProductoLista
  ( OUT   Resultado             : Double;
          Lista1, Lista2        : LongInt                       ) : Boolean;
{
  FUNCTION CAFE_ProductoLista
        Las listas se refieren a arreglos reales en
        CAFE_PaqueteListaRectangular, accesados con enteros
        FUNCION realiza el producto punto de dos listas
        que deben tener el mismo tamano
  Resultado                     : Devuelve el producto punto
  Lista1                        : Entero que identifica la primera lista
        en CAFE_PaqueteListaRectangular interpretada como lista lineal
  Lista2                        : Entero que identifica la segunda lista
        en CAFE_PaqueteListaRectangular interpretada como lista lineal
  FUNCTION CAFE_ProductoLista   : TRUE indica exito en el proceso,
        FALSE indica fracaso
}

FUNCTION  CAFE_ProductoLista3
  ( OUT   Resultado                     : Double;
          Lista1, Lista2, Lista3        : LongInt               ) : Boolean;
{
  FUNCTION CAFE_ProductoLista3
        Las listas se refieren a arreglos reales en
        CAFE_PaqueteListaRectangular, accesados con enteros
        FUNCION realiza la suma del producto de tres listas
        que deben tener el mismo tamano
  Resultado                     : Devuelve el valor solicitado
  Lista1                        : Entero que identifica la primera lista
        en CAFE_PaqueteListaRectangular interpretada como lista lineal
  Lista2                        : Entero que identifica la segunda lista
        en CAFE_PaqueteListaRectangular interpretada como lista lineal
  Lista3                        : Entero que identifica la tercera lista
        en CAFE_PaqueteListaRectangular interpretada como lista lineal
  FUNCTION CAFE_ProductoLista3  : TRUE indica exito en el proceso,
        FALSE indica fracaso
}

FUNCTION  CAFE_DeterminanteLista
  ( OUT   Resultado             : Double;
          Lista1                : LongInt                       ) : Boolean;
{
  FUNCTION CAFE_DeterminanteLista
        Las listas se refieren a arreglos reales en
        CAFE_PaqueteListaRectangular, accesados con enteros
        FUNCION calculo el determinante de Lista1 que al
        interpretarse como matriz bidimensional deberia
        resultar en una matriz cuadrada por definicion
  Resultado                     : Devuelve el valor solicitado
  Lista1                        : Entero que identifica la primera lista
        en CAFE_PaqueteListaRectangular interpretada como matriz cuadrada
  FUNCTION CAFE_ProductoLista3  : TRUE indica exito en el proceso,
        FALSE indica fracaso i.e. no es cuadrada
}

FUNCTION  CAFE_InversaLista
  ( OUT   Resultado             : Double;
          Lista1                : LongInt;
          Fila, Columna         : LongInt                       ) : Boolean;
{
  FUNCTION CAFE_InversaLista
        Las listas se refieren a arreglos reales en
        CAFE_PaqueteListaRectangular, accesados con enteros
        FUNCION calcula el valor de una casilla de la matriz inversa
        Lista1 debe interpretarse como matriz bidimensional deberia
        resultar en una matriz cuadrada por definicion
  Resultado                     : Devuelve el valor solicitado
  Lista1                        : Entero que identifica la primera lista
        en CAFE_PaqueteListaRectangular interpretada como matriz cuadrada
  Fila                          : Numerada a partir de cero, se
        refiere a la fila
  Columna                       : Numerada a partir de cero, se
        refiere a la columna
  FUNCTION CAFE_InversaLista    : TRUE indica exito en el proceso,
        FALSE indica fracaso i.e. no es cuadrada
}

FUNCTION  CAFE_SistemaLista
  ( OUT   Resultado             : Double;
          Lista1, Lista2        : LongInt;
          Fila                  : LongInt                       ) : Boolean;
{
  FUNCTION CAFE_SistemaLista
        Las listas se refieren a arreglos reales en
        CAFE_PaqueteListaRectangular, accesados con enteros
        FUNCION calcula el valor de una variable que resuelve
        el sistema [Lista1]n*n * [X]n*1 = [Lista2]n*1
        Fila define la variable a resolver a partir de cero.
        [Lista1]n*n debe interpretarse como matriz bidimensional deberia
        resultar en una matriz cuadrada por definicion
        [Lista2]n*1 es un vector, pero es flexible en cuanto
        a forma de la zona, siempre y cuando tenga
        el numero de elementos apropiado
  Resultado                     : Devuelve el valor de variable solicitado
        numerada apartir de cero
  Lista1                        : Entero que identifica la primera lista
        en CAFE_PaqueteListaRectangular interpretada como matriz cuadrada
  Lista2                        : Entero que representa la lista
        de soluciones del producto matriz*variable del sistema
        lineal.  Es flexible en cuanto a forma pero no a tamano.
  Fila                          : Numerada a partir de cero, se
        refiere a la variable que se solicita resolver.
        Se utiliza metodo Kramer.
  FUNCTION CAFE_SistemaLista    : TRUE indica exito en el proceso,
        FALSE indica fracaso i.e. no es cuadrada
}

FUNCTION  CAFE_CovarianzaLista
  ( OUT   Resultado             : Double;
          Lista1, Lista2        : LongInt                       ) : Boolean;
{
  FUNCTION CAFE_CovarianzaLista
        Calcula la covarianza entre dos listas del mismo tamano
                (Suma(Xi*Yi)-Suma(Xi)*Suma(Yi)/N)/(N-1)
  Resultado                     : Devuelve el valor de covarianza solicitada
  Lista1                        : Entero que identifica la primera lista
        en CAFE_PaqueteListaRectangular interpretada como arreglo lineal
  Lista2                        : Entero que identifica la segunda lista
        en CAFE_PaqueteListaRectangular interpretada como arreglo lineal
  FUNCTION CAFE_CovarianzaLista : TRUE indica exito en el proceso,
        FALSE indica fracaso
}

FUNCTION CAFE_FormatDate
  (       MyDate                : TDateTime;
    CONST MyFormat              : ShortString   = '';
          MyLength              : LongInt       = 0     ) : ShortString;
{
  FUNCTION CAFE_FormatDate
        Para formatear MyDate a String.  '' aplica
        CAFE_FormatDateDefault con CAFE_TamanoFormatDate
  MyDate                        : fecha a transformar
  MyFormat                      : permite agregar un formato al date
  MyLength                      : permite intentar una justificacion
        con espacios a la izquierda 0 no aplica.
  FUNCTION CAFE_FormatDate      : ShortString solicitado
}

VAR
  CAFE_MoldeManejadorCharByte           : CAFE_ReferenciaCharByte;
{
  CAFE_MoldeManejadorCharByte           :
        Molde para que CAFE_ManejadorBasico genera CharByte internos
}

  CAFE_MoldeManejadorArbol              : CAFE_ReferenciaNudoSintactico;
{
  CAFE_MoldeManejadorArbol              :
        Molde para que CAFE_ManejadorBasico genero arboles sintacticos
}

  CAFE_MoldeManejadorDatoCasilla        : CAFE_ReferenciaDatoExtendido;
{
  CAFE_MoldeManejadorDatoCasilla        :
        Molde para que CAFE_ManejadorBasico genere Dato Extendido
}

  CAFE_MoldeManejadorPaquete            : CAFE_ReferenciaInterpreteSintactico;
{
  CAFE_MoldeManejadorPaquete            :
        Molde para que CAFE_ManejadorBasico genere Interprete Sintactico
}

IMPLEMENTATION

{ IMPLEMENTATION }
CONST
  // Advertencia al agregar una nueva funcion:
  // 1. Actualice
  //    a. TotalFuncionPredefinidas
  //    b. Crea un numero clave unico
  //    c. Agregue la funcion a ArregloFuncionPredefinida
  //    d. Actualice el CASE en EvaluarPredefinidoFuncionalSimple
  // 2. Recuerde colocar el Overload Integer de primero en el array antes
  // del Double, la clave no importa (requiere OverloadNITI para activar)
  // 3. Unicamente se permiten valores default nulos (CAFE_DefaultNuloVariant)
  // se exige [ActivarDefaultNITI, AnularDefaultNITI]
  // Se indica el parametro con default mediante la(s) bandera(s),
  // PrimeroDefaultNITI, SegundoDefaultNITI, TerceroDefaultNITI
  // 4. Es bastante probable que surja una confusion
  // con OverloadNITI y ActivarDefaultNITI
  // La prioridad es el orden en ArregloFuncionPredefinida
  // y se intenta el ActivarDefaultNITI antes del OverloadNITI CUIDADO!!!

  // Esta numeracion no es definitiva..., disculpas
  TotalFuncionPredefinidas      = 200;
  ClaveAnyStd                   = 1;
  ClaveParentesisDouble         = ClaveAnyStd;
  ClaveParentesisInteger        = ClaveParentesisDouble+1;
  ClaveParentesisBoolean        = ClaveParentesisDouble+2;
  ClaveParentesisString         = ClaveParentesisDouble+3;
  ClaveParentesisByte           = ClaveParentesisDouble+4;
  ClaveIfThenDouble             = 10;
  ClaveIfThenInteger            = ClaveIfThenDouble+1;
  ClaveIfThenBoolean            = ClaveIfThenDouble+2;
  ClaveIfThenString             = ClaveIfThenDouble+3;
  ClaveIfThenByte               = ClaveIfThenDouble+4;
  ClaveIfDominioDouble          = ClaveIfThenDouble+5;
  ClaveOperadorStd              = 51;
  ClaveOperadorPositivo         = ClaveOperadorStd;
  ClaveOperadorNegativo         = ClaveOperadorPositivo+1;
  ClaveOperadorSuma             = ClaveOperadorPositivo+2;
  ClaveOperadorResta            = ClaveOperadorPositivo+3;
  ClaveOperadorMultiplicacion   = ClaveOperadorPositivo+4;
  ClaveOperadorDivision         = ClaveOperadorPositivo+5;
  ClaveOperadorMOD              = ClaveOperadorPositivo+6;
  ClaveOperadorDIV              = ClaveOperadorPositivo+7;
  ClaveOperadorSumaString       = ClaveOperadorPositivo+8;
  ClaveIgualAritmetico          = ClaveOperadorPositivo+9;
  ClaveDiferenteAritmetico      = ClaveOperadorPositivo+10;
  ClaveMayor                    = ClaveOperadorPositivo+11;
  ClaveMayorIgual               = ClaveOperadorPositivo+12;
  ClaveMenor                    = ClaveOperadorPositivo+13;
  ClaveMenorIgual               = ClaveOperadorPositivo+14;
  ClaveIgualBoolean             = ClaveOperadorPositivo+15;
  ClaveDiferenteBoolean         = ClaveOperadorPositivo+16;
  ClaveOperadorPositivoInt      = ClaveOperadorPositivo+17;
  ClaveOperadorNegativoInt      = ClaveOperadorPositivo+18;
  ClaveOperadorSumaInt          = ClaveOperadorPositivo+19;
  ClaveOperadorRestaInt         = ClaveOperadorPositivo+20;
  ClaveOperadorMultiplicacionInt= ClaveOperadorPositivo+21;
  ClaveOperadorStringBasico     = ClaveOperadorPositivo+22;
  ClaveOperadorCHR              = ClaveOperadorPositivo+23;
  ClaveCastByte                 = ClaveOperadorPositivo+24;
  ClaveOperadorSHR              = ClaveOperadorPositivo+25;
  ClaveOperadorSHL              = ClaveOperadorPositivo+26;
  ClaveStd                      = 101;
  ClaveSin                      = ClaveStd;
  ClaveCos                      = ClaveSin+1;
  ClaveExp                      = ClaveSin+2;
  ClaveLn                       = ClaveSin+3;
  ClaveArcTan                   = ClaveSin+4;
  ClaveArcTan2                  = ClaveSin+5;
  ClaveFrac                     = ClaveSin+6;
  ClaveRound                    = ClaveSin+7;
  ClaveSqr                      = ClaveSin+8;
  ClaveSqrt                     = ClaveSin+9;
  ClaveTrunc                    = ClaveSin+10;
  ClaveAbs                      = ClaveSin+11;
  ClaveNOT                      = ClaveSin+12;
  ClaveAND                      = ClaveSin+13;
  ClaveOR                       = ClaveSin+14;
  ClaveXOR                      = ClaveSin+15;
  ClaveCopy                     = ClaveSin+16;
  ClaveRandom                   = ClaveSin+17;
  ClaveLengthString             = ClaveSin+18;
  ClaveInsertar                 = ClaveSin+19;
  ClaveToValDouble              = ClaveSin+20;
  ClaveToStrInteger1            = ClaveSin+22;
  ClaveToStrInteger2            = ClaveSin+23;
  ClaveToStrDouble1             = ClaveSin+24;
  ClaveToStrDouble2             = ClaveSin+25;
  ClaveToStrDouble3             = ClaveSin+26;
  ClaveUpCase                   = ClaveSin+27;
  ClaveLowerCase                = ClaveSin+28;
  ClaveTDateTime                = ClaveSin+29;
  ClaveDaysBetween              = ClaveSin+30;
  ClaveIncDay                   = ClaveSin+31;
  ClaveIncWeek                  = ClaveSin+32;
  ClaveIncMonth                 = ClaveSin+33;
  ClaveIncYear                  = ClaveSin+34;
  ClaveIncDayOvl                = ClaveSin+35;
  ClaveIncWeekOvl               = ClaveSin+36;
  ClaveIncMonthOvl              = ClaveSin+37;
  ClaveIncYearOvl               = ClaveSin+38;
  ClaveIsLeapYear               = ClaveSin+39;
  ClaveDayOf                    = ClaveSin+40;
  ClaveWeekOf                   = ClaveSin+41;
  ClaveMonthOf                  = ClaveSin+42;
  ClaveYearOf                   = ClaveSin+43;
  ClaveDaySpan                  = ClaveSin+44;
  ClaveWeekSpan                 = ClaveSin+45;
  ClaveMonthSpan                = ClaveSin+46;
  ClaveYearSpan                 = ClaveSin+47;
  ClaveEncodeDate               = ClaveSin+48;
  ClaveCastDouble               = ClaveSin+49;
  ClaveMath                     = 201;
  ClaveArcCos                   = ClaveMath;
  ClaveArcCosH                  = ClaveMath+1;
  ClaveArCosH                   = ClaveMath+2;
  ClaveArcSin                   = ClaveMath+3;
  ClaveArcSinH                  = ClaveMath+4;
  ClaveArcTanH                  = ClaveMath+5;
  ClaveArSinH                   = ClaveMath+6;
  ClaveArTanH                   = ClaveMath+7;
  ClaveCeil                     = ClaveMath+8;
  ClaveCompareValue             = ClaveMath+9;
  ClaveCosecant                 = ClaveMath+10;
  ClaveCosH                     = ClaveMath+11;
  ClaveCot                      = ClaveMath+12;
  ClaveCotan                    = ClaveMath+13;
  ClaveCsc                      = ClaveMath+14;
  ClaveCycleToRad               = ClaveMath+15;
  ClaveDegToGrad                = ClaveMath+16;
  ClaveDegToRad                 = ClaveMath+17;
  ClaveEnsureRangeDouble        = ClaveMath+18;
  ClaveFloor                    = ClaveMath+19;
  ClaveGradToDeg                = ClaveMath+20;
  ClaveGradToRad                = ClaveMath+21;
  ClaveHypot                    = ClaveMath+22;
  ClaveInRange                  = ClaveMath+23;
  ClaveIntPower                 = ClaveMath+24;
  ClaveIsZero                   = ClaveMath+25;
  ClaveLdExp                    = ClaveMath+26;
  ClaveLnXp1                    = ClaveMath+27;
  ClaveLog10                    = ClaveMath+28;
  ClaveLog2                     = ClaveMath+29;
  ClaveLogN                     = ClaveMath+30;
  ClaveMaxDouble                = ClaveMath+31;
  ClaveMinDouble                = ClaveMath+32;
  ClavePower                    = ClaveMath+33;
  ClaveRadToCycle               = ClaveMath+34;
  ClaveRadToDeg                 = ClaveMath+35;
  ClaveRadToGrad                = ClaveMath+36;
  ClaveRandG                    = ClaveMath+37;
  ClaveRandomRange              = ClaveMath+38;
  ClaveRoundTo                  = ClaveMath+39;
  ClaveSameValue                = ClaveMath+40;
  ClaveSec                      = ClaveMath+41;
  ClaveSecant                   = ClaveMath+42;
  ClaveSign                     = ClaveMath+43;
  ClaveSimpleRoundTo            = ClaveMath+44;
  ClaveSinH                     = ClaveMath+45;
  ClaveTan                      = ClaveMath+46;
  ClaveTanH                     = ClaveMath+47;
  ClaveEnsureRangeInteger       = ClaveMath+48;
  ClaveMaxInteger               = ClaveMath+49;
  ClaveMinInteger               = ClaveMath+50;
  ClaveLengthArray              = ClaveMath+51;
  ClaveMathOperador             = 301;
  ClaveOperadorPower            = ClaveMathOperador;
  ClaveMathArray                = 321;
  ClaveMean                     = ClaveMathArray;
  ClaveSum                      = ClaveMathArray+1;
  ClaveStdDev                   = ClaveMathArray+2;
  ClaveVariance                 = ClaveMathArray+3;
  ClaveTotalVariance            = ClaveMathArray+4;
  ClaveNorm                     = ClaveMathArray+5;
  ClaveSumOfSquares             = ClaveMathArray+6;
  ClaveMinValue                 = ClaveMathArray+7;
  ClaveMaxValue                 = ClaveMathArray+8;
  ClavePopNStdDev               = ClaveMathArray+9;
  ClavePopNVariance             = ClaveMathArray+10;
  ClaveRandomFrom               = ClaveMathArray+11;
  ClaveEjesOperador             = 351;
  ClaveOperadorFactorial        = ClaveEjesOperador;
  ClaveOperadorPotenciaDos      = ClaveEjesOperador+1;
  ClaveOperadorPotenciaTres     = ClaveEjesOperador+2;
  ClaveEjesIdentificador        = 371;
  ClaveEjesIdentificadorRandom                  = ClaveEjesIdentificador;
  ClaveEjesIdentificadorFijarEnFila             = ClaveEjesIdentificador+1;
  ClaveEjesIdentificadorFijarEnColumna          = ClaveEjesIdentificador+2;
  ClaveEjesIdentificadorSelf                    = ClaveEjesIdentificador+3;
  ClaveEjesIdentificadorHoy                     = ClaveEjesIdentificador+4;
  ClaveEjesFuncion              = 401;
  ClaveEjesFactorial            = ClaveEjesFuncion;
  ClaveEjesLaplace              = ClaveEjesFuncion+1;
  ClaveEjesGamma                = ClaveEjesFuncion+2;
  ClaveEjesLaplaceInversa       = ClaveEjesFuncion+3;
  ClaveEjesNormal               = ClaveEjesFuncion+4;
  ClaveEjesNormalInversa        = ClaveEjesFuncion+5;
  ClaveEjesDistribucionNormal   = ClaveEjesFuncion+6;
  ClaveEjesBeta                 = ClaveEjesFuncion+7;
  ClaveEjesTStudent             = ClaveEjesFuncion+8;
  ClaveEjesTStudentInversa      = ClaveEjesFuncion+9;
  ClaveEjesDistribucionTStudent = ClaveEjesFuncion+10;
  ClaveEjesChiSquare            = ClaveEjesFuncion+11;
  ClaveEjesChiSquareInversa     = ClaveEjesFuncion+12;
  ClaveEjesDistribucionChiSquare                = ClaveEjesFuncion+13;
  ClaveEjesIntegralF            = ClaveEjesFuncion+14;
  ClaveEjesIntegralFInversa     = ClaveEjesFuncion+15;
  ClaveEjesDistribucionF        = ClaveEjesFuncion+16;
  ClaveEjesProductoPunto        = ClaveEjesFuncion+17;
  ClaveEjesDeterminante         = ClaveEjesFuncion+18;
  ClaveEjesCasillaInversa       = ClaveEjesFuncion+19;
  ClaveEjesCasillaSistema       = ClaveEjesFuncion+20;
  ClaveEjesMomento1             = ClaveEjesFuncion+21;
  ClaveEjesMomento2             = ClaveEjesFuncion+22;
  ClaveEjesMomento3             = ClaveEjesFuncion+23;
  ClaveEjesMomento4             = ClaveEjesFuncion+24;
  ClaveEjesSkew                 = ClaveEjesFuncion+25;
  ClaveEjesKurtosis             = ClaveEjesFuncion+26;
  ClaveEjesCovariance           = ClaveEjesFuncion+27;
  ClaveEjesPendiente            = ClaveEjesFuncion+28;
  ClaveEjesInterseccion         = ClaveEjesFuncion+29;
  ClaveEjesCoeficienteCorrelacion               = ClaveEjesFuncion+30;
  ClaveEjesSumaProductos2       = ClaveEjesFuncion+31;
  ClaveEjesSumaProductos3       = ClaveEjesFuncion+32;
  ClaveEjesCubo                 = ClaveEjesFuncion+33;
  ClaveEjesUnoDouble            = ClaveEjesFuncion+34;
  ClaveEjesUnoBoolean           = ClaveEjesFuncion+35;
  ClaveEjesCastBoolean          = ClaveEjesFuncion+36;
  ClaveEjesFormatDate           = ClaveEjesFuncion+37;
  ClaveEjesHoy                  = ClaveEjesFuncion+38;
  ClaveEjesDayOfWeek            = ClaveEjesFuncion+39;
  ClaveEjesNombreMes            = ClaveEjesFuncion+40;
  ClaveEjesNombreDia            = ClaveEjesFuncion+41;
  ClaveEjesNombreMesCorto       = ClaveEjesFuncion+42;
  ClaveEjesNombreDiaCorto       = ClaveEjesFuncion+43;
  ClaveEjesDolarCasilla         = ClaveEjesFuncion+44;
  ClaveEjesExtraNoEnLista       = 501;
  ClaveEjesExtraTipoSector      = ClaveEjesExtraNoEnLista;
  ClaveEjesExtraTipoRegistro    = ClaveEjesExtraNoEnLista+1;

TYPE
  CampoFuncionPredefinida       = RECORD

    NombreFuncionPredefinida            : ShortString;
    AliasFuncionPredefinida             : ShortString;
    ClaveFuncionPredefinida             : LongInt;
    EspecialFuncionPredefinida          : CAFE_ConjuntoTipoInterprete;
    TipoFuncionPredefinida              : SizeInt;
    Parametro1FuncionPredefinida        : SizeInt;
    Parametro2FuncionPredefinida        : SizeInt;
    Parametro3FuncionPredefinida        : SizeInt;

                                  END;  { RECORD CampoFuncionPredefinida }

VAR
  ArregloFuncionPredefinida     :
        ARRAY [ 1..TotalFuncionPredefinidas ] OF CampoFuncionPredefinida =
                (
                  ( NombreFuncionPredefinida            :
                                        CAFE_OperadorCHRSintactico;
                    AliasFuncionPredefinida             : 'CARACTER()';
                    ClaveFuncionPredefinida             : ClaveOperadorCHR;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'BYTE()';
                    AliasFuncionPredefinida             : 'ENTEROBREVE()';
                    ClaveFuncionPredefinida             : ClaveCastByte;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varByte;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_OperadorParentesisTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveParentesisByte;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varByte;
                    Parametro1FuncionPredefinida        : varByte;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_OperadorParentesisTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveParentesisInteger;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_OperadorParentesisTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveParentesisDouble;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_OperadorParentesisTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveParentesisBoolean;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_OperadorParentesisTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveParentesisString;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varString;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'IFTHEN()';
                    AliasFuncionPredefinida             : 'SIENTONCES()';
                    ClaveFuncionPredefinida             :
                        ClaveIfThenString;
                    EspecialFuncionPredefinida          :
                      [ OverloadNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varByte;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varByte;
                    Parametro3FuncionPredefinida        : varByte       ),
                  ( NombreFuncionPredefinida            : 'IFTHEN()';
                    AliasFuncionPredefinida             : 'SIENTONCES()';
                    ClaveFuncionPredefinida             :
                        ClaveIfThenInteger;
                    EspecialFuncionPredefinida          :
                      [ OverloadNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varInteger    ),
                  ( NombreFuncionPredefinida            : 'IFTHEN()';
                    AliasFuncionPredefinida             : 'SIENTONCES()';
                    ClaveFuncionPredefinida             :
                        ClaveIfThenDouble;
                    EspecialFuncionPredefinida          :
                      [ OverloadNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            : 'IFDOMINIO()';
                    AliasFuncionPredefinida             : 'SIDOMINIO()';
                    ClaveFuncionPredefinida             :
                        ClaveIfDominioDouble;
                    EspecialFuncionPredefinida          :
                      [ OverloadNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            : 'IFTHEN()';
                    AliasFuncionPredefinida             : 'SIENTONCES()';
                    ClaveFuncionPredefinida             :
                        ClaveIfThenBoolean;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varBoolean;
                    Parametro3FuncionPredefinida        : varBoolean    ),
                  ( NombreFuncionPredefinida            : 'IFTHEN()';
                    AliasFuncionPredefinida             : 'SIENTONCES()';
                    ClaveFuncionPredefinida             :
                        ClaveIfThenString;
                    EspecialFuncionPredefinida          :
                      [ OverloadNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varString;
                    Parametro3FuncionPredefinida        : varString     ),
                  ( NombreFuncionPredefinida            :
                        CAFE_PositivoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorPositivoInt;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_NegativoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorNegativoInt;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_SumaTraducidaOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorSumaInt;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_RestaTraducidaOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorRestaInt;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_MultiplicacionTraducidaOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorMultiplicacionInt;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_OperadorStringTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorStringBasico;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_PositivoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorPositivo;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_NegativoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorNegativo;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_SumaTraducidaOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorSuma;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_RestaTraducidaOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorResta;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_MultiplicacionTraducidaOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorMultiplicacion;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_DivisionTraducidaOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorDivision;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_DIVAritmeticoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorDIV;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_SHRBinarioTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorSHR;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_SHLBinarioTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorSHL;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_MODAritmeticoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorMOD;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_SumaTraducidaOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveOperadorSumaString;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varString;
                    Parametro2FuncionPredefinida        : varString;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_NegacionBinariaTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveNOT;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_ANDBinarioTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveAND;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varBoolean;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_ORBinarioTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveOR;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varBoolean;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_XORBinarioTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveXOR;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varBoolean;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_IgualLogicoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveIgualAritmetico;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_NoIgualLogicoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveDiferenteAritmetico;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_MayorTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveMayor;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_MayorIgualTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveMayorIgual;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_MenorTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveMenor;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_MenorIgualTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveMenorIgual;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_IgualLogicoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveIgualBoolean;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varBoolean;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                        CAFE_NoIgualLogicoTraducidoOperadorBasico;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                        ClaveDiferenteBoolean;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varBoolean;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SIN()';
                    AliasFuncionPredefinida             : 'SENO()';
                    ClaveFuncionPredefinida             : ClaveSin;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'COS()';
                    AliasFuncionPredefinida             : 'COSENO()';
                    ClaveFuncionPredefinida             : ClaveCos;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'EXP()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveExp;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'LN()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveLn;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ARCTAN()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveArcTan;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ARCTAN2()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveArcTan2;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'FRAC()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveFrac;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ROUND()';
                    AliasFuncionPredefinida             : 'REDONDEO()';
                    ClaveFuncionPredefinida             : ClaveRound;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SQR()';
                    AliasFuncionPredefinida             : 'CUAD()';
                    ClaveFuncionPredefinida             : ClaveSqr;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SQRT()';
                    AliasFuncionPredefinida             : 'RAIZ()';
                    ClaveFuncionPredefinida             : ClaveSqrt;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'RANDOM()';
                    AliasFuncionPredefinida             : 'AZAR()';
                    ClaveFuncionPredefinida             : ClaveRandom;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TRUNC()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveTrunc;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ABS()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveAbs;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'COPY()';
                    AliasFuncionPredefinida             : 'COPIAR()';
                    ClaveFuncionPredefinida             : ClaveCopy;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varString;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varInteger    ),
                  ( NombreFuncionPredefinida            : 'UPPERCASE()';
                    AliasFuncionPredefinida             : 'MAYUSCULA()';
                    ClaveFuncionPredefinida             : ClaveUpCase;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varString;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'LOWERCASE()';
                    AliasFuncionPredefinida             : 'MINUSCULA()';
                    ClaveFuncionPredefinida             : ClaveLowerCase;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varString;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'FORMATDATE()';
                    AliasFuncionPredefinida             : 'FORMATOFECHA()';
                    ClaveFuncionPredefinida             : ClaveEjesFormatDate;
                    EspecialFuncionPredefinida          :
                        [ ActivarDefaultNITI, SegundoDefaultNITI,
                          TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varString;
                    Parametro3FuncionPredefinida        : varInteger   ),
                  ( NombreFuncionPredefinida            : 'TDATETIME()';
                    AliasFuncionPredefinida             : 'CODIGOAFECHA()';
                    ClaveFuncionPredefinida             : ClaveTDateTime;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'DOUBLE()';
                    AliasFuncionPredefinida             : 'REAL()';
                    ClaveFuncionPredefinida             : ClaveCastDouble;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'DAYSBETWEEN()';
                    AliasFuncionPredefinida             : 'DIASENTRE()';
                    ClaveFuncionPredefinida             : ClaveDaysBetween;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varDate;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'INCDAY()';
                    AliasFuncionPredefinida             : 'INCDIA()';
                    ClaveFuncionPredefinida             : ClaveIncDay;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'INCWEEK()';
                    AliasFuncionPredefinida             : 'INCSEMANA()';
                    ClaveFuncionPredefinida             : ClaveIncWeek;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'INCMONTH()';
                    AliasFuncionPredefinida             : 'INCMES()';
                    ClaveFuncionPredefinida             : ClaveIncMonth;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'INCYEAR()';
                    AliasFuncionPredefinida             : 'INCANUAL()';
                    ClaveFuncionPredefinida             : ClaveIncYear;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'INCDAY()';
                    AliasFuncionPredefinida             : 'INCDIA()';
                    ClaveFuncionPredefinida             : ClaveIncDayOvl;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'INCWEEK()';
                    AliasFuncionPredefinida             : 'INCSEMANA()';
                    ClaveFuncionPredefinida             : ClaveIncWeekOvl;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'INCMONTH()';
                    AliasFuncionPredefinida             : 'INCMES()';
                    ClaveFuncionPredefinida             : ClaveIncMonthOvl;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'INCYEAR()';
                    AliasFuncionPredefinida             : 'INCANUAL()';
                    ClaveFuncionPredefinida             : ClaveIncYearOvl;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ISLEAPYEAR()';
                    AliasFuncionPredefinida             : 'ESBISIESTO()';
                    ClaveFuncionPredefinida             : ClaveIsLeapYear;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'DAYOF()';
                    AliasFuncionPredefinida             : 'DIADE()';
                    ClaveFuncionPredefinida             : ClaveDayOf;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'WEEKOF()';
                    AliasFuncionPredefinida             : 'SEMANADE()';
                    ClaveFuncionPredefinida             : ClaveWeekOf;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MONTHOF()';
                    AliasFuncionPredefinida             : 'MESDE()';
                    ClaveFuncionPredefinida             : ClaveMonthOf;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'YEAROF()';
                    AliasFuncionPredefinida             : 'ANUALDE()';
                    ClaveFuncionPredefinida             : ClaveYearOf;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'DAYSPAN()';
                    AliasFuncionPredefinida             : 'FRACCIONDIA()';
                    ClaveFuncionPredefinida             : ClaveDaySpan;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varDate;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'WEEKSPAN()';
                    AliasFuncionPredefinida             : 'FRACCIONSEMANA()';
                    ClaveFuncionPredefinida             : ClaveWeekSpan;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varDate;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'MONTHSPAN()';
                    AliasFuncionPredefinida             : 'FRACCIONMES()';
                    ClaveFuncionPredefinida             : ClaveMonthSpan;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varDate;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'YEARSPAN()';
                    AliasFuncionPredefinida             : 'FRACCIONANUAL()';
                    ClaveFuncionPredefinida             : ClaveYearSpan;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varDate;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'ENCODEDATE()';
                    AliasFuncionPredefinida             : 'FECHAACODIGO()';
                    ClaveFuncionPredefinida             : ClaveEncodeDate;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varInteger   ),
                  ( NombreFuncionPredefinida            : 'HOY()';
                    AliasFuncionPredefinida             : 'TODAY()';
                    ClaveFuncionPredefinida             : ClaveEjesHoy;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDate;
                    Parametro1FuncionPredefinida        : varNull;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'DAYOFWEEK()';
                    AliasFuncionPredefinida             : 'DIADESEMANA()';
                    ClaveFuncionPredefinida             : ClaveEjesDayOfWeek;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDate;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'NOMBREMES()';
                    AliasFuncionPredefinida             : 'MONTHNAME()';
                    ClaveFuncionPredefinida             : ClaveEjesNombreMes;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'NOMBREDIA()';
                    AliasFuncionPredefinida             : 'DAYNAME()';
                    ClaveFuncionPredefinida             : ClaveEjesNombreDia;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'NOMBREMESCORTO()';
                    AliasFuncionPredefinida             : 'SHORTMONTHNAME()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesNombreMesCorto;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'NOMBREDIACORTO()';
                    AliasFuncionPredefinida             : 'SHORTDAYNAME()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesNombreDiaCorto;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull      ),
                  ( NombreFuncionPredefinida            : 'LENGTH()';
                    AliasFuncionPredefinida             : 'LARGO()';
                    ClaveFuncionPredefinida             : ClaveLengthString;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varString;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'LENGTH()';
                    AliasFuncionPredefinida             : 'LARGO()';
                    ClaveFuncionPredefinida             : ClaveLengthArray;
                    EspecialFuncionPredefinida          :
                        [ OverloadNITI, SectorNITI, SilenciarSectorNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'INSERTAR()';
                    AliasFuncionPredefinida             : 'INSERTSTRING()';
                    ClaveFuncionPredefinida             : ClaveInsertar;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varString;
                    Parametro2FuncionPredefinida        : varString;
                    Parametro3FuncionPredefinida        : varInteger    ),
                  ( NombreFuncionPredefinida            : 'TOVAL()';
                    AliasFuncionPredefinida             : 'AVAL()';
                    ClaveFuncionPredefinida             : ClaveToValDouble;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varString;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TOSTR()';
                    AliasFuncionPredefinida             : 'ATEXTO()';
                    ClaveFuncionPredefinida             : ClaveToStrInteger1;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TOSTR()';
                    AliasFuncionPredefinida             : 'ATEXTO()';
                    ClaveFuncionPredefinida             : ClaveToStrInteger2;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TOSTR()';
                    AliasFuncionPredefinida             : 'ATEXTO()';
                    ClaveFuncionPredefinida             : ClaveToStrDouble1;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TOSTR()';
                    AliasFuncionPredefinida             : 'ATEXTO()';
                    ClaveFuncionPredefinida             : ClaveToStrDouble2;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TOSTR()';
                    AliasFuncionPredefinida             : 'ATEXTO()';
                    ClaveFuncionPredefinida             : ClaveToStrDouble3;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varString;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varInteger    ),
                  ( NombreFuncionPredefinida            : 'ARCCOS()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveArcCos;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ARCCOSH()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveArcCosH;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ARCOSH()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveArCosH;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ARCSIN()';
                    AliasFuncionPredefinida             : 'ARCSENO()';
                    ClaveFuncionPredefinida             : ClaveArcSin;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ARCSINH()';
                    AliasFuncionPredefinida             : 'ARCSENOH()';
                    ClaveFuncionPredefinida             : ClaveArcSinH;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ARCTANH()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveArcTanH;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ARSINH()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveArSinH;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ARTANH()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveArTanH;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'CEIL()';
                    AliasFuncionPredefinida             : 'TECHO()';
                    ClaveFuncionPredefinida             : ClaveCeil;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'COMPAREVALUE()';
                    AliasFuncionPredefinida             : 'COMPAREVALOR()';
                    ClaveFuncionPredefinida             : ClaveCompareValue;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'COSECANTE()';
                    AliasFuncionPredefinida             : 'COSECANT()';
                    ClaveFuncionPredefinida             : ClaveCosecant;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'COSH()';
                    AliasFuncionPredefinida             : 'COSENOH()';
                    ClaveFuncionPredefinida             : ClaveCosH;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'COT()';
                    AliasFuncionPredefinida             : 'COTANGENTE()';
                    ClaveFuncionPredefinida             : ClaveCot;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'COTAN()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveCotan;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'CSC()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveCsc;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'CYCLETORAD()';
                    AliasFuncionPredefinida             : 'CICLOSARAD()';
                    ClaveFuncionPredefinida             : ClaveCycleToRad;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'DEGTOGRAD()';
                    AliasFuncionPredefinida             : 'GRADOSAGRAD()';
                    ClaveFuncionPredefinida             : ClaveDegToGrad;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ENSURERANGE()';
                    AliasFuncionPredefinida             : 'ASEGURERANGO()';
                    ClaveFuncionPredefinida             :
                                        ClaveEnsureRangeInteger;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varInteger    ),
                  ( NombreFuncionPredefinida            : 'MAX()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveMaxInteger;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MIN()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveMinInteger;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'DEGTORAD()';
                    AliasFuncionPredefinida             : 'GRADOSARAD()';
                    ClaveFuncionPredefinida             : ClaveDegToRad;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ENSURERANGE()';
                    AliasFuncionPredefinida             : 'ASEGURERANGO()';
                    ClaveFuncionPredefinida             :
                                        ClaveEnsureRangeDouble;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            : 'FLOOR()';
                    AliasFuncionPredefinida             : 'PISO()';
                    ClaveFuncionPredefinida             : ClaveFloor;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'GRADTODEG()';
                    AliasFuncionPredefinida             : 'GRADAGRADOS()';
                    ClaveFuncionPredefinida             : ClaveGradToDeg;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'GRADTORAD()';
                    AliasFuncionPredefinida             : 'GRADARAD()';
                    ClaveFuncionPredefinida             : ClaveGradToRad;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'HYPOT()';
                    AliasFuncionPredefinida             : 'HIPOT()';
                    ClaveFuncionPredefinida             : ClaveHypot;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'INRANGE()';
                    AliasFuncionPredefinida             : 'ENRANGO()';
                    ClaveFuncionPredefinida             : ClaveInRange;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            : 'INTPOWER()';
                    AliasFuncionPredefinida             : 'POTENCIAENTERA()';
                    ClaveFuncionPredefinida             : ClaveIntPower;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ISZERO()';
                    AliasFuncionPredefinida             : 'ESCERO()';
                    ClaveFuncionPredefinida             : ClaveIsZero;
                    EspecialFuncionPredefinida          :
                      [ ActivarDefaultNITI,
                        SegundoDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'BOOLEAN()';
                    AliasFuncionPredefinida             : 'BANDERA()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesCastBoolean;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'UNO()';
                    AliasFuncionPredefinida             : 'ONE()';
                    ClaveFuncionPredefinida             :
                                                ClaveEjesUnoDouble;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'UNO()';
                    AliasFuncionPredefinida             : 'ONE()';
                    ClaveFuncionPredefinida             :
                                                ClaveEjesUnoBoolean;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varBoolean;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'LDEXP()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveLdExp;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'LNXP1()';
                    // Puede surgir un problema
                    // en hojas muy grandes
                    // si existe casilla
                    // con macro coincidente
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveLnXp1;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'LOG10()';
                    // Puede surgir un problema
                    // en hojas muy grandes
                    // si existe casilla
                    // con macro coincidente
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveLog10;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'LOG2()';
                    // Puede surgir un problema
                    // en hojas muy grandes
                    // si existe casilla
                    // con macro coincidente
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveLog2;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'LOGN()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveLogN;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MAX()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveMaxDouble;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MIN()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveMinDouble;
                    EspecialFuncionPredefinida          : [ OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'POWER()';
                    AliasFuncionPredefinida             : 'POTENCIA()';
                    ClaveFuncionPredefinida             : ClavePower;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'RADTOCYCLE()';
                    AliasFuncionPredefinida             : 'RADACICLOS()';
                    ClaveFuncionPredefinida             : ClaveRadToCycle;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'RADTODEG()';
                    AliasFuncionPredefinida             : 'RADAGRADOS()';
                    ClaveFuncionPredefinida             : ClaveRadToDeg;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'RADTOGRAD()';
                    AliasFuncionPredefinida             : 'RADAGRAD()';
                    ClaveFuncionPredefinida             : ClaveRadToGrad;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'RANDG()';
                    AliasFuncionPredefinida             : 'AZARG()';
                    ClaveFuncionPredefinida             : ClaveRandG;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'RANDOMRANGE()';
                    AliasFuncionPredefinida             : 'AZARRANGO()';
                    ClaveFuncionPredefinida             : ClaveRandomRange;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varInteger;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'ROUNDTO()';
                    AliasFuncionPredefinida             : 'REDONDEOA()';
                    ClaveFuncionPredefinida             : ClaveRoundTo;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SAMEVALUE()';
                    AliasFuncionPredefinida             : 'MISMOVALOR()';
                    ClaveFuncionPredefinida             : ClaveSameValue;
                    EspecialFuncionPredefinida          :
                      [ ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varBoolean;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            : 'SEC()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveSec;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SECANT()';
                    AliasFuncionPredefinida             : 'SECANTE()';
                    ClaveFuncionPredefinida             : ClaveSecant;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SIGNO()';
                    AliasFuncionPredefinida             : 'SIGN()';
                    ClaveFuncionPredefinida             : ClaveSign;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varInteger;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SIMPLEROUNDTO()';
                    AliasFuncionPredefinida             : 'REDONDEOSIMPLE()';
                    ClaveFuncionPredefinida             : ClaveSimpleRoundTo;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    // Tiene un default no programado de -2 en Unit Math
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SINH()';
                    AliasFuncionPredefinida             : 'SENOH()';
                    ClaveFuncionPredefinida             : ClaveSinH;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TAN()';
                    AliasFuncionPredefinida             : 'TANGENTE()';
                    ClaveFuncionPredefinida             : ClaveTan;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TANH()';
                    AliasFuncionPredefinida             : 'TANGENTEH()';
                    ClaveFuncionPredefinida             : ClaveTanH;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                                CAFE_TraducidoOperadorPower;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                                ClaveOperadorPower;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                                CAFE_TraducidoOperadorFactorial;
                                // Version double
                                // por tener dominio mayor
                                // Utilice Trunc para Integer
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                                ClaveOperadorFactorial;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'FACTORIAL()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                                ClaveEjesFactorial;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                                CAFE_TraducidoOperadorPotenciaDos;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                                ClaveOperadorPotenciaDos;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                                CAFE_TraducidoOperadorPotenciaTres;
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                                ClaveOperadorPotenciaTres;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MEAN()';
                    AliasFuncionPredefinida             : 'PROMEDIO()';
                    ClaveFuncionPredefinida             : ClaveMean;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'STDDEV()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveStdDev;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SUM()';
                    AliasFuncionPredefinida             : 'SUMA()';
                    ClaveFuncionPredefinida             : ClaveSum;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'VARIANCE()';
                    AliasFuncionPredefinida             : 'VARIANZA()';
                    ClaveFuncionPredefinida             : ClaveVariance;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TOTALVARIANCE()';
                    AliasFuncionPredefinida             : 'TOTALVARIANZA()';
                    ClaveFuncionPredefinida             : ClaveTotalVariance;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SUMOFSQUARES()';
                    AliasFuncionPredefinida             : 'SUMACUADRADOS()';
                    ClaveFuncionPredefinida             : ClaveSumOfSquares;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'NORMA()';
                    AliasFuncionPredefinida             : 'NORM()';
                    ClaveFuncionPredefinida             : ClaveNorm;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MINVALUE()';
                    AliasFuncionPredefinida             : 'MINVALOR()';
                    ClaveFuncionPredefinida             : ClaveMinValue;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MAXVALUE()';
                    AliasFuncionPredefinida             : 'MAXVALOR()';
                    ClaveFuncionPredefinida             : ClaveMaxValue;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'POPNSTDDEV()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClavePopNStdDev;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'POPNVARIANCE()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClavePopNVariance;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'RANDOMFROM()';
                    AliasFuncionPredefinida             : 'AZARDESDE()';
                    ClaveFuncionPredefinida             : ClaveRandomFrom;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'LAPLACE()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveEjesLaplace;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        SegundoDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'GAMMA()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveEjesGamma;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        SegundoDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'BETA()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveEjesBeta;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            : 'LAPLACEINVERSA()';
                    AliasFuncionPredefinida             : 'LAPLACEINVERSE()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesLaplaceInversa;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        SegundoDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'NORMAL()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesNormal;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        SegundoDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'NORMALINVERSA()';
                    AliasFuncionPredefinida             : 'NORMALINVERSE()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesNormalInversa;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        SegundoDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                                        'DISTRIBUCIONNORMAL()';
                    AliasFuncionPredefinida             : 'DISTRIBUTIONNORMAL()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesDistribucionNormal;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'TSTUDENT()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesTStudent;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            :
                                        'TSTUDENTINVERSA()';
                    AliasFuncionPredefinida             : 'TSTUDENTINVERSE()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesTStudentInversa;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            :
                                        'DISTRIBUCIONTSTUDENT()';
                    AliasFuncionPredefinida             : 'DISTRIBUTIONTSTUDENT()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesDistribucionTStudent;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            : 'CHISQUARE()';
                    AliasFuncionPredefinida             : 'CHICUADRADO()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesChiSquare;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            :
                                        'CHISQUAREINVERSE()';
                    AliasFuncionPredefinida             :
                                        'CHICUADRADOINVERSA()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesChiSquareInversa;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            :
                                        'DISTRIBUTIONCHISQUARE()';
                    AliasFuncionPredefinida             :
                                        'DISTRIBUCIONCHICUADRADO()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesDistribucionChiSquare;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI, ActivarDefaultNITI,
                        TerceroDefaultNITI, AnularDefaultNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            : 'FISHER()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesIntegralF;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            :
                                        'FISHERINVERSA()';
                    AliasFuncionPredefinida             : 'FISHERINVERSE()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesIntegralFInversa;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            :
                                        'DISTRIBUCIONFISHER()';
                    AliasFuncionPredefinida             : 'DISTRIBUTIONFISHER()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesDistribucionF;
                    EspecialFuncionPredefinida          :
                      [ FuncionalLentoNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varDouble     ),
                  ( NombreFuncionPredefinida            : 'PRODUCTOPUNTO()';
                    AliasFuncionPredefinida             : 'DOTPRODUCT()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesProductoPunto;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varArray;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                                        'SUMAPRODUCTOS()';
                    AliasFuncionPredefinida             : 'SUMOFPRODUCTS()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesSumaProductos2;
                    EspecialFuncionPredefinida          :
                                        [ SectorNITI, OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varArray;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                                        'SUMAPRODUCTOS()';
                    AliasFuncionPredefinida             : 'SUMOFPRODUCTS()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesSumaProductos3;
                    EspecialFuncionPredefinida          :
                                        [ SectorNITI, OverloadNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varArray;
                    Parametro3FuncionPredefinida        : varArray      ),
                  ( NombreFuncionPredefinida            : 'COVARIANCE()';
                    AliasFuncionPredefinida             : 'COVARIANZA()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesCovariance;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varArray;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'PENDIENTE()';
                    AliasFuncionPredefinida             : 'SLOPE()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesPendiente;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varArray;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'INTERSECCION()';
                    AliasFuncionPredefinida             : 'INTERSECTION()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesInterseccion;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varArray;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                                        'COEFICIENTECORRELACION()';
                    AliasFuncionPredefinida             : 'CORRELATIONCOEFFICIENT()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesCoeficienteCorrelacion;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varArray;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'DETERMINANTE()';
                    AliasFuncionPredefinida             : 'DETERMINANT()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesDeterminante;
                    EspecialFuncionPredefinida          :
                      [ SectorNITI, FuncionalLentoNITI, SilenciarSectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            :
                                        'CASILLAINVERSA()';
                    AliasFuncionPredefinida             : 'CELLINVERSE()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesCasillaInversa;
                    EspecialFuncionPredefinida          :
                      [ SectorNITI, FuncionalLentoNITI, SilenciarSectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varInteger;
                    Parametro3FuncionPredefinida        : varInteger;   ),
                  ( NombreFuncionPredefinida            :
                                        'CASILLASISTEMA()';
                    AliasFuncionPredefinida             : 'CELLSYSTEM()';
                    ClaveFuncionPredefinida             :
                                        ClaveEjesCasillaSistema;
                    EspecialFuncionPredefinida          :
                      [ SectorNITI, FuncionalLentoNITI, SilenciarSectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varArray;
                    Parametro3FuncionPredefinida        : varInteger;   ),
                  ( NombreFuncionPredefinida            : 'MOMENTO1()';
                    // Puede surgir un problema
                    // en hojas muy grandes
                    // si existe casilla
                    // con macro coincidente
                    AliasFuncionPredefinida             : 'MOMENT1()';
                    ClaveFuncionPredefinida             : ClaveEjesMomento1;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MOMENTO2()';
                    // Puede surgir un problema
                    // en hojas muy grandes
                    // si existe casilla
                    // con macro coincidente
                    AliasFuncionPredefinida             : 'MOMENT2()';
                    ClaveFuncionPredefinida             : ClaveEjesMomento2;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MOMENTO3()';
                    // Puede surgir un problema
                    // en hojas muy grandes
                    // si existe casilla
                    // con macro coincidente
                    AliasFuncionPredefinida             : 'MOMENT3()';
                    ClaveFuncionPredefinida             : ClaveEjesMomento3;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'MOMENTO4()';
                    // Puede surgir un problema
                    // en hojas muy grandes
                    // si existe casilla
                    // con macro coincidente
                    AliasFuncionPredefinida             : 'MOMENT4()';
                    ClaveFuncionPredefinida             : ClaveEjesMomento4;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'SKEW()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveEjesSkew;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'CUBO()';
                    AliasFuncionPredefinida             : 'CUBE()';
                    ClaveFuncionPredefinida             : ClaveEjesCubo;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : 'KURTOSIS()';
                    AliasFuncionPredefinida             : '';
                    ClaveFuncionPredefinida             : ClaveEjesKurtosis;
                    EspecialFuncionPredefinida          : [ SectorNITI ];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varArray;
                    Parametro2FuncionPredefinida        : varNull;
                    Parametro3FuncionPredefinida        : varNull       ),
                  ( NombreFuncionPredefinida            : '$CASILLA()';
                    AliasFuncionPredefinida             : '$CELL()';
                    ClaveFuncionPredefinida             :
                                                ClaveEjesDolarCasilla;
                    EspecialFuncionPredefinida          : [];
                    TipoFuncionPredefinida              : varDouble;
                    Parametro1FuncionPredefinida        : varDouble;
                    Parametro2FuncionPredefinida        : varDouble;
                    Parametro3FuncionPredefinida        : varNull       )
                );
  { IMPLEMENTATION }

{ IMPLEMENTATION }
CONST
  ImplementationResultadoString         : ShortString   = '¦‡�š}ðw)...';
  MaximoImplementationFactorial         = 69;
  ImplementationStringNull              : ShortString   = '';

VAR
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  ImplementationManejador               : CAFE_InterfaceManejador       = NIL;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  ImplementationSintactico              : CAFE_CharByte3Sintactico;
  ImplementationCicloRectangularSintactico              : LongInt;

VAR
  ImplementationConteoCicloSeguridad    : LongInt;
{ IMPLEMEMTATION }

VAR
  ImplementationFactorial       :
                ARRAY [ 0..MaximoImplementationFactorial ] OF Extended;

FUNCTION CAFE_FormatDate
  (       MyDate                : TDateTime;
    CONST MyFormat              : ShortString   = '';
          MyLength              : LongInt       = 0     ) : ShortString;
VAR
  PivoteResultado               : ShortString;
  PivoteTamano                  : LongInt;

BEGIN  { FUNCTION CAFE_FormatDate }
  IF  MyFormat = ''
  THEN BEGIN
    PivoteResultado          :=
                FormatDateTime( CAFE_FormatDateDefault, MyDate );
    PivoteTamano             := MyLength;
  END ELSE BEGIN  { IF MyFormat = '' ELSE }
    PivoteResultado          :=
                FormatDateTime( MyFormat, MyDate );
    PivoteTamano             := MyLength;
  END;            { IF MyFormat = '' ELSE }
  IF PivoteResultado = '' THEN BEGIN
    PivoteResultado             := DateToStr( MyDate );
  END;  { IF PivoteResultado = '' }
  IF PivoteTamano <> 0 THEN BEGIN
    WHILE ( Length( PivoteResultado ) < PivoteTamano )
    DO PivoteResultado          := ' '+PivoteResultado;
  END;  { IF CAFE_TamanoFormatDate <> 0 }
  CAFE_FormatDate               := PivoteResultado;
END;   { FUNCTION CAFE_FormatDate }

FUNCTION  CAFE_RedondeoTolerancia
  (     Input                   : Double;
        Tolerancia              : Double                        ) : Double;
VAR
  ToleranciaInt                 : Integer;

BEGIN  { FUNCTION CAFE_RedondeoTolerancia }
  TRY
    IF Tolerancia = 0 THEN BEGIN
      CAFE_RedondeoTolerancia   := Input;
      Exit;
    END;  { IF Tolerancia = 0 }
    ToleranciaInt               := Floor( Log10( Tolerancia ) );
    CAFE_RedondeoTolerancia     := SimpleRoundTo( Input, ToleranciaInt );
  EXCEPT
    ON Exception
    DO BEGIN
      CAFE_RedondeoTolerancia   := Input;
    END;  { ON Exception }
  END;  { TRY }
END;   { FUNCTION CAFE_RedondeoTolerancia }

FUNCTION  CAFE_ProductoLista
  ( OUT   Resultado             : Double;
          Lista1, Lista2        : LongInt                       ) : Boolean;
VAR
  Piv_L1,
  Piv_L2                        : CAFE_ArregloDouble;
  RecorreVector                 : LongInt;

BEGIN  { CAFE_ProductoLista }
  TRY
    Resultado                   := 0.0;
    Piv_L1                      :=
        CAFE_ItemListaRectangular.ID[ Lista1 ].ArregloDoubleSector;
    Piv_L2                      :=
        CAFE_ItemListaRectangular.ID[ Lista2 ].ArregloDoubleSector;
    IF Length( Piv_L1 ) <> Length( Piv_L2 )
    THEN RAISE CAFE_MensajeInfructuoso.
        Create( 'Error de tamano en Lista',
                CAFE_4ErrorDescriptorDimensionalInconsistente );
    FOR RecorreVector := Low ( Piv_L1 ) TO High( Piv_L1 )
    DO Resultado
       += Piv_L1[ RecorreVector ]*Piv_L2[ RecorreVector ];
    CAFE_ProductoLista                  := TRUE;
  EXCEPT
    ON Exception
    DO BEGIN
      Resultado                         := 0.0;
      CAFE_ProductoLista                := FALSE;
    END;  { TRY }
  END;  { TRY }
END;   { CAFE_ProductoLista }

FUNCTION  CAFE_ProductoLista3
  ( OUT   Resultado                     : Double;
          Lista1, Lista2, Lista3        : LongInt               ) : Boolean;
VAR
  Piv_L1,
  Piv_L2,
  Piv_L3                        : CAFE_ArregloDouble;
  RecorreVector                 : LongInt;

BEGIN  { CAFE_ProductoLista3 }
  TRY
    Resultado                   := 0.0;
    Piv_L1                      :=
        CAFE_ItemListaRectangular.ID[ Lista1 ].ArregloDoubleSector;
    Piv_L2                      :=
        CAFE_ItemListaRectangular.ID[ Lista2 ].ArregloDoubleSector;
    Piv_L3                      :=
        CAFE_ItemListaRectangular.ID[ Lista3 ].ArregloDoubleSector;
    IF Length( Piv_L1 ) <> Length( Piv_L2 )
    THEN RAISE CAFE_MensajeInfructuoso.
        Create( 'Error de tamano en Lista',
                CAFE_4ErrorDescriptorDimensionalInconsistente );
    IF Length( Piv_L1 ) <> Length( Piv_L3 )
    THEN RAISE CAFE_MensajeInfructuoso.
        Create( 'Error de tamano en Lista',
                CAFE_4ErrorDescriptorDimensionalInconsistente );
    FOR RecorreVector := Low ( Piv_L1 ) TO High( Piv_L1 )
    DO Resultado
       += Piv_L1[ RecorreVector ]*
          Piv_L2[ RecorreVector ]*Piv_L3[ RecorreVector ];
    CAFE_ProductoLista3                 := TRUE;
  EXCEPT
    ON Exception
    DO BEGIN
      Resultado                         := 0.0;
      CAFE_ProductoLista3               := FALSE;
    END;  { TRY }
  END;  { TRY }
END;   { CAFE_ProductoLista3 }

FUNCTION  CAFE_CovarianzaLista
  ( OUT   Resultado             : Double;
          Lista1, Lista2        : LongInt                       ) : Boolean;
VAR
  Piv_L1,
  Piv_L2                        : CAFE_ArregloDouble;
  N,
  RecorreVector                 : LongInt;

BEGIN  { CAFE_CovarianzaLista }
  TRY
    Resultado                   := 0.0;
    Piv_L1                      :=
        CAFE_ItemListaRectangular.ID[ Lista1 ].ArregloDoubleSector;
    Piv_L2                      :=
        CAFE_ItemListaRectangular.ID[ Lista2 ].ArregloDoubleSector;
    N                           := Length( Piv_L1 );
    IF N <> Length( Piv_L2 )
    THEN RAISE CAFE_MensajeInfructuoso.
        Create( 'Error de tamano en Lista',
                CAFE_4ErrorDescriptorDimensionalInconsistente );
    FOR RecorreVector := 0 TO Pred( N )
    DO Resultado
       += Piv_L1[ RecorreVector ]*Piv_L2[ RecorreVector ];
    Resultado
    -=  Sum( Piv_L1 )*Sum( Piv_L2 )/N;
    Resultado
    /=  Pred( N );
    CAFE_CovarianzaLista                := TRUE;
  EXCEPT
    ON Exception
    DO BEGIN
      Resultado                         := 0.0;
      CAFE_CovarianzaLista              := FALSE;
    END;  { TRY }
  END;  { TRY }
END;   { CAFE_CovarianzaLista }

  { IMPLEMENTATION }
  { SISTEMA LINEAL }
CONST
  MaximoGradoAnalisisNumerico   = 15;

TYPE
  IndiceAnalisisNumerico                = 0..MaximoGradoAnalisisNumerico;
  ConjuntoIndiceAnalisisNumerico        = SET OF IndiceAnalisisNumerico;

  RealAnalisisNumerico          = Extended;

  VectorAnalisisNumerico        = ARRAY
        [ 0..MaximoGradoAnalisisNumerico ]      OF RealAnalisisNumerico;

  MatrizAnalisisNumerico        = ARRAY
        [ 0..MaximoGradoAnalisisNumerico ]      OF VectorAnalisisNumerico;

  { Gloria al Padre, gloria al Hijo y gloria al Espiritu Santo }
FUNCTION  ImplementationDeterminanteInteriorMatrizAnalisisNumerico
  ( CONST MatrizA               : MatrizAnalisisNumerico;
          FilasInteriores,
          ColumnasInteriores    : ConjuntoIndiceAnalisisNumerico
                                                ) : RealAnalisisNumerico;
// Tambien tengo el metodo Gauss Jordan programado
// por la prisa no lo incluyo aqui
// probablemente en el futuro...
// DISCULPAS
// Que pase una buena siesta
VAR
  ColumnasHerencia              : ConjuntoIndiceAnalisisNumerico;
  PivoteResultado               : RealAnalisisNumerico;
  Fila,
  RecorreColumna,
  CuentaActivo                  : Byte;

BEGIN  { FUNCTION ImplementationDeterminanteInteriorMatrizAnalisisNumerico }
  IF FilasInteriores = [] THEN BEGIN
    ImplementationDeterminanteInteriorMatrizAnalisisNumerico    := 1.0;
    Exit;
  END;  { IF FilasInteriores = [] }
  Fila                          := 0;
  WHILE NOT( Fila IN FilasInteriores ) DO Inc( Fila );
  CuentaActivo                  := 0;
  PivoteResultado               := 0.0;
  Exclude( FilasInteriores, Fila );
  FOR RecorreColumna := 0 TO MaximoGradoAnalisisNumerico DO BEGIN
    IF ( RecorreColumna IN ColumnasInteriores ) THEN BEGIN
      Inc( CuentaActivo );
      ColumnasHerencia          := ColumnasInteriores-[ RecorreColumna ];
      IF Odd( CuentaActivo ) THEN BEGIN
        PivoteResultado         := PivoteResultado+
                MatrizA[ Fila, RecorreColumna ]*
                ImplementationDeterminanteInteriorMatrizAnalisisNumerico
                        ( MatrizA, FilasInteriores, ColumnasHerencia );
      END ELSE BEGIN  { IF Odd( CuentaActivo ) ELSE }
        PivoteResultado         := PivoteResultado-
                MatrizA[ Fila, RecorreColumna ]*
                ImplementationDeterminanteInteriorMatrizAnalisisNumerico
                        ( MatrizA, FilasInteriores, ColumnasHerencia );
      END;            { IF Odd( CuentaActivo ) ELSE }
    END;  { IF ( RecorreColumna IN ColumnasInteriores ) }
  END;  {  FOR RecorreColumna }
  ImplementationDeterminanteInteriorMatrizAnalisisNumerico
                                        := PivoteResultado;
END;   { FUNCTION ImplementationDeterminanteInteriorMatrizAnalisisNumerico }

FUNCTION  ImplementationDeterminanteMatrizAnalisisNumerico
  ( CONST MatrizA               : MatrizAnalisisNumerico;
          TamanoMiMatriz        : Byte          ) : RealAnalisisNumerico;
VAR
  FilasInteriores,
  ColumnasInteriores            : ConjuntoIndiceAnalisisNumerico;
  RecorreIndice                 : Byte;

BEGIN  { FUNCTION DeterminanteMatrizAnalisisNumerico }
  FilasInteriores               := [];
  ColumnasInteriores            := [];
  FOR RecorreIndice := 0 TO ( TamanoMiMatriz-1 ) DO BEGIN
    Include( FilasInteriores, RecorreIndice );
    Include( ColumnasInteriores, RecorreIndice );
  END;  { FOR RecorreIndice }
  ImplementationDeterminanteMatrizAnalisisNumerico              :=
        ImplementationDeterminanteInteriorMatrizAnalisisNumerico
                ( MatrizA, FilasInteriores, ColumnasInteriores );
END;   { FUNCTION DeterminanteMatrizAnalisisNumerico }

FUNCTION  ImplementationInversaMatrizAnalisisNumerico
  ( OUT   MatrizResultado       : MatrizAnalisisNumerico;
    CONST MatrizA               : MatrizAnalisisNumerico;
          TamanoMiMatriz        : Byte          ) : RealAnalisisNumerico;
VAR
  FilasInteriores,
  ColumnasInteriores,
  FilasHerencia,
  ColumnasHerencia              : ConjuntoIndiceAnalisisNumerico;
  MiDeterminante                : RealAnalisisNumerico;
  RecorreI,
  RecorreJ                      : Byte;

BEGIN  { FUNCTION ImplementationnversaMatrizAnalisisNumerico }
  MiDeterminante                :=
        ImplementationDeterminanteMatrizAnalisisNumerico
                                ( MatrizA, TamanoMiMatriz );
  IF IsZero( MiDeterminante,
                ImplementationManejador.ValorDefaultToleranciaDeterminante )
  THEN RAISE CAFE_PipeException.Create( ErrorREPO,
                                CAFE_4ErrorDeterminanteNulo );
  FilasInteriores               := [];
  ColumnasInteriores            := [];
  FOR RecorreI := 0 TO ( TamanoMiMatriz-1 ) DO BEGIN
    Include( FilasInteriores   , RecorreI );
    Include( ColumnasInteriores, RecorreI );
  END;  { FOR RecorreI }
  FOR RecorreI := 0 TO ( TamanoMiMatriz-1 ) DO BEGIN
    FilasHerencia               := FilasInteriores-[ RecorreI ];
    FOR RecorreJ := 0 TO ( TamanoMiMatriz-1 ) DO BEGIN
      ColumnasHerencia          := ColumnasInteriores-[ RecorreJ ];
      IF Odd( RecorreI+RecorreJ ) THEN BEGIN
        MatrizResultado[ RecorreJ, RecorreI ]           :=
            -ImplementationDeterminanteInteriorMatrizAnalisisNumerico
                ( MatrizA, FilasHerencia, ColumnasHerencia )/MiDeterminante;
      END ELSE BEGIN  { IF Odd( RecorreI+RecorreJ ) ELSE }
        MatrizResultado[ RecorreJ, RecorreI ]           :=
            +ImplementationDeterminanteInteriorMatrizAnalisisNumerico
                ( MatrizA, FilasHerencia, ColumnasHerencia )/MiDeterminante;
      END;            { IF Odd( RecorreI+RecorreJ ) ELSE }
    END;  { FOR RecorreJ }
  END;  { FOR RecorreI }
  ImplementationInversaMatrizAnalisisNumerico   := MiDeterminante;
END;   { FUNCTION ImplementationInversaMatrizAnalisisNumerico }

FUNCTION  ImplementationCasillaInversaMatrizAnalisisNumerico
  ( CONST MatrizA               : MatrizAnalisisNumerico;
          Fila,
          Columna               : Byte;
          TamanoMiMatriz        : Byte          ) : RealAnalisisNumerico;
VAR
  FilasInteriores,
  ColumnasInteriores            : ConjuntoIndiceAnalisisNumerico;
  MiDeterminante                : RealAnalisisNumerico;
  RecorreI                      : Byte;

BEGIN  { FUNCTION ImplementationCasillaInversaMatrizAnalisisNumerico }
  MiDeterminante                :=
        ImplementationDeterminanteMatrizAnalisisNumerico
                                ( MatrizA, TamanoMiMatriz );
  IF IsZero( MiDeterminante,
                ImplementationManejador.ValorDefaultToleranciaDeterminante )
  THEN RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_4ErrorDeterminanteNulo );
  FilasInteriores               := [];
  ColumnasInteriores            := [];
  FOR RecorreI := 0 TO ( TamanoMiMatriz-1 ) DO BEGIN
    Include( FilasInteriores   , RecorreI );
    Include( ColumnasInteriores, RecorreI );
  END;  { FOR RecorreI }
  Exclude( FilasInteriores, Columna );
  Exclude( ColumnasInteriores, Fila );
  IF Odd( Columna+Fila )
  THEN ImplementationCasillaInversaMatrizAnalisisNumerico       :=
            -ImplementationDeterminanteInteriorMatrizAnalisisNumerico
            ( MatrizA, FilasInteriores, ColumnasInteriores )/MiDeterminante
  ELSE ImplementationCasillaInversaMatrizAnalisisNumerico       :=
            +ImplementationDeterminanteInteriorMatrizAnalisisNumerico
            ( MatrizA, FilasInteriores, ColumnasInteriores )/MiDeterminante;
END;   { FUNCTION ImplementationCasillaInversaMatrizAnalisisNumerico }

FUNCTION  ImplementationSistemaMatrizAnalisisNumerico
  ( CONST MatrizA               : MatrizAnalisisNumerico;
    CONST VectorResultado       : VectorAnalisisNumerico;
          Fila                  : LongInt;
          TamanoMiMatriz        : Byte          ) : RealAnalisisNumerico;
VAR
  MatrizPivote                  : MatrizAnalisisNumerico;
  MyDeterminante                : RealAnalisisNumerico;
  RecorreI                      : Byte;

BEGIN  { FUNCTION ImplementationSistemaMatrizAnalisisNumerico }
  MyDeterminante                :=
        ImplementationDeterminanteMatrizAnalisisNumerico
        ( MatrizA, TamanoMiMatriz );
  IF IsZero( MyDeterminante,
                ImplementationManejador.ValorDefaultToleranciaDeterminante )
  THEN RAISE CAFE_PipeException.Create
        (  ErrorREPO, CAFE_4ErrorDeterminanteNulo );
  MatrizPivote                  := MatrizA;
  FOR RecorreI := 0 TO ( TamanoMiMatriz-1 ) DO
        MatrizPivote[ RecorreI, Fila ]  := VectorResultado[ RecorreI ];
  ImplementationSistemaMatrizAnalisisNumerico   :=
        ImplementationDeterminanteMatrizAnalisisNumerico
        ( MatrizPivote, TamanoMiMatriz )/MyDeterminante;
END;   { FUNCTION ImplementationSistemaMatrizAnalisisNumerico }
  { SISTEMA LINEAL }
  { IMPLEMENTATION }

FUNCTION  CAFE_DeterminanteLista
  ( OUT   Resultado             : Double;
          Lista1                : LongInt                       ) : Boolean;
VAR
  MyMatriz                      : MatrizAnalisisNumerico;
  RecorreFila,
  RecorreColumna                : LongInt;

BEGIN  { FUNCTION CAFE_DeterminanteLista }
  TRY
    Resultado                   := 0.0;
    WITH CAFE_ItemListaRectangular.ID[ Lista1 ] DO BEGIN
      IF FilasDouble <> ColumnasDouble
      THEN RAISE CAFE_PipeException.Create( ErrorREPO,
                        CAFE_4ErrorDescriptorDimensionalInconsistente );
      IF FilasDouble > MaximoGradoAnalisisNumerico
      THEN RAISE CAFE_PipeException.Create( ErrorREPO,
                        CAFE_4ErrorMatrizAnalisisNumericoMuyGrande );
      FOR RecorreFila := 0 TO Pred( FilasDouble ) DO
        FOR RecorreColumna := 0 TO Pred( ColumnasDouble ) DO
          MyMatriz[ RecorreFila ][ RecorreColumna ]     :=
                LeerDoubleItemRectangular
                ( RecorreFila, RecorreColumna );
      Resultado                 :=
        ImplementationDeterminanteMatrizAnalisisNumerico
                                        ( MyMatriz, FilasDouble );
    END;  { CAFE_ItemListaRectangular.ID[ Lista1 ] }
    CAFE_DeterminanteLista              := TRUE;
  EXCEPT
    Resultado                           := 0.0;
    CAFE_DeterminanteLista              := FALSE;
  END;  { TRY }
END;   { FUNCTION CAFE_DeterminanteLista }

FUNCTION  CAFE_InversaLista
  ( OUT   Resultado             : Double;
          Lista1                : LongInt;
          Fila, Columna         : LongInt                       ) : Boolean;
VAR
  MyMatriz                      : MatrizAnalisisNumerico;
  RecorreFila,
  RecorreColumna                : LongInt;

BEGIN  { CAFE_InversaLista }
  TRY
    Resultado                   := 0.0;
    WITH CAFE_ItemListaRectangular.ID[ Lista1 ] DO BEGIN
      IF FilasDouble <> ColumnasDouble
      THEN RAISE Exception.Create( 'Matriz no es cuadrada' );
      IF FilasDouble > MaximoGradoAnalisisNumerico
      THEN RAISE Exception.Create( 'Matriz demasiado grande' );
      FOR RecorreFila := 0 TO Pred( FilasDouble ) DO
        FOR RecorreColumna := 0 TO Pred( ColumnasDouble ) DO
          MyMatriz[ RecorreFila ][ RecorreColumna ]     :=
                LeerDoubleItemRectangular
                ( RecorreFila, RecorreColumna );
      IF NOT( InRange( Fila, 0, Pred( FilasDouble ) ) ) OR
         NOT( InRange( Columna, 0, Pred( ColumnasDouble ) ) )
      THEN RAISE Exception.Create( 'Acceso a matriz fuera de rango' );
      Resultado                 :=
        ImplementationCasillaInversaMatrizAnalisisNumerico
                        ( MyMatriz, Fila, Columna, FilasDouble );
    END;  { WITH ItemListaRectangular.ID[ Lista1 ] }
    CAFE_InversaLista                   := TRUE;
  EXCEPT
    Resultado                           := 0.0;
    CAFE_InversaLista                   := FALSE;
  END;  { TRY }
END;   { CAFE_InversaLista }

FUNCTION  CAFE_SistemaLista
  ( OUT   Resultado             : Double;
          Lista1, Lista2        : LongInt;
          Fila                  : LongInt                       ) : Boolean;
VAR
  Piv_L2                        : CAFE_ArregloDouble;
  MyMatriz                      : MatrizAnalisisNumerico;
  MyVector                      : VectorAnalisisNumerico;
  RecorreFila,
  RecorreColumna                : LongInt;

BEGIN  { FUNCTION CAFE_SistemaLista }
  TRY
    Resultado                   := 0.0;
    Piv_L2                      :=
        CAFE_ItemListaRectangular.ID[ Lista2 ].ArregloDoubleSector;
    WITH CAFE_ItemListaRectangular.ID[ Lista1 ] DO BEGIN
      IF FilasDouble <> ColumnasDouble
      THEN RAISE Exception.Create( 'Matriz no es cuadrada' );
      IF FilasDouble > MaximoGradoAnalisisNumerico
      THEN RAISE Exception.Create( 'Matriz demasiado grande' );
      IF Length( Piv_L2 ) <> FilasDouble
      THEN RAISE Exception.Create( 'Tamano vector no corresponde' );
      FOR RecorreFila := 0 TO Pred( FilasDouble ) DO BEGIN
        FOR RecorreColumna := 0 TO Pred( ColumnasDouble ) DO BEGIN
          MyMatriz[ RecorreFila ][ RecorreColumna ]     :=
                LeerDoubleItemRectangular
                ( RecorreFila, RecorreColumna );
        END;  { FOR RecorreColumna }
        MyVector[ RecorreFila ] := Piv_L2[ RecorreFila ];
      END;  { FOR RecorreFila }
      IF NOT( InRange( Fila, 0, Pred( FilasDouble ) ) )
      THEN RAISE Exception.Create( 'Acceso a matriz fuera de rango' );
      Resultado                 :=
        ImplementationSistemaMatrizAnalisisNumerico
                        ( MyMatriz, MyVector, Fila, FilasDouble );
    END;  { WITH ItemListaRectangular.ID[ Lista1 ] }
    CAFE_SistemaLista                   := TRUE;
  EXCEPT
    Resultado                           := 0.0;
    CAFE_SistemaLista                   := FALSE;
  END;  { TRY }
END;   { FUNCTION CAFE_SistemaLista }

FUNCTION    CAFE_VarCast
  ( OUT   MyVar                 : Variant;
    CONST MyInput               : Variant;
          NuevoType             : SizeInt                       ) : Boolean;

VAR
  MyByte                        : Byte;

BEGIN  { FUNCTION CAFE_VarCast }
  IF ( NuevoType = varString ) AND
        ( CAFE_TipoVariante( MyInput ) = varByte ) THEN BEGIN
    MyByte                      := MyInput;
    MyVar                       := Concat( Chr( MyByte ) );
    CAFE_VarCast                := TRUE;
  END ELSE BEGIN  { FUNCTION CAFE_VarCast }
    IF MyInput = Null THEN BEGIN
      MyVar                     := CAFE_DefaultNuloVariant( NuevoType );
      CAFE_VarCast              := TRUE;
    END ELSE BEGIN  { IF MyInput = Null ELSE }
      TRY
        VarCast( MyVar, MyInput, NuevoType );
        CAFE_VarCast              := TRUE;
      EXCEPT
        ON Exception
        DO CAFE_VarCast           := FALSE;
      END;
    END;            { IF MyInput = Null ELSE }
  END;            { FUNCTION CAFE_VarCast }
END;   { FUNCTION CAFE_VarCast }

FUNCTION    CAFE_DefaultNuloCasilla ( MyTipo    : SizeInt       ) : Variant;
BEGIN  { CAFE_DefaultNuloCasilla }
  IF MyTipo = varNull
  THEN VarCast( CAFE_DefaultNuloCasilla, 0.0, varDouble )
  ELSE CAFE_DefaultNuloCasilla  := CAFE_DefaultNuloVariant( MyTipo );
END;   { CAFE_DefaultNuloCasilla }

FUNCTION    CAFE_DefaultNuloVariant ( MyTipo    : SizeInt       ) : Variant;
VAR
  PivoteVariant2                : Variant;
  PivoteTDateTime               : TDateTime;

BEGIN  { FUNCTION CAFE_DefaultNuloVariant }
  CASE MyTipo OF
    varNull                     : PivoteVariant2        := Null;
    varBoolean                  : PivoteVariant2        := FALSE;
    varByte                     :
        VarCast( PivoteVariant2, 0, varByte    );
    varDate                     :
      BEGIN
        PivoteTDateTime         := JulianEpoch;
        PivoteVariant2          := PivoteTDateTime;
      END;  { CASE varDate }
    varDouble                   :
        VarCast( PivoteVariant2, 0, varDouble  );
    varInteger                  :
        VarCast( PivoteVariant2, 0, varInteger );
    varString                   :
      BEGIN
        CAFE_DefaultNuloVariant := ImplementationStringNull;
        Exit;
      END;  { CASE varString }
  END;  { CASE MyTipo }
  CAFE_DefaultNuloVariant       := PivoteVariant2;
END;   { FUNCTION CAFE_DefaultNuloVariant }

FUNCTION    CAFE_VariantValorCompatible
  ( CONST MyVar1, MyInput       : Variant                       ) : Boolean;
VAR
  PivoteTipo            : SizeInt;
  PivoteRespuesta       : Boolean;

BEGIN  { FUNCTION CAFE_VariantValorCompatible }
  PivoteRespuesta               := FALSE;
  IF MyInput = Null THEN BEGIN
    // Esta regla es para hojas de calculo, quiza no sea apropiada en su caso
    PivoteRespuesta             := TRUE;
  END ELSE BEGIN  { IF MyInput = varNull ELSE }
    // Suponemos que un byte es totalmente equivalente a un char
    // Puede que no sea siempre lo mas apropiado
    PivoteTipo                  := CAFE_TipoVariante( MyInput );
    CASE CAFE_TipoVariante( MyVar1 ) OF
      varByte           : PivoteRespuesta       :=
        ( PivoteTipo = varInteger ) OR ( PivoteTipo = varByte );
      varInteger        : PivoteRespuesta       :=
        ( PivoteTipo = varInteger ) OR ( PivoteTipo = varByte );
      varDouble         : PivoteRespuesta       :=
        ( PivoteTipo = varInteger ) OR ( PivoteTipo = varDouble )
        OR ( PivoteTipo = varByte ) OR ( PivoteTipo = varDate );
      varString         : PivoteRespuesta       :=
        ( PivoteTipo = varString ) OR ( PivoteTipo = varByte );
      varDate           : PivoteRespuesta       :=
        ( PivoteTipo = varDouble ) OR ( PivoteTipo = varDate );
      varBoolean        : PivoteRespuesta       := PivoteTipo = varBoolean;
      varNull           : PivoteRespuesta       := TRUE;
    END;  { CASE PivoteTipo }
  END;            { IF MyInput = Null ELSE }
  CAFE_VariantValorCompatible           := PivoteRespuesta;
END;   { FUNCTION CAFE_VariantValorCompatible }

FUNCTION    CAFE_TypeSimpleValorCompatible
  (       MyVar1, MyInput       : SizeInt                       ) : Boolean;
VAR
  PivoteRespuesta       : Boolean;

BEGIN  { FUNCTION CAFE_TypeSimpleValorCompatible }
  PivoteRespuesta               := FALSE;
  IF MyInput = varNull THEN BEGIN
    // Esta regla es para hojas de calculo, quiza no sea apropiada en su caso
    PivoteRespuesta             := TRUE;
  END ELSE BEGIN  { IF MyInput = varNull ELSE }
    // Suponemos que un byte es totalmente equivalente a un char
    // Puede que no sea siempre lo mas apropiado
    CASE MyVar1 OF
      varByte           : PivoteRespuesta       := MyInput = varByte;
      // Utilice el Cast Byte cuando resulte problematico
      // No es la mejor opcion
      varInteger        : PivoteRespuesta       :=
        ( MyInput = varInteger ) OR ( MyInput = varByte );
      varDouble         : PivoteRespuesta       :=
        ( MyInput = varInteger ) OR ( MyInput = varDouble )
        OR ( MyInput = varByte ) OR ( MyInput = varDate );
      varString         : PivoteRespuesta       :=
        ( MyInput = varString ) OR ( MyInput = varByte );
      varBoolean        : PivoteRespuesta       := MyInput = varBoolean;
      varDate           : PivoteRespuesta       :=
        ( MyInput = varDouble ) OR ( MyInput = varDate );
      varNull           : PivoteRespuesta       := TRUE;
    END;  { CASE MyVar1 }
  END;            { IF MyInput = Null ELSE }
  CAFE_TypeSimpleValorCompatible                := PivoteRespuesta;
END;   { FUNCTION CAFE_TypeSimpleValorCompatible }

  { IMPLEMENTATION }
FUNCTION    ImplementationOverloadTypeSimpleValorCompatible
  (       MyVar1, MyInput       : SizeInt                       ) : Boolean;

BEGIN  { FUNCTION ImplementationOverloadTypeSimpleValorCompatible }
  IF ( MyVar1 = MyInput ) THEN BEGIN
    ImplementationOverloadTypeSimpleValorCompatible     := TRUE;
    Exit;
  END;  { IF ( MyVar1 = MyInput ) }
  IF ( MyVar1 <> varNull ) AND ( MyInput = varNull )
  THEN ImplementationOverloadTypeSimpleValorCompatible  := FALSE
  ELSE ImplementationOverloadTypeSimpleValorCompatible  :=
                CAFE_TypeSimpleValorCompatible( MyVar1, MyInput );
END;   { FUNCTION ImplementationOverloadTypeSimpleValorCompatible }
  { IMPLEMENTATION }

FUNCTION    CAFE_GenerarPaqueteRectangular
  (       TamanoFila, TamanoColumna             : LongInt;
          ClaveSintactico                       : LongInt       ) : LongInt;
VAR
  NuevoItem                     : CAFE_ItemRectangular;
  RecorreDouble                 : LongInt;

BEGIN  { FUNCTION CAFE_GenerarPaqueteRectangular }
  IF ClaveSintactico <> ImplementationCicloRectangularSintactico
  THEN CAFE_ItemListaRectangular.Clear;
  ImplementationCicloRectangularSintactico      := ClaveSintactico;
  NuevoItem                     :=
        CAFE_ItemListaRectangular.Add as CAFE_ItemRectangular;
  WITH NuevoItem DO BEGIN
    FilasDouble                 := TamanoFila;
    ColumnasDouble              := TamanoColumna;
    SetLength( ArregloDoubleSector, FilasDouble*ColumnasDouble );
    BanderaRectangular          := TRUE;
    FOR RecorreDouble := Low( ArregloDoubleSector ) TO
                         High( ArregloDoubleSector )
    DO ArregloDoubleSector[ RecorreDouble ]     := 0.0;
    ClaveCicloRectangular       := ClaveSintactico;
  END;  { WITH NuevoItem }
  CAFE_GenerarPaqueteRectangular                := NuevoItem.ID;
END;   { FUNCITON CAFE_GenerarPaqueteRectangular }

CONSTRUCTOR CAFE_ItemRectangular.Create
  (       ACollection           : TCollection                           );
{ override; }
BEGIN  { CONSTRUCTOR CAFE_ItemRectangular.Create }
  Inherited;
  ArregloDoubleSector           := NIL;
  FilasDouble                   := 0;
  ColumnasDouble                := 0;
  ClaveCicloRectangular         := 0;
  BanderaRectangular            := FALSE;
END;   { CONSTRUCTOR CAFE_ItemRectangular.Create }

DESTRUCTOR  CAFE_ItemRectangular.Destroy;
{ override; }
BEGIN  { DESTRUCTOR CAFE_ItemRectangular.Destroy }
  SetLength( ArregloDoubleSector, 0 );
  FilasDouble                   := 0;
  ColumnasDouble                := 0;
  ClaveCicloRectangular         := 0;
  BanderaRectangular            := FALSE;
  Inherited;
END;   { DESTRUCTOR CAFE_ItemRectangular.Destroy }

PROCEDURE   CAFE_ItemRectangular.EscribirDoubleItemRectangular
  (       ValorDouble           : Double;
          FilaPaquete, ColumnaPaquete           : LongInt               );
BEGIN  { PROCEDURE CAFE_ItemRectangular.EscribirDoubleItemRectangular }
  ArregloDoubleSector[ FilaPaquete*ColumnasDouble+ColumnaPaquete ]
                                := ValorDouble;
END;   { PROCEDURE CAFE_ItemRectangular.EscribirDoubleItemRectangular }

FUNCTION    CAFE_ItemRectangular.LeerDoubleItemRectangular
  (       FilaPaquete, ColumnaPaquete           : LongInt       ) : Double;
BEGIN  { FUNCTION CAFE_ItemRectangular.LeerDoubleItemRectangular }
  LeerDoubleItemRectangular     :=
        ArregloDoubleSector[ FilaPaquete*ColumnasDouble+ColumnaPaquete ];
END;   { FUNCTION CAFE_ItemRectangular.LeerDoubleItemRectangular }

FUNCTION    CAFE_ItemRectangular.ReadItems
  (     Ide                     : LongInt                       ) : Double;
BEGIN  { CAFE_ItemRectangular.ReadItems }
  ReadItems                     := ArregloDoubleSector[ Ide ];
END;   { CAFE_ItemRectangular.ReadItems }

PROCEDURE   CAFE_ItemRectangular.WriteItems
  (     Ide                     : LongInt;
        MyDouble                : Double                                );
BEGIN  { CAFE_ItemRectangular.WriteItems }
  ArregloDoubleSector[ Ide ]    := MyDouble;
END;   { CAFE_ItemRectangular.WriteItems }

CONSTRUCTOR CAFE_TCollectionRectangular.Create;
{ virtual; }
BEGIN  { CAFE_TCollectionRectangular }
  inherited Create( CAFE_ItemRectangular );
END;   { CAFE_TCollectionRectangular }

FUNCTION    CAFE_TCollectionRectangular.ReadItemID
  (     Ide                     : LongInt       ) : CAFE_ItemRectangular;
VAR
  PivoteItem                    : TCollectionItem;

BEGIN  { FUNCTION CAFE_TCollectionRectangular.ReadItemID }
  PivoteItem                    := FindItemID( Ide );
  IF PivoteItem = NIL
  THEN ReadItemID               := NIL
  ELSE ReadItemID               := PivoteItem as CAFE_ItemRectangular;
END;   { FUNCTION CAFE_TCollectionRectangular.ReadItemID K7}

CONSTRUCTOR CAFE_TCollectionManejador0.Create;
{ virtual; }
BEGIN  { CONSTRUCTOR CAFE_ManejadorBasico }
  inherited Create( NIL, CAFE_TipoManejadorAsignado );
END;   { CONSTRUCTOR CAFE_ManejadorBasico }

DESTRUCTOR  CAFE_TCollectionManejador0.Destroy;
{ override; }
VAR
  RecorreCol                    : TCollectionItem;

BEGIN  { DESTRUCTOR CAFE_TCollectionManejador0.Destroy }
  FOR RecorreCol IN Self DO BEGIN
    FreeAndNil( ( RecorreCol as CAFE_ManejadorBasico ).HojaDefaultI );
  END;  { FOR RecorreCol }
  Inherited;
END;   { DESTRUCTOR CAFE_TCollectionManejador0.Destroy }

  Class
PROCEDURE   CAFE_TCollectionManejador0.Activar;
{ virtual; }
BEGIN  { PROCEDURE CAFE_TCollectionManejador0.Activar }
  CAFE_RaizManejadores          := CAFE_TipoCollectionPrincipal.Create;
END;   { PROCEDURE CAFE_TCollectionManejador0.Activar }

  Class
PROCEDURE   CAFE_TCollectionManejador0.Desactivar;
{ virtual; }
BEGIN  { PROCEDURE CAFE_TCollectionManejador0.Desactivar }
  FreeAndNil( CAFE_RaizManejadores );
  CAFE_ItemListaRectangular.Clear;
  CAFE_DefaultListaString.Clear;
END;   { PROCEDURE CAFE_TCollectionManejador0.Desactivar }

PROCEDURE   CAFE_TCollectionManejador0.AtFreeID
  (       Ide                   : LongInt;
          BorrarHoja            : Boolean       = FALSE                 );
VAR
  MyManejador                   : CAFE_ManejadorBasico;

BEGIN  { PROCEDURE CAFE_TCollectionManejador0.AtFreeID }
  MyManejador                   := ID[ Ide ];
  IF MyManejador <> NIL THEN BEGIN
    IF BorrarHoja THEN FreeAndNil( MyManejador.HojaDefaultI );
    Delete( MyManejador.Index );
  END;  { IF MyManejador <> NIL }
END;   { PROCEDURE CAFE_TCollectionManejador0.AtFreeID }

FUNCTION    CAFE_TCollectionManejador0.ReadItemID
  (     Ide                     : LongInt       ) : CAFE_ManejadorBasico;
VAR
  PivoteItem                    : TCollectionItem;

BEGIN  { FUNCTION CAFE_TCollectionManejador0.ReadItemID }
  PivoteItem                    := FindItemID( Ide );
  IF PivoteItem = NIL
  THEN ReadItemID               := NIL
  ELSE ReadItemID               := PivoteItem as CAFE_ManejadorBasico;
END;   { FUNCTION CAFE_TCollectionManejador0.ReadItemID }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_CharByte3Sintactico.Create
  (     Tamano          : LongInt                               );
BEGIN  { CONSTRUCTOR CAFE_CharByte3Sintactico.Create }
  Inherited;
  ModeloInterior        := CAFE_CharByte3Sintactico;
END;   { CONSTRUCTOR CAFE_CharByte3Sintactico.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_CharByte3Sintactico.Create
  ( CONST
        Msg             : ShortString;
        Tamano          : LongInt                               );
BEGIN  { CONSTRUCTOR CAFE_CharByte3Sintactico.Create }
  Inherited;
  ModeloInterior        := CAFE_CharByte3Sintactico;
END;   { CONSTRUCTOR CAFE_CharByte3Sintactico.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_CharByte3Sintactico.Create
  (     Modelo          : CAFE_ClassCharByte                    );
BEGIN  { CONSTRUCTOR CAFE_CharByte2Sintactico.Create }
  Inherited;
  ModeloInterior                := CAFE_CharByte3Sintactico;
END;   { CONSTRUCTOR CAFE_CharByte2Sintactico.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

FUNCTION    CAFE_CharByte3Sintactico.VerificarIdentificador
  ( CONST CadenaIdentificador   : ShortString                   ) : Boolean;
VAR
  PivoteCadena                  : ShortString;

BEGIN  { FUNCTION CAFE_CharByte3Sintactico.VerificarIdentificador }
  ImplementationSintactico.InsertarString( CadenaIdentificador );
  VerificarIdentificador        := ImplementationSintactico.
        VerificarIdentificadorBasico( PivoteCadena,
                CAFE_PrimerByteIdentificadorSintactico,
                CAFE_MedioByteIdentificadorSintactico,
                CAFE_UltimoByteIdentificadorSintactico );
END;   { FUNCTION CAFE_CharByte3Sintactico.VerificarIdentificador }

FUNCTION    CAFE_CharByte3Sintactico.GramaticaOperadores
  ( CONST Msg           : ShortString;
          Lista         : CAFE_TStringList              = NIL   ) : Boolean;
{ virtual; }
VAR
  CadenaError                   : ShortString           = '';
  ConteoParentesisAbrir,
  ConteoParentesisCerrar,
  PosicionActual                : LongInt;

LABEL
  SalidaFalsa;

BEGIN  { FUNCTION CAFE_CharByte3Sintactico.GramaticaOperadores }
  IF Lista = NIL THEN Lista     := CAFE_DefaultListaString;
  InsertarString( Msg );
  IF Ocupado < TamanoVector THEN BEGIN
    Inc( Ocupado );
    Self[ Ocupado ]             := 13;
    // Retorno de carro
    // Final usual de comentario
    Self[ Ocupado+1 ]           := 0;
  END;  { IF Ocupado < TamanoVector }
  IF CAFE_IntentoInfructuosoSintactico THEN GOTO SalidaFalsa;
  CAFE_EliminarSustituirUpCaseBlancoComentario( Self, TRUE );
  IF CAFE_IntentoInfructuosoSintactico THEN GOTO SalidaFalsa;
  PosicionActual                := 0;
  WHILE ImplementationSintactico.ExtraccionSustitucionByteDuplicadoString
      ( Self, PosicionActual, FALSE, Lista ) DO Continue;
  IF CAFE_IntentoInfructuosoSintactico THEN GOTO SalidaFalsa;
  CAFE_DesplazarBlancoParentesisIzquierdo
      ( Self, CAFE_ByteParentesisAbrirSintactico, '', FALSE );
  IF CAFE_IntentoInfructuosoSintactico THEN GOTO SalidaFalsa;
  CAFE_AgregarEspacioIzquierdoOperadorConfundiblePrecedencia
      ( Self, @CAFE_RegistroPrecedenciaOperadorSintacticoPascal );
  IF CAFE_IntentoInfructuosoSintactico THEN GOTO SalidaFalsa;
  PosicionActual                := 0;
  IF BuscarSiguienteCadena( PosicionActual, ':=', TRUE ) THEN BEGIN
    InsertarString( CAFE_OperadorAsignacionBasicaTraducidoOperadorBasico );
    GramaticaOperadores         := TRUE;
    // Esto probablemente no sea cierto
    // Simplemente se procesa la asignacion posteriormente
    // note que la informacion se pierde
    Exit;
  END;  { IF BuscarSiguienteCadena... }
  ImplementationSintactico.ReescribirOperadoresReferenciaNivelesPrecedencia
      ( Self, @CAFE_RegistroPrecedenciaDescriptorIdentificadorPascal,
        CadenaError );
  IF CAFE_IntentoInfructuosoSintactico THEN GOTO SalidaFalsa;
  ImplementationSintactico.ReescribirOperadoresReferenciaNivelesPrecedencia
      ( Self, @CAFE_RegistroPrecedenciaOperadorSintacticoPascal,
        CadenaError );
  IF CAFE_IntentoInfructuosoSintactico THEN GOTO SalidaFalsa;
  CAFE_DesplazarBlancoParentesisIzquierdo
      ( Self, CAFE_ByteParentesisAbrirSintactico,
              CAFE_OperadorParentesisTraducidoOperadorBasico, TRUE );
  IF CAFE_IntentoInfructuosoSintactico THEN GOTO SalidaFalsa;
  ExtraccionBlancoParentesis( CAFE_ByteBlancoSintactico,
        CAFE_ByteParentesisAbrirSintactico,
        CAFE_ByteParentesisCerrarSintactico );
  ConteoParentesisAbrir                 := 0;
  ConteoParentesisCerrar                := 0;
  PosicionActual                        := 0;
  WHILE BuscarSiguienteByte( PosicionActual,
        CAFE_ByteParentesisAbrirSintactico, TRUE, TRUE )
  DO Inc( ConteoParentesisAbrir );
  PosicionActual                        := 0;
  WHILE BuscarSiguienteByte( PosicionActual,
        CAFE_ByteParentesisCerrarSintactico, TRUE, TRUE )
  DO Inc( ConteoParentesisCerrar );
  IF ConteoParentesisAbrir < ConteoParentesisCerrar THEN BEGIN
    CAFE_PosicionInfructuosoSintactico  :=
                        CAFE_4ErrorExcesoParentesisCerrados;
    CAFE_MensajeInfructuosoSintactico   := 'Exceso de parentesis cerrados';
    CAFE_IntentoInfructuosoSintactico   := TRUE;
    GramaticaOperadores                 := FALSE;
    Exit;
  END;  { IF ConteoParentesisAbrir <> ConteoParentesisCerrar }
  WHILE ConteoParentesisAbrir > ConteoParentesisCerrar DO BEGIN
    Inc( ConteoParentesisCerrar );
    Inc( Ocupado );
    Self[ Ocupado ]             := CAFE_ByteParentesisCerrarSintactico;
    // Retorno de carro
    // Final usual de comentario
    Self[ Ocupado+1 ]           := 0;
  END;  { IF ConteoParentesisAbrir > ConteoParentesisCerrar }
  GramaticaOperadores                   := TRUE;
  Exit;
SalidaFalsa :
  IF CadenaError <> '' THEN BEGIN
    CAFE_MensajeInfructuosoSintactico        := CadenaError;
    // Version final : 'CadenaError' con error de sintaxis
    CAFE_PosicionInfructuosoSintactico       :=
                CAFE_4ErrorGramaticaOperadoresCadenaError;
    CAFE_IntentoInfructuosoSintactico        := TRUE;
  END ELSE BEGIN  { IF CadenaError <> '' ELSE }
    IF NOT( CAFE_IntentoInfructuosoSintactico ) THEN BEGIN
      CAFE_IntentoInfructuosoSintactico   := TRUE;
      CAFE_MensajeInfructuosoSintactico   := 'Error de sintaxis';
      CAFE_PosicionInfructuosoSintactico  :=
                CAFE_4ErrorGramaticaOperadoresGeneral;
    END;  { IF NOT( CAFE_IntentoInfructuosoSintactico ) }
  END;            { IF CadenaError <> '' ELSE }
  GramaticaOperadores                   := FALSE;
END;   { FUNCTION CAFE_CharByte3Sintactico.GramaticaOperadores }

DESTRUCTOR  CAFE_CharByte3Sintactico.Destroy;
BEGIN  { DESTRUCTOR CAFE_CharByte3Sintactico.Destroy }
  Inherited Destroy;
END;   { DESTRUCTOR CAFE_CharByte3Sintactico.Destroy }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_Interprete2Sintactico.Create;
BEGIN  { CONSTRUCTOR CAFE_InterpreteSintactico.Create }
  Inherited Create;
  InterpreteReferencia          := CAFE_Interprete2Sintactico;
  TotalParametros               := 0;
  ProfundidadSintactica         := 0;
  ClaveInterpretado             := 0;
  SiguienteIdentificador        := NIL;
  DescriptorInterprete          := [ ];
  ResultadoPrincipal            := varNull;
  ParametroUno                  := varNull;
  ParametroDos                  := varNull;
  ParametroTres                 := varNull;
  Parametrizacion               := NIL;
END;   { CONSTRUCTOR CAFE_InterpreteSintactico.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_Interprete2Sintactico.Create
  ( CONST Nombre                : ShortString;
          NuevoValor            : Variant                               );
BEGIN  { CONSTRUCTOR CAFE_InterpreteSintactico.Create }
  Inherited Create( Nombre, NuevoValor );
  InterpreteReferencia          := CAFE_Interprete2Sintactico;
  TotalParametros               := 0;
  ProfundidadSintactica         := 0;
  ClaveInterpretado             := 0;
  SiguienteIdentificador        := NIL;
  DescriptorInterprete          := [ ActivoNITI, VarNITI ];
  ResultadoPrincipal            := CAFE_TipoVariante( NuevoValor );
  ParametroUno                  := varNull;
  ParametroDos                  := varNull;
  ParametroTres                 := varNull;
  Parametrizacion               := NIL;
END;   { CONSTRUCTOR CAFE_InterpreteSintactico.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
PROCEDURE   CAFE_Interprete2Sintactico.VaciarDatos;
BEGIN  { PROCEDURE CAFE_Interprete2Sintactico.VaciarDatos }
  NombreIdentificador           := '';
  ValorInterpretado             := Null;
  BanderaVariant                := TRUE;
  BanderaSimple                 := TRUE;
  TotalParametros               := 0;
  ProfundidadSintactica         := 0;
  ClaveInterpretado             := 0;
  FreeAndNil( SiguienteIdentificador );
  DescriptorInterprete          := [];
  ResultadoPrincipal            := varNull;
  ParametroUno                  := varNull;
  ParametroDos                  := varNull;
  ParametroTres                 := varNull;
  FreeAndNil( Parametrizacion );
END;   { PROCEDURE CAFE_Interprete2Sintactico.VaciarDatos }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

PROCEDURE   CAFE_Interprete2Sintactico.EstablecerCasillaHojaDefault
  (       FilaAbsoluta          : Boolean;
          Fila                  : LongInt;
          ColumnaAbsoluta       : Boolean;
          Columna               : LongInt                               );
BEGIN  { PROCEDURE CAFE_Interprete2Sintactico.EstablecerCasillaHojaDefault }
  VaciarDatos;
  BanderaVariant                := FALSE;
  DescriptorInterprete          :=
        [ ActivoNITI, CasillaHojaNITI, HojaDefaultNITI, NudilladoNITI ];
  IF ColumnaAbsoluta
  THEN Include( DescriptorInterprete, AbsolutoColumnaNITI );
  IF FilaAbsoluta
  THEN Include( DescriptorInterprete, AbsolutoFilaNITI );
  GenerarNombreCasillaHoja
        ( NombreIdentificador, ColumnaAbsoluta, Columna, FilaAbsoluta, Fila );
  ValorInterpretado             := varNull;
  ValorInterpretado             := VarArrayCreate( [ 1, 2 ], varInteger );
  ValorInterpretado[ 1 ]        := Fila;
  ValorInterpretado[ 2 ]        := Columna;
END;   { PROCEDURE CAFE_Interprete2Sintactico.EstablecerCasillaHojaDefault }

  {$IFDEF       SILENCIAR       }
  {$HINTS       OFF             }
  {$ENDIF                       }
PROCEDURE   CAFE_Interprete2Sintactico.DefaultPredefinidos
  (       Manejador             : CAFE_InterfaceBasico;
          Quimico               : Boolean;
          Graficador            : Boolean       = FALSE                 );
VAR
  RecorreFuncion                : LongInt;
  Resultado                     : Variant;
  PivoteEntero                  : LongInt;

BEGIN  { CAFE_Interprete2Sintactico.DefaultPredefinidos }
  NombreIdentificador           := CAFE_IdentificadorStringNull;
  ValorInterpretado             := ImplementationStringNull;
//  VarCast( ValorInterpretado, 0, varByte );
  DescriptorInterprete          :=
                        [ ActivoNITI, PredefinidoNITI, ConstNITI ];
  AnexarManejadorPrincipal
        ( CAFE_CadenaIdentificadorSelf, Manejador.Actual.ID, TRUE );
  Include( UltimoLista.DescriptorInterprete, PredefinidoNITI );
  UltimoLista.ClaveInterpretado := ClaveEjesIdentificadorSelf;
  AnexarPredefinidoVariant( 'PI', Pi );
  AnexarPredefinidoVariant( 'E', Exp( 1 ) );
  AnexarPredefinidoVariant( 'RANDOM', 0.0 );
  UltimoLista.ClaveInterpretado := ClaveEjesIdentificadorRandom;
  AnexarPredefinidoVariant( 'TODAY', CAFE_DefaultNuloVariant( varDate ) );
  UltimoLista.ClaveInterpretado := ClaveEjesIdentificadorHoy;
  AnexarPredefinidoVariant( 'TRUE', TRUE );
  AnexarPredefinidoVariant( 'FALSE', FALSE );
  AnexarPredefinidoVariant( 'ON', TRUE );
  AnexarPredefinidoVariant( 'OFF', FALSE );
  AnexarPredefinidoVariant( 'YES', TRUE );
  AnexarPredefinidoVariant( 'SI', TRUE );
  AnexarPredefinidoVariant( 'NO', FALSE );
  PivoteEntero                  := 0;
  AnexarPredefinidoVariant( CAFE_StringFijarEnFila, PivoteEntero );
  UltimoLista.ClaveInterpretado := ClaveEjesIdentificadorFijarEnFila;
  AnexarPredefinidoVariant( CAFE_StringFijarEnColumna, PivoteEntero );
  UltimoLista.ClaveInterpretado := ClaveEjesIdentificadorFijarEnColumna;
  WITH Manejador.Actual as CAFE_ManejadorBasico
  DO BEGIN
    PaqueteIdioma.Add
        ( 'AZAR'+CAFE_NameValueSeparator+'RANDOM' );
    PaqueteIdioma.Add
        ( 'HOY'+CAFE_NameValueSeparator+'TODAY' );
    PaqueteIdioma.Add
        ( 'ALEATORIO'+CAFE_NameValueSeparator+'RANDOM' );
    PaqueteIdioma.Add
        ( 'MISMO'+CAFE_NameValueSeparator+CAFE_CADENAIDENTIFICADORSELF );
    PaqueteIdioma.Add
        ( 'VERDADERO'+CAFE_NameValueSeparator+'TRUE' );
    PaqueteIdioma.Add
        ( 'VERDAD'+CAFE_NameValueSeparator+'TRUE' );
    PaqueteIdioma.Add
        ( 'CIERTO'+CAFE_NameValueSeparator+'TRUE' );
    PaqueteIdioma.Add
        ( 'FALSO'+CAFE_NameValueSeparator+'FALSE' );
    PaqueteIdioma.Add
        ( 'ENCENDIDO'+CAFE_NameValueSeparator+'ON' );
    PaqueteIdioma.Add
        ( 'APAGADO'+CAFE_NameValueSeparator+'OFF' );
    PaqueteIdioma.Add
        ( '$COLUMN'+CAFE_NameValueSeparator+CAFE_StringFijarEnColumna );
    PaqueteIdioma.Add
        ( '$ROW'+CAFE_NameValueSeparator+CAFE_StringFijarEnFila );
  END;  { WITH Manejador.Actual as CAFE_ManejadorBasico }
  IF Quimico THEN BEGIN
    // 1L = 0.055063 pulgadas 1 metro = 715 L
    // 814 Tom = 1 s
    // 10000 D = T.f. Agua 273.15
    // mp = 1E-23 M
    // M = 1.67482E-4 Kg
    // e = 1E-20E Emma, Monica, Daniel, Tom, Lisa
    AnexarPredefinidoVariant( 'MP', 1E-23 );
    AnexarPredefinidoVariant( 'N', 1E20 );
    AnexarPredefinidoVariant( 'TS', 10000 );
    AnexarPredefinidoVariant( 'C', 2.63331250E8 );
    AnexarPredefinidoVariant( 'J', 6.44301 );
    AnexarPredefinidoVariant( 'H', 3.475181E-34 );
    AnexarPredefinidoVariant( 'EE', 1E-20 );
    AnexarPredefinidoVariant( 'ATM', 1.68027E-3 );
    AnexarPredefinidoVariant( 'K', 2.42976E-24 );
    AnexarPredefinidoVariant( 'R', 2.42976E-4 );
  END;  { IF CAFE_BanderaQuimico }
  FOR RecorreFuncion := 1 TO TotalFuncionPredefinidas DO BEGIN
    WITH ArregloFuncionPredefinida[ RecorreFuncion ] DO BEGIN
      CASE TipoFuncionPredefinida OF
        varBoolean              : Resultado     := FALSE;
        varDouble               : CAFE_VarCast( Resultado, 0.0, varDouble );
        varInteger              : CAFE_VarCast( Resultado, 0, varInteger );
        varByte                 : CAFE_VarCast( Resultado, 0, varByte );
        varDate                 :
                Resultado     := CAFE_DefaultNuloVariant( varDate );
        varString               : Resultado     :=
                                        ImplementationResultadoString;
        varNull                 : Resultado     := Null;
        varAny                  : Resultado     := Null;
        ELSE RAISE Exception.Create( 'Funcion mal definida' );
      END;  { CASE TipoFuncionPredefinida }
      AnexarPredefinidoFuncion( NombreFuncionPredefinida, Resultado,
          Parametro1FuncionPredefinida, Parametro2FuncionPredefinida,
          Parametro3FuncionPredefinida );
      WITH UltimoLista DO BEGIN
        DescriptorInterprete    :=
                DescriptorInterprete+EspecialFuncionPredefinida;
        IF Graficador THEN BEGIN
          IF ClaveFuncionPredefinida <> ClaveLengthArray
          THEN Exclude( DescriptorInterprete, SilenciarSectorNITI );
        END;  { IF Graficador }
        ClaveInterpretado       := ClaveFuncionPredefinida;
        IF AliasFuncionPredefinida <> '' THEN BEGIN
          WITH Manejador.Actual as CAFE_ManejadorBasico
          DO BEGIN
            PaqueteIdioma.Add
                ( AliasFuncionPredefinida+
                        CAFE_NameValueSeparator+
                        NombreFuncionPredefinida );
          END;  { WITH Manejador.Actual as CAFE_ManejadorBasico }
        END;  { IF AliasFuncionPredefinida <> '' }
      END;  { WITH UltimoLista }
    END;  { WITH ArregloFuncionPredefinida[ RecorreFuncion ] }
  END;  { FOR RecorreFuncion }
END;   { CAFE_Interprete2Sintactico.DefaultPredefinidos }
  {$IFDEF       SILENCIAR       }
  {$HINTS       ON              }
  {$ENDIF                       }

FUNCTION    CAFE_Interprete2Sintactico.BusquedaNombreIdentificador
  ( CONST Nombre                : ShortString;
          Actual                : CAFE_Interprete2Sintactico    = NIL;
          BanderaActivo         : Boolean                       = TRUE
                                ) : CAFE_Interprete2Sintactico;
VAR
  RecorreActual                 : CAFE_Interprete2Sintactico;
  FinBusqueda                   : Boolean;

BEGIN  { FUNCTION CAFE_Interprete2Sintactico.BusquedaNombreIdentificador }
  IF Nombre = '' THEN Exit( NIL );
  IF Actual = NIL
  THEN RecorreActual            := Self
  ELSE RecorreActual            := Actual.SiguienteIdentificador;
  FinBusqueda                   := FALSE;
  REPEAT
    IF RecorreActual = NIL
    THEN FinBusqueda            := TRUE
    ELSE BEGIN
      IF RecorreActual.NombreIdentificador = Nombre THEN BEGIN
        IF BanderaActivo THEN BEGIN
          IF ActivoNITI IN RecorreActual.DescriptorInterprete
          THEN FinBusqueda      := TRUE
          ELSE RecorreActual    := RecorreActual.SiguienteIdentificador;
        END ELSE BEGIN
          FinBusqueda           := TRUE;
        END;
      END ELSE BEGIN  { IF RecorreActual.NombreIdentificador = Nombre }
        RecorreActual           := RecorreActual.SiguienteIdentificador;
      END;
    END;
  UNTIL FinBusqueda;
  BusquedaNombreIdentificador   := RecorreActual;
END;   { FUNCTION CAFE_Interprete2Sintactico.BusquedaNombreIdentificador }

PROCEDURE   CAFE_Interprete2Sintactico.AnexarManejadorPrincipal
  (     NombreManejador         : ShortString;
        ControlID               : LongInt;
        BanderaSelf             : Boolean       = FALSE                 );
VAR
  NuevoDato                     : CAFE_InterpreteSintactico;

BEGIN  { PROCEDURE CAFE_Interprete2Sintactico.AnexarManejadorPrincipal }
  NuevoDato                     :=
                InterpreteReferencia.Create( NombreManejador, ControlID );
  UltimoLista.SiguienteIdentificador            :=
                                NuevoDato as CAFE_Interprete2Sintactico;
  WITH NuevoDato as CAFE_Interprete2Sintactico DO BEGIN
    DescriptorInterprete        :=
                [ ActivoNITI, RegistroAsociadoNITI, ManejadorPrincipalNITI ];
    IF BanderaSelf THEN Include( DescriptorInterprete, ManejadorSelfNITI );
  END;  { WITH NuevoDato }
END;   { PROCEDURE CAFE_Interprete2Sintactico.AnexarManejadorPrincipal }

PROCEDURE   CAFE_Interprete2Sintactico.AnexarPredefinidoVariant
  (     Nombre                  : ShortString;
        NuevoValor              : Variant                               );
VAR
  NuevoDato                     : CAFE_InterpreteSintactico;

BEGIN  { PROCEDURE CAFE_Interprete2Sintactico.AnexarPredefinidoVariant }
  NuevoDato                     :=
                InterpreteReferencia.Create( Nombre, NuevoValor );
  UltimoLista.SiguienteIdentificador            :=
                                NuevoDato as CAFE_Interprete2Sintactico;
  WITH NuevoDato as CAFE_Interprete2Sintactico DO BEGIN
    DescriptorInterprete        := [ ActivoNITI, PredefinidoNITI, ConstNITI ];
  END;  { WITH NuevoDato }
END;   { PROCEDURE CAFE_Interprete2Sintactico.AnexarPredefinidoVariant }

PROCEDURE   CAFE_Interprete2Sintactico.AnexarPredefinidoFuncion
  (     Nombre                  : ShortString;
        ValorInicial            : Variant;
        P1, P2, P3              : SizeInt                               );
VAR
  NuevoDato                     : CAFE_InterpreteSintactico;

BEGIN  { PROCEDURE CAFE_Interprete2Sintactico.AnexarPredefinidoFuncion }
  NuevoDato                     :=
                InterpreteReferencia.Create( Nombre, ValorInicial );
  UltimoLista.SiguienteIdentificador            :=
                                NuevoDato as CAFE_Interprete2Sintactico;
  WITH NuevoDato as CAFE_Interprete2Sintactico DO BEGIN
    BanderaVariant              := FALSE;
    DescriptorInterprete        :=
                [ ActivoNITI, PredefinidoNITI, ConstNITI, FuncionalNITI ];
    ResultadoPrincipal          := CAFE_TipoVariante( ValorInicial );
    ParametroUno                := P1;
    ParametroDos                := P2;
    ParametroTres               := P3;
    TotalParametros             := 3;
    IF P3 = varNull THEN TotalParametros        := 2;
    IF P2 = varNull THEN TotalParametros        := 1;
    IF P1 = varNull THEN TotalParametros        := 0;
  END;  { WITH NuevoDato }
END;   { PROCEDURE CAFE_Interprete2Sintactico.AnexarPredefinidoFuncion }

  {$IFDEF       SILENCIAR       }
  {$HINTS       OFF             }
  {$ENDIF                       }
FUNCTION    ImplementationAuxiliarLaplace
  (     X   : Double; P         : Pointer                       ) : Double;
CONST
  FactorInterno                 = 1/SqRt( 2*Pi );

BEGIN  { FUNCTION ImplementationAuxiliarLaplace }
  ImplementationAuxiliarLaplace := FactorInterno*Exp( -X*X/2 );
END;   { FUNCTION ImplementationAuxiliarLaplace }
  {$IFDEF       SILENCIAR       }
  {$HINTS       ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$HINTS       OFF             }
  {$ENDIF                       }
FUNCTION    ImplementationAuxiliarLaplaceInversa
  (     X   : Double; P         : Pointer                       ) : Double;
CONST
  FactorInterno                 = 1/SqRt( 2*Pi );

BEGIN  { FUNCTION ImplementationAuxiliarLaplaceInversa }
  TRY
    IF ( ABS( X ) = Pi/2 )
    THEN ImplementationAuxiliarLaplaceInversa   := 0.0
    ELSE ImplementationAuxiliarLaplaceInversa   :=
                  FactorInterno*Exp( -Sqr( Tan( X ) )/2 )*Sqr( Sec( X ) );
  EXCEPT
    ImplementationAuxiliarLaplaceInversa        := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarLaplaceInversa }
  {$IFDEF       SILENCIAR       }
  {$HINTS       ON              }
  {$ENDIF                       }

TYPE
  PointerPaqueteDistribucionF           = ^PaqueteDistribucionF;

  PaqueteDistribucionF          = RECORD

    D1LibreDistribucionF        : Double;
    D2LibreDistribucionF        : Double;
    IgualDistribucionF          : Double;

                                  END;  { RECORD PaqueteDistribucionF }

FUNCTION    ImplementationAuxiliarDistribucionF
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  Paq                           : PointerPaqueteDistribucionF;

BEGIN  { FUNCTION ImplementationAuxiliarDistribucionF }
  TRY
    Paq                         := Pointer( P );
    WITH Paq^ DO
      ImplementationAuxiliarDistribucionF :=
                Power( X, D1LibreDistribucionF/2-1 )*
                Power( 1+X*D1LibreDistribucionF/D2LibreDistribucionF,
                        -( D1LibreDistribucionF+D2LibreDistribucionF )/2 );
  EXCEPT
    ImplementationAuxiliarDistribucionF := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarDistribucionF }

FUNCTION    ImplementationAuxiliarDistribucionFInversa
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  Paq                           : PointerPaqueteDistribucionF;

BEGIN  { FUNCTION ImplementationAuxiliarDistribucionFInversa }
  TRY
    Paq                         := Pointer( P );
    WITH Paq^ DO
      IF ( ABS( X ) = Pi/2 )
      THEN ImplementationAuxiliarDistribucionFInversa   := 0.0
      ELSE ImplementationAuxiliarDistribucionFInversa   :=
                Power( Tan( X ), D1LibreDistribucionF/2-1 )*
                Power( 1+Tan( X )*D1LibreDistribucionF/D2LibreDistribucionF,
                        -( D1LibreDistribucionF+D2LibreDistribucionF )/2 )*
                        Sqr( Sec( X ) );
  EXCEPT
    ImplementationAuxiliarDistribucionFInversa          := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarDistribucionFInversa }

FUNCTION    ImplementationAuxiliarTStudentInversa
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  V                             : Double;

BEGIN  { FUNCTION ImplementationAuxiliarTStudentInversa }
  TRY
    V                           := PDouble( P )^;
    IF ( ABS( X ) = Pi/2 )
    THEN ImplementationAuxiliarTStudentInversa  := 0.0
    ELSE ImplementationAuxiliarTStudentInversa  :=
                  Power( 1+Sqr( Tan( X ) )/V, -( V+1 )/2 )*Sqr( Sec( X ) );
  EXCEPT
    ImplementationAuxiliarTStudentInversa       := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarTStudentInversa }

FUNCTION    ImplementationAuxiliarChiSquareInversa
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  K                             : Double;

BEGIN  { FUNCTION ImplementationAuxiliarChiSquareInversa }
  TRY
    K                           := PDouble( P )^;
    IF ( ABS( X ) = Pi/2 )
    THEN ImplementationAuxiliarChiSquareInversa := 0.0
    ELSE ImplementationAuxiliarChiSquareInversa :=
           Power( Tan( X ), K/2-1 )*Exp( -Tan( X )/2 )*Sqr( Sec( X ) );
  EXCEPT
    ImplementationAuxiliarChiSquareInversa      := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarChiSquareInversa }

FUNCTION    ImplementationAuxiliarIntegralLaplaceInversa
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  PivoteResultado,
  Y                             : Double;

BEGIN  { FUNCTION ImplementationAuxiliarIntegralLaplaceInversa }
  TRY
    IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado,
                0, X, @ImplementationAuxiliarLaplaceInversa, NIL,
                CAFE_DefaultToleranciaFuncionalLento ) )
    THEN RAISE CAFE_Exception.Create( 'Error al calcular LaplaceInverso' );
    Y                           := PDouble( P )^;
    ImplementationAuxiliarIntegralLaplaceInversa        :=
                                                PivoteResultado-Y;
  EXCEPT
    ImplementationAuxiliarIntegralLaplaceInversa        := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarIntegralLaplaceInversa }

TYPE
  PointerPaqueteChiSquareInverso        = ^PaqueteChiSquareInverso;

  PaqueteChiSquareInverso       = RECORD

    VLibreChiSquare             : Double;
    IgualChiSquare              : Double;

                                  END;  { RECORD PaqueteChiSquareInverso }

FUNCTION    ImplementationAuxiliarIntegralChiSquareInversa
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  MyPaquete                     : PointerPaqueteChiSquareInverso;
  PivoteResultado               : Double;

BEGIN  { FUNCTION ImplementationAuxiliarIntegralChiSquareInversa }
  TRY
    MyPaquete                   := P;
    IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado,
                0, X, @ImplementationAuxiliarChiSquareInversa,
                @( MyPaquete^.VLibreChiSquare ),
                CAFE_DefaultToleranciaFuncionalLento ) )
    THEN RAISE CAFE_Exception.Create( 'Error al calcular ChiSquareInversa' );
    ImplementationAuxiliarIntegralChiSquareInversa      :=
                PivoteResultado-MyPaquete^.IgualChiSquare;
  EXCEPT
    ImplementationAuxiliarIntegralChiSquareInversa      := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarIntegralChiSquareInversa }

FUNCTION    ImplementationAuxiliarIntegralFInversa
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  MyPaquete                     : PointerPaqueteDistribucionF;
  PivoteResultado               : Double;

BEGIN  { FUNCTION ImplementationAuxiliarIntegralFInversa }
  TRY
    MyPaquete                   := P;
    IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado,
                0, X, @ImplementationAuxiliarDistribucionFInversa, P,
                CAFE_DefaultToleranciaFuncionalF/10 ) )
    THEN RAISE CAFE_Exception.Create( 'Error al calcular IntegralFInversa' );
    ImplementationAuxiliarIntegralFInversa              :=
                PivoteResultado-MyPaquete^.IgualDistribucionF;
  EXCEPT
    ImplementationAuxiliarIntegralFInversa              := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarIntegralFInversa }

TYPE
  PointerPaqueteTStudentInverso = ^PaqueteTStudentInverso;

  PaqueteTStudentInverso        = RECORD

    VLibreTStudent              : Double;
    IgualTStudent               : Double;

                                  END;  { RECORD PaqueteTStudentInverso }

FUNCTION    ImplementationAuxiliarIntegralTStudentInversa
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  MyPaquete                     : PointerPaqueteTStudentInverso;
  PivoteResultado               : Double;

BEGIN  { FUNCTION ImplementationAuxiliarIntegralTStudentInversa }
  TRY
    MyPaquete                   := P;
    IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado,
                0, X, @ImplementationAuxiliarTStudentInversa,
                @MyPaquete^.VLibreTStudent,
                CAFE_DefaultToleranciaFuncionalLento ) )
    THEN RAISE CAFE_Exception.Create( 'Error al calcular TStudentInversa' );
    ImplementationAuxiliarIntegralTStudentInversa       :=
                PivoteResultado-MyPaquete^.IgualTStudent;
  EXCEPT
    ImplementationAuxiliarIntegralTStudentInversa       := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarIntegralTStudentInversa }

FUNCTION    ImplementationAuxiliarGamma
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  Y                             : Double;

BEGIN  { FUNCTION ImplementationAuxiliarGamma }
  TRY
    Y                           := PDouble( P )^;
    IF ( X = Pi/2 )
    THEN ImplementationAuxiliarGamma    := 0.0
    ELSE ImplementationAuxiliarGamma    :=
                  Power( Tan( X ), Y-1 )*Exp( -Tan( X) )*Sqr( Sec( X ) );
  EXCEPT
    ImplementationAuxiliarGamma         := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarGamma }

FUNCTION    ImplementationAuxiliarTStudent
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  V                             : Double;

BEGIN  { FUNCTION ImplementationAuxiliarTStudent }
  TRY
    V                           := PDouble( P )^;
    ImplementationAuxiliarTStudent      :=
                                  Power( 1+Sqr( X )/V, -( V+1 )/2 );
  EXCEPT
    ImplementationAuxiliarTStudent      := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarTStudent }

FUNCTION    ImplementationAuxiliarChiSquare
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  K                             : Double;

BEGIN  { FUNCTION ImplementationAuxiliarChiSquare }
  TRY
    K                           := PDouble( P )^;
    ImplementationAuxiliarChiSquare     :=
                                  Power( X, K/2-1 )*Exp( -X/2 );
  EXCEPT
    ImplementationAuxiliarChiSquare     := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarChiSquare }

  { IMPLEMENTATION }
TYPE
  PointerImplementationPaqueteBeta      = ^ImplementationPaqueteBeta;

  ImplementationPaqueteBeta     = RECORD
        XBeta                   : Double;
        YBeta                   : Double;
                                  END;  { ImplementationPaqueteBeta }

FUNCTION    ImplementationAuxiliarBeta
  (     X   : Double; P         : Pointer                       ) : Double;
VAR
  PaqueteBetaInterno            : PointerImplementationPaqueteBeta;

BEGIN  { FUNCTION ImplementationAuxiliarBeta }
  TRY
    PaqueteBetaInterno          := Pointer( P );
    WITH PaqueteBetaInterno^ DO BEGIN
      IF ( X = Pi/2 )
      THEN ImplementationAuxiliarBeta   := 0.0
      ELSE ImplementationAuxiliarBeta   :=
                2*Power( Sin( X ), 2*XBeta-1 )*Power( Cos( X ), 2*YBeta-1 );
    END;  { WITH PaqueteBetaInterno^ }
  EXCEPT
    ImplementationAuxiliarBeta          := 0.0;
  END;  { TRY }
END;   { FUNCTION ImplementationAuxiliarBeta }

FUNCTION    CAFE_Interprete2Sintactico.
                ReadUltimoLista                 : CAFE_Interprete2Sintactico;
BEGIN  { FUNCTION CAFE_Interprete2Sintactico.ReadUltimoLista }
  IF SiguienteIdentificador = NIL
  THEN ReadUltimoLista          := Self
  ELSE ReadUltimoLista          := SiguienteIdentificador.ReadUltimoLista;
END;   { FUNCTION CAFE_Interprete2Sintactico.ReadUltimoLista }

FUNCTION    CAFE_Interprete2Sintactico.EvaluarPredefinidoFuncionalSimple
  ( OUT   Msg                   : ShortString;
    OUT   ResultadoFuncional    : Variant;
    CONST Param1                : Variant;
    CONST Param2                : Variant;
    CONST Param3                : Variant;
          Manejador             : CAFE_InterfaceBasico;
          CicloSintactico       : LongInt                       ) : Boolean;
VAR
  MyPaqueteF                    : PaqueteDistribucionF;
  MyPaqueteChiSquare            : PaqueteChiSquareInverso;
  MyPaqueteTStudent             : PaqueteTStudentInverso;
  MyPaqueteBeta                 : ImplementationPaqueteBeta;
  CaracterMacro                 : CAFE_ConjuntoParametroBasico;
  PivoteString1,
  PivoteString2                 : ShortString;
  PivoteVariant1,
  PivoteVariant2                : Variant;
  Momento1,
  Momento2,
  Momento3,
  Momento4,
  Skew,
  Kurtosis                      : Extended;
  PivoteDefault,
  PivoteResultado,
  PivoteResultado1,
  PivoteResultado2,
  PivoteResultado3,
  PivoteReal3,
  PivoteReal1,
  PivoteReal2                   : Double;
  PivoteTDateTime1,
  PivoteTDateTime2              : TDateTime;
  PivoteEntero1,
  PivoteEntero2,
  PivoteEntero3                 : Integer;
  PivoteByte1                   : Byte;
  PivoteBoolean1,
  PivoteBoolean2                : Boolean;

BEGIN  { FUNCTION ...EvaluarPredefinidoFuncionalSimple }
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, ImplementationManejador );
  CASE ClaveInterpretado OF
    ClaveCastByte               :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param1, varByte );
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveCastByte }
    ClaveOperadorCHR            :
        BEGIN
          TRY
            PivoteByte1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, PivoteByte1, varString );
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveOperadorCHR }
    ClaveOperadorStringBasico   :
        BEGIN
          TRY
          PivoteEntero1         := Param1;
          ResultadoFuncional    := CAFE_DefaultListaString[ PivoteEntero1 ];
          EvaluarPredefinidoFuncionalSimple     := TRUE;
          EXCEPT
            ON Exception
            DO ResultadoFuncional               := FALSE;
          END;  { TRY }
        END;  { CASE ClaveOperadorStringBasico }
    ClaveParentesisDouble       :
        BEGIN
          EvaluarPredefinidoFuncionalSimple :=
                CAFE_VarCast( ResultadoFuncional, Param1, varDouble )
        END;  { CASE ClaveParentesisDoble }
    ClaveParentesisInteger      :
        BEGIN
          EvaluarPredefinidoFuncionalSimple :=
                CAFE_VarCast( ResultadoFuncional, Param1, varInteger )
        END;  { CASE ClaveParentesisInteger }
    ClaveParentesisBoolean      :
        BEGIN
          EvaluarPredefinidoFuncionalSimple :=
                CAFE_VarCast( ResultadoFuncional, Param1, varBoolean )
        END;  { CASE ClaveParentesisBoolean }
    ClaveParentesisString       :
        BEGIN
          EvaluarPredefinidoFuncionalSimple :=
                CAFE_VarCast( ResultadoFuncional, Param1, varString )
        END;  { CASE ClaveParentesisString }
    ClaveParentesisByte         :
        BEGIN
          EvaluarPredefinidoFuncionalSimple :=
                CAFE_VarCast( ResultadoFuncional, Param1, varByte )
        END;  { CASE ClaveParentesisByte }
    ClaveIfDominioDouble,
    ClaveIfThenDouble           :
        BEGIN
          PivoteBoolean1        := Param1;
          IF PivoteBoolean1 THEN BEGIN
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param2, varDouble );
          END ELSE BEGIN  { IF PivoteBoolean1 }
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param3, varDouble );
          END;            { IF PivoteBoolean1 }
        END;  { CASE IfThenDouble }
    ClaveIfThenInteger          :
        BEGIN
          PivoteBoolean1        := Param1;
          IF PivoteBoolean1 THEN BEGIN
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param2, varInteger );
          END ELSE BEGIN  { IF PivoteBoolean1 }
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param3, varInteger );
          END;            { IF PivoteBoolean1 }
        END;  { CASE IfThenInteger }
    ClaveIfThenBoolean          :
        BEGIN
          PivoteBoolean1        := Param1;
          IF PivoteBoolean1 THEN BEGIN
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param2, varBoolean );
          END ELSE BEGIN  { IF PivoteBoolean1 }
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param3, varBoolean );
          END;            { IF PivoteBoolean1 }
        END;  { CASE IfThenBoolean }
    ClaveIfThenString           :
        BEGIN
          PivoteBoolean1        := Param1;
          IF PivoteBoolean1 THEN BEGIN
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param2, varString );
          END ELSE BEGIN  { IF PivoteBoolean1 }
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param3, varString );
          END;            { IF PivoteBoolean1 }
        END;  { CASE IfThenString }
    ClaveIfThenByte             :
        BEGIN
          PivoteBoolean1        := Param1;
          IF PivoteBoolean1 THEN BEGIN
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param2, varByte );
          END ELSE BEGIN  { IF PivoteBoolean1 }
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, Param3, varByte );
          END;            { IF PivoteBoolean1 }
        END;  { CASE IfThenByte }
    ClaveOperadorPositivo       :
        BEGIN
          PivoteReal1           := Param1;
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, PivoteReal1, varDouble )
        END;  { CASE ClaveOperadorPositivo }
    ClaveOperadorNegativo       :
        BEGIN
          PivoteReal1           := -Param1;
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, PivoteReal1, varDouble )
        END;  { CASE ClaveOperadorPositivo }
    ClaveOperadorSuma           :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal2           := Param2;
          ResultadoFuncional    := PivoteReal1+PivoteReal2;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveOperadorSuma }
    ClaveOperadorResta          :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal2           := Param2;
          ResultadoFuncional    := PivoteReal1-PivoteReal2;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveOperadorResta }
    ClaveOperadorMultiplicacion :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal2           := Param2;
          ResultadoFuncional    := PivoteReal1*PivoteReal2;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveOperadorMultiplicacion }
    ClaveOperadorDivision       :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal2           := Param2;
          IF PivoteReal2 = 0 THEN BEGIN
            ResultadoFuncional  := 0;
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END ELSE BEGIN  { IF PivoteReal2 = 0 ELSE }
            ResultadoFuncional  := PivoteReal1/PivoteReal2;
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          END;            { IF PivoteReal2 = 0 ELSE }
        END;  { CASE ClaveOperadorDivision }
    ClaveOperadorMOD            :
        BEGIN
          PivoteEntero1         := Param1;
          PivoteEntero2         := Param2;
          IF PivoteEntero2 = 0 THEN BEGIN
            ResultadoFuncional  := 0;
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END ELSE BEGIN  { IF PivoteEntero2 = 0 ELSE }
            ResultadoFuncional  := PivoteEntero1 MOD PivoteEntero2;
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          END;            { IF PivoteEntero2 = 0 ELSE }
        END;  { CASE ClaveOperadorMOD }
    ClaveOperadorDIV            :
        BEGIN
          PivoteEntero1         := Param1;
          PivoteEntero2         := Param2;
          IF PivoteEntero2 = 0 THEN BEGIN
            ResultadoFuncional  := 0;
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END ELSE BEGIN  { IF PivoteEntero2 = 0 ELSE }
            ResultadoFuncional  := PivoteEntero1 DIV PivoteEntero2;
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          END;            { IF PivoteEntero2 = 0 ELSE }
        END;  { CASE ClaveOperadorDIV }
    ClaveOperadorSHR            :
        TRY
          PivoteEntero1         := Param1;
          PivoteByte1           := Param2;
          ResultadoFuncional  := PivoteEntero1 SHR PivoteByte1;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        EXCEPT
          ON Exception
          DO EvaluarPredefinidoFuncionalSimple          := FALSE;
        END;  { TRY ClaveOperadorSHR }
    ClaveOperadorSHL            :
        TRY
          PivoteEntero1         := Param1;
          PivoteByte1           := Param2;
          ResultadoFuncional  := PivoteEntero1 SHL PivoteByte1;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        EXCEPT
          ON Exception
          DO EvaluarPredefinidoFuncionalSimple          := FALSE;
        END;  { TRY ClaveOperadorSHL }
    ClaveOperadorSumaString     :
        BEGIN
          IF CAFE_VarCast( PivoteVariant1, Param1, varString ) AND
             CAFE_VarCast( PivoteVariant2, Param2, varString ) THEN BEGIN
            PivoteString1       := PivoteVariant1;
            PivoteString2       := PivoteVariant2;
            ResultadoFuncional  := Concat( PivoteString1, PivoteString2 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          END ELSE BEGIN  { IF VarCast( ... ) AND ... ELSE }
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END;            { IF VarCast( ... ) AND ... ELSE }
        END;  { CASE ClaveOperadorSumaString }
    ClaveIgualAritmetico,
    ClaveIgualBoolean           :
        BEGIN
          ResultadoFuncional    := ( Param1 = Param2 );
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveIgualAritmetico, ... }
    ClaveDiferenteAritmetico    :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal2           := Param2;
          ResultadoFuncional    := ( PivoteReal1 <> PivoteReal2 );
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveDiferenteAritmetico, ... }
    ClaveDiferenteBoolean       :
        BEGIN
          PivoteBoolean1        := Param1;
          PivoteBoolean2        := Param2;
          ResultadoFuncional    := ( PivoteBoolean1 <> PivoteBoolean2 );
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveDiferenteAritmetico, ... }
    ClaveMayor                  :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal2           := Param2;
          ResultadoFuncional    := ( PivoteReal1 > PivoteReal2 );
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveMayor }
    ClaveMayorIgual             :
        BEGIN
          ResultadoFuncional    := ( Param1 >= Param2 );
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveMayorIgual }
    ClaveMenor                  :
        BEGIN
          ResultadoFuncional    := ( Param1 < Param2 );
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveMenor }
    ClaveMenorIgual             :
        BEGIN
          ResultadoFuncional    := ( Param1 <= Param2 );
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveMenorIgual }
    ClaveOperadorPositivoInt    :
        BEGIN
          PivoteEntero1         := Param1;
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, PivoteEntero1, varInteger )
        END;  { CASE ClaveOperadorPositivoInt }
    ClaveOperadorNegativoInt    :
        BEGIN
          PivoteEntero1         := -Param1;
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, PivoteEntero1, varInteger )
        END;  { CASE ClaveOperadorPositivoInt }
    ClaveOperadorSumaInt        :
        BEGIN
          PivoteEntero1         := Param1;
          PivoteEntero2         := Param2;
          ResultadoFuncional    := PivoteEntero1+PivoteEntero2;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveOperadorSumaInt }
    ClaveOperadorRestaInt       :
        BEGIN
          PivoteEntero1         := Param1;
          PivoteEntero2         := Param2;
          ResultadoFuncional    := PivoteEntero1-PivoteEntero2;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveOperadorRestaInt }
    ClaveOperadorMultiplicacionInt                      :
        BEGIN
          PivoteEntero1         := Param1;
          PivoteEntero2         := Param2;
          ResultadoFuncional    := PivoteEntero1*PivoteEntero2;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveOperadorMultiplicacionInt }
    ClaveSin                    :
        BEGIN
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, Sin( Param1 ), varDouble );
        END;  { CASE ClaveSin }
    ClaveCos                    :
        BEGIN
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, Cos( Param1 ), varDouble );
        END;  { CASE ClaveCos }
    ClaveExp                    :
        BEGIN
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, Exp( Param1 ), varDouble );
        END;  { CASE ClaveExp }
    ClaveLn                     :
        BEGIN
          PivoteReal1           := Param1;
          IF PivoteReal1 <= 0 THEN BEGIN
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END ELSE BEGIN  { IF PivoteReal1 <= 0 ELSE }
            EvaluarPredefinidoFuncionalSimple           :=
                  CAFE_VarCast( ResultadoFuncional, Ln( Param1 ), varDouble );
          END;            { IF PivoteReal1 <= 0 ELSE }
        END;  { CASE ClaveLn }
    ClaveArcTan                 :
        BEGIN
          EvaluarPredefinidoFuncionalSimple             :=
              CAFE_VarCast( ResultadoFuncional, ArcTan( Param1 ), varDouble );
        END;  { CASE ClaveArcTan }
    ClaveArcTan2                :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal2           := Param2;
          IF PivoteReal2 = 0 THEN BEGIN
            IF PivoteReal1 <> 0 THEN BEGIN
              IF PivoteReal1 > 0
              THEN EvaluarPredefinidoFuncionalSimple    :=
                        CAFE_VarCast( ResultadoFuncional, Pi/2, varDouble )
              ELSE EvaluarPredefinidoFuncionalSimple    :=
                        CAFE_VarCast( ResultadoFuncional, -Pi/2, varDouble );
            END ELSE BEGIN  { IF PivoteReal1 <> 0 ELSE }
              ResultadoFuncional := CAFE_DefaultNuloVariant( varDouble );
              EvaluarPredefinidoFuncionalSimple         := FALSE;
            END;            { IF PivoteReal1 <> 0 ELSE }
          END ELSE BEGIN  { IF PivoteReal1 = 0 ELSE }
            PivoteReal2         := ArcTan2( PivoteReal1, PivoteReal2 );
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional,
                        PivoteReal2, varDouble );
          END;            { IF PivoteReal1 = 0 ELSE }
        END;  { CASE ClaveArcTan2 }
    ClaveFrac                   :
        BEGIN
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, Frac( Param1 ), varDouble );
        END;  { CASE ClaveFrac }
    ClaveRound                  :
        BEGIN
          EvaluarPredefinidoFuncionalSimple             :=
              CAFE_VarCast( ResultadoFuncional, Round( Param1 ), varDouble );
        END;  { CASE ClaveRound }
    ClaveOperadorPotenciaDos,
    ClaveSqr                    :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal1           := Sqr( PivoteReal1 );
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, PivoteReal1, varDouble );
        END;  { CASE ClaveSqr }
    ClaveSqrt                   :
        BEGIN
          PivoteReal1           := Param1;
          IF PivoteReal1 <= 0 THEN BEGIN
            IF IsZero( PivoteReal1,
                ImplementationManejador.ValorEpsilonZero ) THEN BEGIN
              ResultadoFuncional        :=
                                CAFE_DefaultNuloVariant( varDouble );
              EvaluarPredefinidoFuncionalSimple         := TRUE;
              Exit;
            END;  { IF IsZero( PivoteReall1 ) }
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END ELSE BEGIN  { IF PivoteReal1 < 0 ELSE }
            PivoteReal1         := Sqrt( PivoteReal1 );
            EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional,
                                PivoteReal1, varDouble );
          END;            { IF PivoteReal1 < 0 ELSE }
        END;  { CASE ClaveSqrt }
    ClaveRandom                 :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  := Random( PivoteEntero1 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { CASE TRY }
        END;  { ClaveRandom }
    ClaveTrunc                  :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal1           := Trunc( PivoteReal1 );
          EvaluarPredefinidoFuncionalSimple             :=
             CAFE_VarCast( ResultadoFuncional, PivoteReal1, varDouble );
        END;  { CASE ClaveTrunc }
    ClaveAbs                    :
        BEGIN
          PivoteReal1           := Param1;
          PivoteReal1           := Abs( PivoteReal1 );
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, PivoteReal1, varDouble );
        END;  { CASE ClaveAbs }
    ClaveNOT                    :
        BEGIN
          EvaluarPredefinidoFuncionalSimple             :=
                CAFE_VarCast( ResultadoFuncional, NOT( Param1 ), varBoolean );
        END;  { CASE ClaveNOT }
    ClaveAND                    :
        BEGIN
          ResultadoFuncional    := Param1 AND Param2;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveAND }
    ClaveOR                     :
        BEGIN
          ResultadoFuncional    := Param1 OR Param2;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveOR }
    ClaveXOR                    :
        BEGIN
          ResultadoFuncional    := Param1 XOR Param2;
          EvaluarPredefinidoFuncionalSimple             := TRUE;
        END;  { CASE ClaveXOR }
    ClaveCopy                   :
        BEGIN
          IF CAFE_VarCast( PivoteVariant1, Param1, varString ) THEN BEGIN
            ResultadoFuncional  := Copy( PivoteVariant1, Param2, Param3 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          END ELSE BEGIN  { IF CAFE_VarCast... ELSE }
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END;            { IF CAFE_VarCast... ELSE }
        END;  { CASE ClaveCopy }
    ClaveUpCase                 :
        BEGIN
          IF CAFE_VarCast( PivoteVariant1, Param1, varString ) THEN BEGIN
            PivoteString1       := PivoteVariant1;
            ResultadoFuncional  := UpCase( PivoteString1 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          END ELSE BEGIN  { IF CAFE_VarCast... ELSE }
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END;            { IF CAFE_VarCast... ELSE }
        END;  { CASE ClaveUpCase }
    ClaveLowerCase              :
        BEGIN
          IF CAFE_VarCast( PivoteVariant1, Param1, varString ) THEN BEGIN
            PivoteString1       := PivoteVariant1;
            ResultadoFuncional  := LowerCase( PivoteString1 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          END ELSE BEGIN  { IF CAFE_VarCast... ELSE }
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END;            { IF CAFE_VarCast... ELSE }
        END;  { CASE ClaveLowerCase }
    ClaveEjesFormatDate         :
        BEGIN
          PivoteEntero1         := Param3;
          IF ( CAFE_VarCast( PivoteVariant2, Param2, varString ) )
             AND InRange( PivoteEntero1, 0, CAFE_TamanoCadenaSintactica )
          THEN BEGIN
            PivoteTDateTime1    := Param1;
            PivoteString1       := PivoteVariant2;
            ResultadoFuncional  :=
                CAFE_FormatDate( PivoteTDateTime1, PivoteString1,
                                PivoteEntero1 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          END ELSE BEGIN  { IF CAFE_VarCast... ELSE }
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END;            { IF CAFE_VarCast... ELSE }
        END;  { CASE ClaveEjesFormatDate }
    ClaveTDateTime              :
        BEGIN
          TRY
            PivoteTDateTime2    := Param1;
            ResultadoFuncional  := PivoteTDateTime2;
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveTDateTime }
    ClaveCastDouble             :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            ResultadoFuncional  := PivoteReal1;
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveCastDouble }
    ClaveDaysBetween            :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                DaysBetween( Param1, Param2 ), varInteger );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveDaysBetween }
    ClaveDaySpan                :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                DaySpan( Param1, Param2 ), varDouble );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveDaySpan }
    ClaveWeekSpan               :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                WeekSpan( Param1, Param2 ), varDouble );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveWeekSpan }
    ClaveMonthSpan              :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                MonthSpan( Param1, Param2 ), varDouble );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMonthSpan }
    ClaveYearSpan               :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                YearSpan( Param1, Param2 ), varDouble );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveYearSpan }
    ClaveDayOf                  :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                DayOf( Param1 ), varInteger );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveDayOf }
    ClaveWeekOf                 :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                WeekOf( Param1 ), varInteger );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveWeekOf }
    ClaveMonthOf                :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                MonthOf( Param1 ), varInteger );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMonthOf }
    ClaveYearOf                 :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                YearOf( Param1 ), varInteger );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveYearOf }
    ClaveIsLeapYear             :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple   :=
                CAFE_VarCast( ResultadoFuncional,
                IsLeapYear( Param1 ), varBoolean );
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIsLeapYear }
    ClaveEjesHoy                :
        BEGIN
          PivoteTDateTime1      := Date;
          ResultadoFuncional    := PivoteTDateTime1;
          EvaluarPredefinidoFuncionalSimple     := TRUE;
        END;  { ClaveEjesHoy }
    ClaveEncodeDate             :
        BEGIN
          TRY
            PivoteTDateTime1    := EncodeDate( Param1, Param2, Param3 );
            ResultadoFuncional  := PivoteTDateTime1;
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEncodeDate }
    ClaveIncDay                 :
        BEGIN
          TRY
            PivoteTDateTime1    := Param1;
            ResultadoFuncional  := IncDay( PivoteTDateTime1 );
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIncDay }
    ClaveEjesDayOfWeek          :
        BEGIN
          TRY
            PivoteTDateTime1    := Param1;
            ResultadoFuncional  := DayOfWeek( PivoteTDateTime1 );
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesDayOfWeek }
    ClaveEjesNombreMes          :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            IF InRange( PivoteEntero1, 1, 12 ) THEN BEGIN
              ResultadoFuncional  := ( PivoteEntero1 );
              EvaluarPredefinidoFuncionalSimple   := CAFE_VarCast
                ( ResultadoFuncional,
                  LongMonthNames[ PivoteEntero1 ], varString );
            END ELSE EvaluarPredefinidoFuncionalSimple   := FALSE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesNombreMes }
    ClaveEjesNombreDia          :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            IF InRange( PivoteEntero1, 1, 7 ) THEN BEGIN
              ResultadoFuncional  := ( PivoteEntero1 );
              EvaluarPredefinidoFuncionalSimple   := CAFE_VarCast
                ( ResultadoFuncional,
                  LongDayNames[ PivoteEntero1 ], varString );
            END ELSE EvaluarPredefinidoFuncionalSimple   := FALSE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesNombreDia }
    ClaveEjesNombreMesCorto     :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            IF InRange( PivoteEntero1, 1, 12 ) THEN BEGIN
              ResultadoFuncional  := ( PivoteEntero1 );
              EvaluarPredefinidoFuncionalSimple   := CAFE_VarCast
                ( ResultadoFuncional,
                  ShortMonthNames[ PivoteEntero1 ], varString );
            END ELSE EvaluarPredefinidoFuncionalSimple   := FALSE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesNombreMesCorto }
    ClaveEjesNombreDiaCorto     :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            IF InRange( PivoteEntero1, 1, 7 ) THEN BEGIN
              ResultadoFuncional  := ( PivoteEntero1 );
              EvaluarPredefinidoFuncionalSimple   := CAFE_VarCast
                ( ResultadoFuncional,
                  ShortDayNames[ PivoteEntero1 ], varString );
            END ELSE EvaluarPredefinidoFuncionalSimple   := FALSE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesNombreDiaCorto }
    ClaveIncDayOvl              :
        BEGIN
          TRY
            PivoteTDateTime1    := Param1;
            ResultadoFuncional  := IncDay( PivoteTDateTime1, Param2 );
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIncDayOvl }
    ClaveIncWeek                :
        BEGIN
          TRY
            PivoteTDateTime1    := Param1;
            ResultadoFuncional  := IncWeek( PivoteTDateTime1 );
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIncWeek }
    ClaveIncWeekOvl             :
        BEGIN
          TRY
            PivoteTDateTime1    := Param1;
            ResultadoFuncional  := IncWeek( PivoteTDateTime1, Param2 );
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIncWeekOvl }
    ClaveIncMonth               :
        BEGIN
          TRY
            PivoteTDateTime1    := Param1;
            ResultadoFuncional  := IncMonth( PivoteTDateTime1 );
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIncMonth }
    ClaveIncMonthOvl            :
        BEGIN
          TRY
            PivoteTDateTime1    := Param1;
            ResultadoFuncional  := IncMonth( PivoteTDateTime1, Param2 );
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIncMonthOvl }
    ClaveIncYear                :
        BEGIN
          TRY
            PivoteTDateTime1    := Param1;
            ResultadoFuncional  := IncYear( PivoteTDateTime1 );
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIncYear }
    ClaveIncYearOvl             :
        BEGIN
          TRY
            PivoteTDateTime1    := Param1;
            ResultadoFuncional  := IncYear( PivoteTDateTime1, Param2 );
            EvaluarPredefinidoFuncionalSimple   := TRUE;
          EXCEPT
            EvaluarPredefinidoFuncionalSimple   := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIncYearOvl }
    ClaveInsertar               :
        BEGIN
          IF CAFE_VarCast( PivoteVariant1, Param1, varString ) THEN BEGIN
            IF CAFE_VarCast( PivoteVariant2, Param2, varString ) THEN BEGIN
              PivoteString1     := PivoteVariant1;
              PivoteString2     := PivoteVariant2;
              PivoteEntero1     := Param3;
              Insert( PivoteString1, PivoteString2, PivoteEntero1 );
              ResultadoFuncional        := PivoteString2;
              EvaluarPredefinidoFuncionalSimple         := TRUE;
            END ELSE BEGIN  { IF CAFE_VarCast... ELSE }
              EvaluarPredefinidoFuncionalSimple         := FALSE;
            END;            { IF CAFE_VarCast... ELSE }
          END ELSE BEGIN  { IF CAFE_VarCast... ELSE }
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END;            { IF CAFE_VarCast... ELSE }
        END;  { CASE ClaveInsertarString }
    ClaveToValDouble            :
        BEGIN
          TRY
            IF CAFE_VarCast( PivoteVariant1, Param1, varString ) THEN BEGIN
              PivoteString1     := PivoteVariant1;
              Val( PivoteString1, PivoteReal1 );
              ResultadoFuncional                        := PivoteReal1;
              EvaluarPredefinidoFuncionalSimple         := TRUE;
            END ELSE BEGIN  { IF CAFE_VarCast... ELSE }
              EvaluarPredefinidoFuncionalSimple         := FALSE;
            END;            { IF CAFE_VarCast... ELSE }
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveToValDouble }
    ClaveToStrInteger1          :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            Str( PivoteEntero1, PivoteString1 );
            ResultadoFuncional  := PivoteString1;
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveToStrInteger1 }
    ClaveToStrInteger2          :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            PivoteEntero2       := Param2;
            Str( PivoteEntero1:PivoteEntero2, PivoteString1 );
            ResultadoFuncional  := PivoteString1;
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveToStrInteger2 }
    ClaveToStrDouble1           :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            Str( PivoteReal1, PivoteString1 );
            ResultadoFuncional  := PivoteString1;
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveToStrDouble1 }
    ClaveToStrDouble2           :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteEntero2       := Param2;
            Str( PivoteReal1:PivoteEntero2, PivoteString1 );
            ResultadoFuncional  := PivoteString1;
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveToStrDouble2 }
    ClaveToStrDouble3           :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteEntero2       := Param2;
            PivoteEntero3       := Param3;
            Str( PivoteReal1:PivoteEntero2:PivoteEntero3, PivoteString1 );
            ResultadoFuncional  := PivoteString1;
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveToStrDouble3 }
    ClaveLengthString           :
        BEGIN
          IF CAFE_VarCast( PivoteVariant1, Param1, varString ) THEN BEGIN
            ResultadoFuncional  := Length( PivoteVariant1 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          END ELSE BEGIN  { IF CAFE_VarCast... ELSE }
            EvaluarPredefinidoFuncionalSimple           := FALSE;
          END;            { IF CAFE_VarCast... ELSE }
        END;  { CASE ClaveLengthString }
    ClaveArcCos                 :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
              CAFE_VarCast( ResultadoFuncional, ArcCos( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveArcCos }
    ClaveArcCosH,
    ClaveArCosH                 :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                ArcCosH( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveArcCosH, ... }
    ClaveArcSin                 :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                ArcSin( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveArcSin }
    ClaveArcSinH,
    ClaveArSinH                 :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                ArcSinH( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveArcSinH }
    ClaveArcTanH,
    ClaveArTanH                 :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                ArcTanH( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveArTanH }
    ClaveCeil                   :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Ceil( Param1 ), varInteger );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveCeil }
    ClaveCompareValue           :
        BEGIN
          TRY
            PivoteReal1                 := Param1;
            PivoteReal2                 := Param2;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                   CompareValue( PivoteReal1, PivoteReal2 ), varInteger );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveCompareValue }
    ClaveCosH                   :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                CosH( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveCosH }
    ClaveCot,
    ClaveCotan                  :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Cotan( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveCot, ... }
    ClaveCosecant,
    ClaveCsc                    :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Csc( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveCsc }
    ClaveCycleToRad             :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                CycleToRad( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveCycleToRad }
    ClaveDegToGrad              :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                DegToGrad( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveDegToGrad }
    ClaveDegToRad               :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                DegToRad( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveDegToRad }
    ClaveEnsureRangeDouble      :
        BEGIN
          PivoteReal1           := Param1;
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
               EnsureRange( PivoteReal1, Param2, Param3 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEnsureRangeDouble }
    ClaveFloor                  :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Floor( PivoteReal1 ), varInteger );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveFloor }
    ClaveGradToDeg              :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                GradToDeg( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveGradToDeg }
    ClaveGradToRad              :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                GradToRad( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveGradToRad }
    ClaveHypot                  :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Hypot( Param1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveHypot }
    ClaveInRange                :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                InRange( PivoteReal1, Param2, Param2 ),
                                varBoolean );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveInRange }
    ClaveEjesCubo,
    ClaveOperadorPotenciaTres   :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                IntPower( Param1, 3 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesPotenciaTres }
    ClaveIntPower               :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                IntPower( Param1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIntPower }
    ClaveEjesUnoDouble          :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                IfThen( PivoteReal1 > 0.0, 1, 0 ),
                                varInteger );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesUnoDouble }
    ClaveEjesUnoBoolean         :
        BEGIN
          TRY
            PivoteBoolean1      := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                          IfThen( PivoteBoolean1, 1, 0 ), varInteger );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesUnoBoolean }
    ClaveEjesCastBoolean        :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                ( PivoteReal1 <> 0 ), varBoolean );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesCastBoolean }
    ClaveIsZero                 :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            IF Param2 <> 0
            THEN EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                IsZero( PivoteReal1 ), varBoolean )
            ELSE EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                IsZero( PivoteReal1, Param2 ), varBoolean );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveIsZero }
    ClaveLdExp                  :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                LdExp( Param1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveLdExp }
    ClaveLnXp1                  :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                LnXp1( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveLnXp1 }
    ClaveLog10                  :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Log10( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveLog10 }
    ClaveLog2                   :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Log2( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveLog2 }
    ClaveLogN                   :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                LogN( Param1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveLogN }
    ClaveMaxDouble              :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Max( PivoteReal1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMaxDouble }
    ClaveMinDouble              :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Min( PivoteReal1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMinDouble }
    ClavePower,
    ClaveOperadorPower          :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Power( Param1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMaxDouble }
    ClaveRadToCycle             :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                RadToCycle( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveRadToCycle }
    ClaveRadToDeg               :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                RadToDeg( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveRadToDeg }
    ClaveRadToGrad              :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                RadToGrad( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveRadToGrad }
    ClaveRandG                  :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                RandG( Param1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveRandG }
    ClaveRandomRange            :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            PivoteEntero2       := Param2;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                        RandomRange( PivoteEntero1, PivoteEntero2 ),
                        varInteger );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveRandomRange }
    ClaveRoundTo                :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                RoundTo( PivoteReal1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveRoundTo }
    ClaveSameValue              :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                        SameValue( PivoteReal1, PivoteReal2, PivoteReal3 ),
                        varBoolean );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveSameValue }
    ClaveSec,
    ClaveSecant                 :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Sec( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveSec, ... }
    ClaveSign                   :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Sign( PivoteReal1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveSign }
    ClaveSimpleRoundTo          :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                        SimpleRoundTo( PivoteReal1, Param2 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveSimpleRoundTo }
    ClaveSinH                   :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                SinH( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveSinH }
    ClaveTan                    :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Tan( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveTan }
    ClaveTanH                   :
        BEGIN
          TRY
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                TanH( Param1 ), varDouble );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveTanH }
    ClaveEnsureRangeInteger     :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                EnsureRange( PivoteEntero1, Param2, Param2 ),
                                varInteger );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEnsureRangeInteger }
    ClaveMaxInteger             :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Max( PivoteEntero1, Param2 ),
                                varInteger );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMaxInteger }
    ClaveMinInteger             :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                Min( PivoteEntero1, Param2 ),
                                varInteger );
          EXCEPT
            ON EInvalidArgument
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMinInteger }
    ClaveEjesFactorial,
    ClaveOperadorFactorial      :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteEntero1       := Round( PivoteReal1 );
            IF ( PivoteEntero1 < 0 ) OR
               ( PivoteEntero1 > MaximoImplementationFactorial )
            THEN BEGIN
              ResultadoFuncional                        := 1.0;
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF ( PivoteEntero1 < 0 ) OR ... }
            EvaluarPredefinidoFuncionalSimple           :=
                        CAFE_VarCast( ResultadoFuncional,
                                ImplementationFactorial[ PivoteEntero1 ],
                                varInteger );
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMinInteger }
    ClaveMean                   :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                Mean( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMean }
    ClaveLengthArray            :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                Length( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveLengthArray }
    ClaveSum                    :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                Sum( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveSum }
    ClaveStdDev                 :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                StdDev( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveStdDev }
    ClaveVariance               :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                Variance( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveVariante }
    ClaveTotalVariance          :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                TotalVariance( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveTotalVariance }
    ClaveNorm                   :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                Norm( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveNorm }
    ClaveSumOfSquares           :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                SumOfSquares( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveSumOfSquares }
    ClaveMinValue               :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                MinValue( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMinValue }
    ClaveMaxValue               :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                MaxValue( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMaxValue }
    ClavePopNStdDev             :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                PopNStdDev( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClavePopNStdDev }
    ClavePopNVariance           :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                PopNVariance( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClavePopNVariance }
    ClaveRandomFrom             :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            ResultadoFuncional  :=
                RandomFrom( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveRandomFrom }
    ClaveEjesLaplace            :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            IF IsZero( PivoteReal2 )
            THEN PivoteReal2    := CAFE_DefaultToleranciaFuncionalLento;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0,
                        PivoteReal1,
            @ImplementationAuxiliarLaplace, NIL, PivoteReal2 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Msg                       := 'funcional Laplace';
              RAISE CAFE_MensajeInfructuoso.
                Create( 'funcional Laplace', CAFE_4ErrorIntegralNoRealizada );
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            ResultadoFuncional  :=
                CAFE_RedondeoTolerancia( PivoteResultado, 2.5*PivoteReal2 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesLaplace }
    ClaveEjesDistribucionNormal :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            ResultadoFuncional  :=
                        ImplementationAuxiliarLaplace( PivoteReal1, NIL );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesNormal }
    ClaveEjesNormal             :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            IF IsZero( PivoteReal2 )
            THEN PivoteReal2    := CAFE_DefaultToleranciaFuncionalLento;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0,
                        PivoteReal1,
            @ImplementationAuxiliarLaplace, NIL, PivoteReal2 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            ResultadoFuncional  :=
                CAFE_RedondeoTolerancia( PivoteResultado+0.5,
                                                2.5*PivoteReal2 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesNormal }
    ClaveEjesGamma              :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            IF PivoteReal1 <= 0 THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF PivoteReal1 < 0 }
            IF IsZero( PivoteReal2 )
            THEN PivoteReal2    := CAFE_DefaultToleranciaFuncionalLento;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
              @ImplementationAuxiliarGamma, @PivoteReal1, PivoteReal2 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            ResultadoFuncional  :=
              CAFE_RedondeoTolerancia( PivoteResultado, 2.5*PivoteReal2 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesGamma }
    ClaveEjesBeta               :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( PivoteReal1 <= 0 ) OR ( PivoteReal2 <= 0 ) THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF PivoteReal1 < 0 }
            IF IsZero( PivoteReal3 )
            THEN PivoteReal3    := CAFE_DefaultToleranciaFuncionalLento/100;
            MyPaqueteBeta.XBeta := PivoteReal1;
            MyPaqueteBeta.YBeta := PivoteReal2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
              @ImplementationAuxiliarBeta, @MyPaqueteBeta, PivoteReal3 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            ResultadoFuncional  :=
              CAFE_RedondeoTolerancia( PivoteResultado, 2.5*PivoteReal3 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesBeta }
    ClaveEjesTStudent           :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( PivoteReal2 <= 0 ) THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF PivoteReal1 < 0 }
            IF IsZero( PivoteReal3 )
            THEN PivoteReal3    := CAFE_DefaultToleranciaFuncionalLento;
            MyPaqueteBeta.XBeta := 0.5;
            MyPaqueteBeta.YBeta := PivoteReal2/2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
              @ImplementationAuxiliarBeta, @MyPaqueteBeta, PivoteReal3/10 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado2, 0,
                        PivoteReal1,
            @ImplementationAuxiliarTStudent, @PivoteReal2, PivoteReal3 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            PivoteResultado3            :=
                PivoteResultado2/( Sqrt( PivoteReal2 )*PivoteResultado )+0.5;
            ResultadoFuncional  :=
                CAFE_RedondeoTolerancia( PivoteResultado3, 2.5*PivoteReal3 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesTStudent }
    ClaveEjesChiSquare          :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( PivoteReal2 <= 0 ) OR ( PivoteReal1 < 0 ) THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF PivoteReal1 < 0 }
            IF IsZero( PivoteReal3 )
            THEN PivoteReal3    := CAFE_DefaultToleranciaFuncionalLento;
            PivoteResultado1    := PivoteReal2/2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
         @ImplementationAuxiliarGamma, @PivoteResultado1, PivoteReal3/10 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado2, 0,
                        PivoteReal1,
         @ImplementationAuxiliarChiSquare, @PivoteReal2, PivoteReal3 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            PivoteResultado3            :=
         PivoteResultado2/( Power( 2, PivoteResultado1 )*PivoteResultado );
            ResultadoFuncional  :=
                CAFE_RedondeoTolerancia( PivoteResultado3, 2.5*PivoteReal3 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesChiSquare }
    ClaveEjesIntegralF                  :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( PivoteReal2 <= 0 ) OR ( PivoteReal1 < 0 ) OR
               ( PivoteReal3 <= 0 )
            THEN RAISE Exception.Create('');
            WITH MyPaqueteF DO BEGIN
              D1LibreDistribucionF              := PivoteReal2;
              D2LibreDistribucionF              := PivoteReal3;
            END;  { WITH MyPaqueteF }
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado2, 0,
                        PivoteReal1,
                        @ImplementationAuxiliarDistribucionF, @MyPaqueteF,
                        CAFE_DefaultToleranciaFuncionalF ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            MyPaqueteBeta.XBeta := PivoteReal2/2;
            MyPaqueteBeta.YBeta := PivoteReal3/2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
              @ImplementationAuxiliarBeta, @MyPaqueteBeta,
              CAFE_DefaultToleranciaFuncionalF/10 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            PivoteResultado3            :=
                PivoteResultado2*
                ( Power( PivoteReal2/PivoteReal3, PivoteReal2/2 )
                /PivoteResultado );
            ResultadoFuncional  :=
                CAFE_RedondeoTolerancia( PivoteResultado3,
                        2.5*CAFE_DefaultToleranciaFuncionalF );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesIntegralF }
    ClaveEjesLaplaceInversa     :
        BEGIN
          TRY
            PivoteDefault       := CAFE_DefaultToleranciaFuncionalLento;
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := ABS( PivoteReal1 );
            IF NOT( InRange( PivoteReal3, 0, 0.5 ) ) THEN BEGIN
              EvaluarPredefinidoFuncionalSimple := FALSE;
              Exit;
            END;  { IF NOT( InRange... ) }
            IF IsZero( PivoteReal2 )
            THEN PivoteReal2    := CAFE_DefaultToleranciaFuncionalLento/2
            ELSE CAFE_DefaultToleranciaFuncionalLento   := PivoteReal2;
            IF NOT( CAFE_SolvePuntoMedioZonaNula( PivoteResultado, 0,
                        Pi/2,
                @ImplementationAuxiliarIntegralLaplaceInversa,
                @PivoteReal3, PivoteReal2 ) )
            THEN BEGIN
              CAFE_DefaultToleranciaFuncionalLento      := PivoteDefault;
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            CAFE_DefaultToleranciaFuncionalLento        := PivoteDefault;
            IF PivoteReal1 >= 0.0
            THEN ResultadoFuncional     :=
        CAFE_RedondeoTolerancia( Tan( PivoteResultado ), 2.5*PivoteReal2 )
            ELSE ResultadoFuncional     :=
        CAFE_RedondeoTolerancia( -Tan( PivoteResultado ), 2.5*PivoteReal2 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              CAFE_DefaultToleranciaFuncionalLento      := PivoteDefault;
            END;  { ON Exception }
          END;  { TRY }
        END;  { CASE ClaveEjesLaplaceInversa }
    ClaveEjesTStudentInversa    :
        BEGIN
          TRY
            PivoteDefault       := CAFE_DefaultToleranciaFuncionalLento;
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( ( PivoteReal1 <= 0 ) OR ( PivoteReal2 <= 0 ) OR
               ( PivoteReal1 >= 1 ) ) THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF PivoteReal1 < 0 }
            IF IsZero( PivoteReal3 )
            THEN PivoteReal3    := CAFE_DefaultToleranciaFuncionalLento/2
            ELSE CAFE_DefaultToleranciaFuncionalLento   := PivoteReal3;
            MyPaqueteBeta.XBeta := 0.5;
            MyPaqueteBeta.YBeta := PivoteReal2/2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
              @ImplementationAuxiliarBeta, @MyPaqueteBeta, PivoteReal3/10 ) )
            THEN BEGIN
              CAFE_DefaultToleranciaFuncionalLento      := PivoteDefault;
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            MyPaqueteTStudent.VLibreTStudent    := PivoteReal2;
            MyPaqueteTStudent.IgualTStudent     :=
                        ABS( PivoteReal1-0.5 )*
                        ( Sqrt( PivoteReal2 )*PivoteResultado );
            IF NOT( CAFE_SolvePuntoMedioZonaNula( PivoteResultado2, 0,
                        Pi/2,
                @ImplementationAuxiliarIntegralTStudentInversa,
                @MyPaqueteTStudent, PivoteReal3 ) )
            THEN BEGIN
              CAFE_DefaultToleranciaFuncionalLento      := PivoteDefault;
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            IF ( PivoteReal1-0.5 ) < 0
            THEN ResultadoFuncional  :=
    CAFE_RedondeoTolerancia( -Tan( PivoteResultado2 ), 2.5*PivoteReal3 )
            ELSE ResultadoFuncional  :=
    CAFE_RedondeoTolerancia(  Tan( PivoteResultado2 ), 2.5*PivoteReal3 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
            CAFE_DefaultToleranciaFuncionalLento        := PivoteDefault;
          EXCEPT
            ON Exception
            DO BEGIN
              EvaluarPredefinidoFuncionalSimple          := FALSE;
              CAFE_DefaultToleranciaFuncionalLento       := PivoteDefault;
            END;  { ON Exception }
          END;  { TRY }
        END;  { CASE ClaveEjesTStudentInversa }
    ClaveEjesChiSquareInversa   :
        BEGIN
          TRY
            PivoteDefault       := CAFE_DefaultToleranciaFuncionalLento;
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( ( PivoteReal1 < 0 ) OR ( PivoteReal2 <= 0 ) OR
               ( PivoteReal1 >= 1 ) ) THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF PivoteReal1 < 0 }
            IF IsZero( PivoteReal3 )
            THEN PivoteReal3    := CAFE_DefaultToleranciaFuncionalLento/2
            ELSE CAFE_DefaultToleranciaFuncionalLento   := PivoteReal3;
            PivoteResultado1    := PivoteReal2/2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
        @ImplementationAuxiliarGamma, @PivoteResultado1, PivoteReal3/10 ) )
            THEN BEGIN
              CAFE_DefaultToleranciaFuncionalLento      := PivoteDefault;
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            MyPaqueteChiSquare.VLibreChiSquare   := PivoteReal2;
            MyPaqueteChiSquare.IgualChiSquare    :=
        PivoteReal1*( Power( 2, PivoteReal2/2 )*PivoteResultado );
            IF NOT( CAFE_SolvePuntoMedioZonaNula( PivoteResultado2, 0,
                        Pi/2,
                @ImplementationAuxiliarIntegralChiSquareInversa,
                @MyPaqueteChiSquare, PivoteReal3 ) )
            THEN BEGIN
              CAFE_DefaultToleranciaFuncionalLento      := PivoteDefault;
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            ResultadoFuncional  :=
    CAFE_RedondeoTolerancia(  Tan( PivoteResultado2 ), 2.5*PivoteReal3 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
            CAFE_DefaultToleranciaFuncionalLento        := PivoteDefault;
          EXCEPT
            ON Exception
            DO BEGIN
              EvaluarPredefinidoFuncionalSimple          := FALSE;
              CAFE_DefaultToleranciaFuncionalLento       := PivoteDefault;
            END;  { ON Exception }
          END;  { TRY }
        END;  { CASE ClaveEjesTStudentInversa }
    ClaveEjesIntegralFInversa           :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( PivoteReal2 <= 0 ) OR ( PivoteReal1 < 0 ) OR
               ( PivoteReal3 <= 0 )
            THEN RAISE Exception.Create('');
            MyPaqueteBeta.XBeta := PivoteReal2/2;
            MyPaqueteBeta.YBeta := PivoteReal3/2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
              @ImplementationAuxiliarBeta, @MyPaqueteBeta,
              CAFE_DefaultToleranciaFuncionalF/10 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            WITH MyPaqueteF DO BEGIN
              D1LibreDistribucionF              := PivoteReal2;
              D2LibreDistribucionF              := PivoteReal3;
              IgualDistribucionF                :=
                PivoteReal1*PivoteResultado/
                ( Power( PivoteReal2/PivoteReal3, PivoteReal2/2 ) );
            END;  { WITH MyPaqueteF }
            IF NOT( CAFE_SolvePuntoMedioZonaNula( PivoteResultado2, 0,
                        Pi/2,
                @ImplementationAuxiliarIntegralFInversa,
                @MyPaqueteF, CAFE_DefaultToleranciaFuncionalF/10 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            ResultadoFuncional  :=
                CAFE_RedondeoTolerancia(  Tan( PivoteResultado2 ),
                        25*CAFE_DefaultToleranciaFuncionalF );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesIntegralFInversa }
    ClaveEjesNormalInversa      :
        BEGIN
          TRY
            PivoteDefault       := CAFE_DefaultToleranciaFuncionalLento;
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal1
            -=                  0.5;
            PivoteReal3         := ABS( PivoteReal1 );
            IF NOT( InRange( PivoteReal3, 0, 0.5 ) ) THEN BEGIN
              EvaluarPredefinidoFuncionalSimple := FALSE;
              Exit;
            END;  { IF NOT( InRange... ) }
            IF  IsZero( PivoteReal2 )
            THEN PivoteReal2    := CAFE_DefaultToleranciaFuncionalLento/2
            ELSE CAFE_DefaultToleranciaFuncionalLento   := PivoteReal2;
            IF NOT( CAFE_SolvePuntoMedioZonaNula( PivoteResultado, 0,
                        Pi/2,
                @ImplementationAuxiliarIntegralLaplaceInversa,
                @PivoteReal3, PivoteReal2 ) )
            THEN BEGIN
              CAFE_DefaultToleranciaFuncionalLento      := PivoteDefault;
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            CAFE_DefaultToleranciaFuncionalLento        := PivoteDefault;
            IF PivoteReal1 >= 0.0
            THEN ResultadoFuncional     :=
        CAFE_RedondeoTolerancia( Tan( PivoteResultado ), 2.5*PivoteReal2 )
            ELSE ResultadoFuncional     :=
        CAFE_RedondeoTolerancia( -Tan( PivoteResultado ), 2.5*PivoteReal2 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              CAFE_DefaultToleranciaFuncionalLento      := PivoteDefault;
            END;  { ON Exception }
          END;  { TRY }
        END;  { CASE ClaveEjesNormalInversa }
    ClaveEjesDistribucionTStudent       :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( PivoteReal2 <= 0 ) THEN RAISE Exception.Create('');
            PivoteResultado2    :=
    ImplementationAuxiliarTStudent( PivoteReal1, @PivoteReal2 );
            IF IsZero( PivoteReal3 )
            THEN PivoteReal3    := CAFE_DefaultToleranciaFuncionalLento;
            MyPaqueteBeta.XBeta := 0.5;
            MyPaqueteBeta.YBeta := PivoteReal2/2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
              @ImplementationAuxiliarBeta, @MyPaqueteBeta, PivoteReal3/10 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            PivoteResultado3            :=
                PivoteResultado2/( Sqrt( PivoteReal2 )*PivoteResultado );
            ResultadoFuncional  :=
                CAFE_RedondeoTolerancia( PivoteResultado3, 2.5*PivoteReal3 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
              EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesDistribucionTStudent }
    ClaveEjesDistribucionChiSquare      :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( PivoteReal2 <= 0 ) OR ( PivoteReal1 < 0 )
            THEN RAISE Exception.Create('');
            PivoteResultado2    :=
    ImplementationAuxiliarChiSquare( PivoteReal1, @PivoteReal2 );
            IF IsZero( PivoteReal3 )
            THEN PivoteReal3    := CAFE_DefaultToleranciaFuncionalLento;
            PivoteResultado1    := PivoteReal2/2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
         @ImplementationAuxiliarGamma, @PivoteResultado1, PivoteReal3/10 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            PivoteResultado3            :=
         PivoteResultado2/( Power( 2, PivoteResultado1 )*PivoteResultado );
            ResultadoFuncional  :=
                CAFE_RedondeoTolerancia( PivoteResultado3, 2.5*PivoteReal3 );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesDistribucionTStudent }
    ClaveEjesDistribucionF              :
        BEGIN
          TRY
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteReal3         := Param3;
            IF ( PivoteReal2 <= 0 ) OR ( PivoteReal1 < 0 ) OR
               ( PivoteReal3 <= 0 )
            THEN RAISE Exception.Create('');
            WITH MyPaqueteF DO BEGIN
              D1LibreDistribucionF              := PivoteReal2;
              D2LibreDistribucionF              := PivoteReal3;
            END;  { WITH MyPaqueteF }
            PivoteResultado2    :=
    ImplementationAuxiliarDistribucionF( PivoteReal1, @MyPaqueteF );
            MyPaqueteBeta.XBeta := PivoteReal2/2;
            MyPaqueteBeta.YBeta := PivoteReal3/2;
            IF NOT( CAFE_IntegralOctavoImpar( PivoteResultado, 0, Pi/2,
              @ImplementationAuxiliarBeta, @MyPaqueteBeta,
              CAFE_DefaultToleranciaFuncionalF/10 ) )
            THEN BEGIN
              EvaluarPredefinidoFuncionalSimple         := FALSE;
              Exit;
            END;  { IF NOT( CAFE_IntegralOctavoImpar... ) }
            PivoteResultado3            :=
                PivoteResultado2*
                ( Power( PivoteReal2/PivoteReal3, PivoteReal2/2 )
                /PivoteResultado );
            ResultadoFuncional  :=
                CAFE_RedondeoTolerancia( PivoteResultado3,
                        2.5*CAFE_DefaultToleranciaFuncionalF );
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesDistribucionF }
    ClaveEjesSumaProductos2,
    ClaveEjesProductoPunto      :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            PivoteEntero2       := Param2;
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_ProductoLista( PivoteReal1,
                        PivoteEntero1, PivoteEntero2 );
            ResultadoFuncional  := PivoteReal1;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesProductoPunto }
    ClaveEjesSumaProductos3     :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            PivoteEntero2       := Param2;
            PivoteEntero3       := Param3;
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_ProductoLista3( PivoteReal1,
                        PivoteEntero1, PivoteEntero2, PivoteEntero3 );
            ResultadoFuncional  := PivoteReal1;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesProductoPunto }
    ClaveEjesCovariance,
    ClaveEjesPendiente,
    ClaveEjesInterseccion,
    ClaveEjesCoeficienteCorrelacion             :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            PivoteEntero2       := Param2;
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_CovarianzaLista( PivoteReal1,
                        PivoteEntero1, PivoteEntero2 );
            IF ClaveInterpretado = ClaveEjesCovariance THEN BEGIN
              ResultadoFuncional                        := PivoteReal1;
            END ELSE BEGIN
              { IF ClaveInterpretado = ClaveEjesCovariance ELSE }
              PivoteReal2       :=
                Variance( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector );
              IF ClaveInterpretado = ClaveEjesPendiente THEN BEGIN
                ResultadoFuncional      := PivoteReal1/PivoteReal2;
              END ELSE BEGIN  { IF ... = ClaveEjesPendiente ELSE }
                IF ClaveInterpretado = ClaveEjesInterseccion THEN BEGIN
                  ResultadoFuncional    :=
                Mean( CAFE_ItemListaRectangular.ID[ PivoteEntero2 ].
                                        ArregloDoubleSector )
                                        -PivoteReal1*
                Mean( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].
                                        ArregloDoubleSector )
                                        /PivoteReal2;
                END ELSE BEGIN  { IF ... = ClaveEjesPendiente ELSE }
                  ResultadoFuncional := PivoteReal1/Sqrt( PivoteReal2*
                Variance( CAFE_ItemListaRectangular.ID[ PivoteEntero2 ].
                                        ArregloDoubleSector ) );
                END;            { IF ... = ClaveEjesInterseccion ELSE }
              END;            { IF ... = ClaveEjesInterseccion ELSE }
            END;
              { IF ClaveInterpretado = ClaveEjesCovariance ELSE }
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesCovariance }
    ClaveEjesDeterminante       :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_DeterminanteLista( PivoteReal1, PivoteEntero1 );
            ResultadoFuncional  := PivoteReal1;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesDeterminante }
    ClaveEjesCasillaInversa     :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            PivoteEntero2       := Param2;
            PivoteEntero3       := Param3;
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_InversaLista
                ( PivoteReal1, PivoteEntero1,
                  PivoteEntero2-1, PivoteEntero3-1 );
            ResultadoFuncional  := PivoteReal1;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesCasillaInversa }
    ClaveEjesCasillaSistema     :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            PivoteEntero2       := Param2;
            PivoteEntero3       := Param3;
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_SistemaLista
                ( PivoteReal1, PivoteEntero1,
                  PivoteEntero2, PivoteEntero3-1 );
            ResultadoFuncional  := PivoteReal1;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveEjesCasillaSistema }
      ClaveEjesMomento1,
      ClaveEjesMomento2,
      ClaveEjesMomento3,
      ClaveEjesMomento4,
      ClaveEjesSkew,
      ClaveEjesKurtosis         :
        BEGIN
          TRY
            PivoteEntero1       := Param1;
            MomentSkewKurtosis
  ( CAFE_ItemListaRectangular.ID[ PivoteEntero1 ].ArregloDoubleSector,
                 Momento1, Momento2, Momento3, Momento4, Skew, Kurtosis );
            CASE ClaveInterpretado OF
              ClaveEjesMomento1  :
                EvaluarPredefinidoFuncionalSimple       :=
                  CAFE_VarCast( ResultadoFuncional, Momento1, varDouble );
              ClaveEjesMomento2  :
                EvaluarPredefinidoFuncionalSimple       :=
                  CAFE_VarCast( ResultadoFuncional, Momento2, varDouble );
              ClaveEjesMomento3  :
                EvaluarPredefinidoFuncionalSimple       :=
                  CAFE_VarCast( ResultadoFuncional, Momento3, varDouble );
              ClaveEjesMomento4  :
                EvaluarPredefinidoFuncionalSimple       :=
                  CAFE_VarCast( ResultadoFuncional, Momento4, varDouble );
              ClaveEjesSkew      :
                EvaluarPredefinidoFuncionalSimple       :=
                  CAFE_VarCast( ResultadoFuncional, Skew    , varDouble );
              ClaveEjesKurtosis  :
                EvaluarPredefinidoFuncionalSimple       :=
                  CAFE_VarCast( ResultadoFuncional, Kurtosis, varDouble );
            END;  { CASE ClaveEjesCasillaInversa }
            EvaluarPredefinidoFuncionalSimple           := TRUE;
          EXCEPT
            ON Exception
            DO EvaluarPredefinidoFuncionalSimple        := FALSE;
          END;  { TRY }
        END;  { CASE ClaveMean }
    ClaveEjesDolarCasilla       :
        TRY
          WITH ImplementationManejador DO BEGIN
            IF HojaDefault = NIL THEN BEGIN
              CAFE_IntentoInfructuosoSintactico       := TRUE;
              CAFE_PosicionInfructuosoSintactico      :=
                              CAFE_4ErrorOrdenRequiereHojaTrabajo;
              CAFE_MensajeInfructuosoSintactico       := '$CASILLA()';
              EvaluarPredefinidoFuncionalSimple       := FALSE;
              Exit;
            END;  { IF HojaDefault = NIL }
            PivoteReal1         := Param1;
            PivoteReal2         := Param2;
            PivoteEntero1       := Round( PivoteReal1 );
            PivoteEntero2       := Round( PivoteReal2 );
            IF NOT( InRange( PivoteEntero1, 1,
                       HojaDefault.ColumnasEnHoja ) ) OR
               NOT( InRange( PivoteEntero2, 1,
                       HojaDefault.FilasEnHoja ) )
            THEN BEGIN
              CAFE_IntentoInfructuosoSintactico       := TRUE;
              CAFE_PosicionInfructuosoSintactico      :=
                      CAFE_4ErrorDatoFueraRangoAdmisible;
              CAFE_MensajeInfructuosoSintactico       := '$CASILLA()';
              EvaluarPredefinidoFuncionalSimple       := FALSE;
            END;  { IF NOT( ... ) OR NOT( ... ) }
            HojaDefault.LecturaTipo( Pred( PivoteEntero2 ),
              Pred( PivoteEntero1 ),
              PivoteBoolean1, PivoteBoolean2, CaracterMacro ,
              PivoteVariant1, PivoteVariant2 );
            IF PivoteBoolean2 THEN BEGIN
              ResultadoFuncional                      := Null;
              EvaluarPredefinidoFuncionalSimple       := FALSE;
              Exit;
            END;  { IF PivoteBoolean2 }
            IF PivoteBoolean1 THEN BEGIN
              IF NOT( HojaDefault.EvaluarFuncionSimple
                ( Pred( PivoteEntero2 ), Pred( PivoteEntero1 ),
                  PivoteVariant1, Msg, Manejador, CicloSintactico ) )
              THEN BEGIN
                ResultadoFuncional                      := Null;
                EvaluarPredefinidoFuncionalSimple       := FALSE;
                Exit;
              END;        { IF NOT( ...EvaluarFuncionSimple... ) }
            END;  { IF PivoteBoolean1 }
            EvaluarPredefinidoFuncionalSimple           :=
                CAFE_VarCast( ResultadoFuncional, PivoteVariant1, varDouble );
          END;  { WITH ImplementationManejador }
        EXCEPT
          ON Exception
          DO EvaluarPredefinidoFuncionalSimple        := FALSE;
        END;  { TRY $CASILLA }
    ELSE EvaluarPredefinidoFuncionalSimple              := FALSE;
  END;  { CASE ClaveInterpretado OF }
END;   { FUNCTION ...EvaluarPredefinidoFuncionalSimple }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
DESTRUCTOR  CAFE_Interprete2Sintactico.Destroy;
BEGIN  { DESTRUCTOR CAFE_InterpreteSintactico.Destroy }
  Inherited Destroy;
  TotalParametros               := 0;
  ProfundidadSintactica         := 0;
  ClaveInterpretado             := 0;
  FreeAndNil( SiguienteIdentificador );
  DescriptorInterprete          := [];
  ResultadoPrincipal            := varNull;
  ParametroUno                  := varNull;
  ParametroDos                  := varNull;
  ParametroTres                 := varNull;
  FreeAndNil( Parametrizacion );
END;   { DESTRUCTOR CAFE_InterpreteSintactico.Destroy }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

CONSTRUCTOR CAFE_Nudo2Sintactico.Create;
BEGIN  { CONSTRUCTOR CAFE_Nudo2Sintactico.Create }
  Inherited Create;
  MoldeGenerar                  := CAFE_Nudo2Sintactico;
END;   { CONSTRUCTOR CAFE_Nudo2Sintactico.Create }

CONSTRUCTOR CAFE_Nudo2Sintactico.Create
  (     Ide                     : LongInt                               );
BEGIN  { CONSTRUCTOR CAFE_Nudo2Sintactico.Create }
  Inherited Create( Ide );
  MoldeGenerar                  := CAFE_Nudo2Sintactico;
END;   { CONSTRUCTOR CAFE_Nudo2Sintactico.Create }

CONSTRUCTOR CAFE_Nudo2Sintactico.Create
  (     Ide                     : LongInt;
        NuevoDato               : Variant                               );
BEGIN  { CONSTRUCTOR CAFE_Nudo2Sintactico.Create }
  Inherited Create( Ide, NuevoDato );
  MoldeGenerar                  := CAFE_Nudo2Sintactico;
END;   { CONSTRUCTOR CAFE_Nudo2Sintactico.Create }

CONSTRUCTOR CAFE_Nudo2Sintactico.Create
  (     Modelo                  : CAFE_NudoSintactico                   );
BEGIN  { CONSTRUCTOR CAFE_Nudo2Sintactico.Create }
  Inherited Create( Modelo );
  MoldeGenerar                  := CAFE_Nudo2Sintactico;
END;   { CONSTRUCTOR CAFE_Nudo2Sintactico.Create }

FUNCTION    CAFE_Nudo2Sintactico.NuevoArbol
  ( CONST VectorFuente          : CAFE_ClassCharbyte
                                                ) : CAFE_Nudo2Sintactico;
VAR
  PivoteArbol                   : CAFE_NudoSintactico;
  Ubicacion                     : LongInt;

BEGIN  { FUNCTION CAFE_Nudo2Sintactico.NuevoArbol }
  PivoteArbol                   := MoldeGenerar.Create;
  Ubicacion                     := 0;
        // Vacia interior automaticamente
  PivoteArbol.GenerarArbolSintacticoBasico( VectorFuente, Ubicacion, FALSE );
  IF CAFE_IntentoInfructuosoSintactico THEN FreeAndNil( PivoteArbol );
  IF PivoteArbol = NIL
  THEN NuevoArbol               := NIL
  ELSE NuevoArbol               := PivoteArbol as CAFE_Nudo2Sintactico;
END;   { FUNCTION CAFE_Nudo2Sintactico.NuevoArbol }

FUNCTION    CAFE_Nudo2Sintactico.TotalDescendientesDirectos
  (       PunteroActual         : CAFE_NudoSintactico  = NIL    ) : LongInt;
VAR
  PivoteRespuesta               : LongInt;

BEGIN  { FUNCTION CAFE_Nudo2Sintactico.TotalDescendientesDirectos }
  IF PunteroActual = NIL THEN PunteroActual     := Self;
  PivoteRespuesta               := 0;
  PunteroActual                 := PunteroActual.DescendienteVertical;
  WHILE PunteroActual <> NIL DO BEGIN
    PunteroActual      := PunteroActual.DescendienteHorizontal;
    Inc( PivoteRespuesta );
  END;  { WHILE PunteroActual <> NIL }
  TotalDescendientesDirectos    := PivoteRespuesta;
END;   { FUNCTION CAFE_Nudo2Sintactico.TotalDescendientesDirectos }

FUNCTION    CAFE_Nudo2Sintactico.InterpretarMacroFuncion
  (       Manejador             : CAFE_InterfaceBasico;
    OUT   FuncionReturn         : Variant;
    OUT   Msg                   : ShortString;
    CONST NomParam1             : ShortString   = '';
    CONST NomParam2             : ShortString   = '';
    CONST NomParam3             : ShortString   = '';
    CONST NomFor1               : ShortString   = '';
    CONST NomFor2               : ShortString   = '';
    CONST NomFor3               : ShortString   = '';
          SubRegistro           : Boolean       = FALSE         ) : Boolean;
VAR
  PivoteString                  : ShortString;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

    { ANIDADO }
  FUNCTION AnidadoObtenerTipoParametros
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   Par1                : SizeInt;
      OUT   Par2                : SizeInt;
      OUT   Par3                : SizeInt;
            BanderaVertical     : Boolean       = TRUE          ) : Boolean;
                                forward;
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoAnularDefault
    (       PunteroActual       : CAFE_Nudo2Sintactico;
            Bandera1            : Boolean;
            Tipo1               : SizeInt;
            Bandera2            : Boolean;
            Tipo2               : SizeInt;
            Bandera3            : Boolean;
            Tipo3               : SizeInt                               );
  VAR
    PunteroPivote,
    PunteroAnexo                : CAFE_NudoSintactico;
    NuevoDato                   : Variant;

  BEGIN  { PROCEDURE AnidadoAnularDefault }
    IF Bandera1 THEN BEGIN
      NuevoDato                 := CAFE_DefaultNuloVariant( Tipo1 );
      PunteroAnexo              := PunteroActual.MoldeGenerar.Create;
      PunteroAnexo.DatoElemento := NuevoDato;
      PunteroAnexo.DescendienteHorizontal       :=
                                PunteroActual.DescendienteVertical;
      PunteroActual.DescendienteVertical        := PunteroAnexo;
    END;  { IF Bandera1 }
    PunteroPivote               := PunteroActual.DescendienteVertical;
    IF Bandera2 THEN BEGIN
      NuevoDato                 := CAFE_DefaultNuloVariant( Tipo2 );
      PunteroAnexo              := PunteroActual.MoldeGenerar.Create;
      PunteroAnexo.DatoElemento := NuevoDato;
      PunteroAnexo.DescendienteHorizontal       :=
                                PunteroPivote.DescendienteHorizontal;
      PunteroPivote.DescendienteHorizontal      := PunteroAnexo;
    END;  { IF Bandera2 }
    PunteroPivote               := PunteroPivote.DescendienteHorizontal;
    IF Bandera3 THEN BEGIN
      NuevoDato                 := CAFE_DefaultNuloVariant( Tipo3 );
      PunteroAnexo              := PunteroActual.MoldeGenerar.Create;
      PunteroAnexo.DatoElemento := NuevoDato;
      PunteroAnexo.DescendienteHorizontal       :=
                                PunteroPivote.DescendienteHorizontal;
      PunteroPivote.DescendienteHorizontal      := PunteroAnexo;
    END;  { IF Bandera3 }
  END;   { PROCEDURE AnidadoAnularDefault }
    { ANIDADO }

    { ANIDADO }
  FUNCTION AnidadoIdentificador
    ( CONST AnidadoString       : ShortString;
            PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   IdentificadorReturn : Variant                       ) : Boolean;
  VAR
    Interprete                  : CAFE_Interprete2Sintactico;
    CaracterMacro               : CAFE_ConjuntoParametroBasico;
    Fila,
    Columna                     : LongInt;
    BanderaNudillado,
    BanderaMacro,
    FilaBandera,
    ColumnaBandera              : Boolean;

      { ANIDADO }
    FUNCTION AnidadoParametro
      ( CONST MyParam           : ShortString;
              DesPar            : CAFE_TipoInterprete           ) : Boolean;
    BEGIN  { FUNCTION AnidadoParametro }
      Interprete                := CAFE_Interprete2Sintactico.Create;
      WITH Interprete DO BEGIN
        NombreIdentificador     := MyParam;
        ValorInterpretado       := 0.0;
        BanderaVariant          := FALSE;
        BanderaSimple           := TRUE;
        DescriptorInterprete    :=
                [ ActivoNITI, ParametroMacroNITI, NudilladoNITI, Despar ];
      END;  { WITH Interprete }
      PunteroActual.DatoInterpretado            := Interprete;
      IdentificadorReturn       := CAFE_DefaultNuloVariant( varDouble );
      AnidadoParametro          := TRUE;
    END;   { FUNCTION AnidadoParametro }
      { ANIDADO }

      { ANIDADO }
    FUNCTION AnidadoParametroFor
      ( CONST MyParam           : ShortString;
              DesPar            : CAFE_TipoInterprete           ) : Boolean;
    BEGIN  { FUNCTION AnidadoParametroFor }
      Interprete                := CAFE_Interprete2Sintactico.Create;
      WITH Interprete DO BEGIN
        NombreIdentificador     := MyParam;
        ValorInterpretado       := 0.0;
        BanderaVariant          := FALSE;
        BanderaSimple           := TRUE;
        DescriptorInterprete    :=
                [ ActivoNITI, ParametroCalculoNITI, NudilladoNITI, Despar ];
      END;  { WITH Interprete }
      PunteroActual.DatoInterpretado            := Interprete;
      IdentificadorReturn       := CAFE_DefaultNuloVariant( varDouble );
      AnidadoParametroFor       := TRUE;
    END;   { FUNCTION AnidadoParametroFor }
      { ANIDADO }

  BEGIN  { FUNCTION AnidadoIdentificador }
    IF NOT( SubRegistro ) THEN BEGIN
      IF AnidadoString = NomParam1 THEN BEGIN
        AnidadoIdentificador      :=
                  AnidadoParametro( NomParam1, Parametro1DNITI );
        Exit;
      END;  { IF AnidadoString = NomParam1 }
      IF AnidadoString = NomParam2 THEN BEGIN
        AnidadoIdentificador      :=
                  AnidadoParametro( NomParam2, Parametro2DNITI );
        Exit;
      END;  { IF AnidadoString = NomParam2 }
      IF AnidadoString = NomParam3 THEN BEGIN
        AnidadoIdentificador      :=
                  AnidadoParametro( NomParam3, Parametro3DNITI );
        Exit;
      END;  { IF AnidadoString = NomParam3 }
      IF AnidadoString = NomFor1 THEN BEGIN
        AnidadoIdentificador      :=
                  AnidadoParametroFor( NomFor1, Parametro1CalculoNITI );
        Exit;
      END;  { IF AnidadoString = NomFor1 }
      IF AnidadoString = NomFor2 THEN BEGIN
        AnidadoIdentificador      :=
                  AnidadoParametroFor( NomFor2, Parametro2CalculoNITI );
        Exit;
      END;  { IF AnidadoString = NomFor2 }
      IF AnidadoString = NomFor3 THEN BEGIN
        AnidadoIdentificador      :=
                  AnidadoParametroFor( NomFor3, Parametro3CalculoNITI );
        Exit;
      END;  { IF AnidadoString = NomFor3 }
    END;  { IF NOT( SubRegistro ) }
    WITH MyManejador DO BEGIN
      Interprete                :=
        PaquetePredefinido.BusquedaNombreIdentificador( AnidadoString );
      IF Interprete = NIL THEN BEGIN
        Interprete              := PaquetePredefinido.
          BusquedaNombreIdentificador
                ( PaqueteIdioma.Values[ AnidadoString ] );
      END;  { IF Interprete = NIL ELSE }
      IF Interprete = NIL THEN BEGIN
        IF HojaDefault = NIL THEN BEGIN
          AnidadoIdentificador          := FALSE;
        END ELSE BEGIN  { IF HojaDefault = NIL ELSE }
          IF HojaDefault.IdentificadorValidoCasilla( AnidadoString,
                FilaBandera, Fila, ColumnaBandera, Columna ) THEN BEGIN
            Interprete          := CAFE_Interprete2Sintactico.Create;
            Interprete.EstablecerCasillaHojaDefault
                        ( FilaBandera, Fila, ColumnaBandera, Columna );
            PunteroActual.DatoInterpretado              := Interprete;
            IdentificadorReturn := CAFE_DefaultNuloCasilla(
                HojaDefault.LecturaTipo
               ( Fila, Columna, BanderaNudillado,
                        BanderaMacro, CaracterMacro ) );
            IF BanderaMacro THEN BEGIN
              AnidadoIdentificador      := FALSE;
            END ELSE BEGIN  { IF BanderaMacro }
              AnidadoIdentificador      := TRUE;
            END;            { IF BanderaMacro }
          END ELSE BEGIN  { IF HojaDefault.IdentificadorValidoCasilla... }
            // Existe la posibilidad de funciones sin parametros
            // futura mejora...
            IF SubRegistro THEN BEGIN
              IF AnidadoString = NomParam1 THEN BEGIN
                AnidadoIdentificador      :=
                          AnidadoParametro( NomParam1, Parametro1DNITI );
                Exit;
              END;  { IF AnidadoString = NomParam1 }
              IF AnidadoString = NomParam2 THEN BEGIN
                AnidadoIdentificador      :=
                          AnidadoParametro( NomParam2, Parametro2DNITI );
                Exit;
              END;  { IF AnidadoString = NomParam2 }
              IF AnidadoString = NomParam3 THEN BEGIN
                AnidadoIdentificador      :=
                          AnidadoParametro( NomParam3, Parametro3DNITI );
                Exit;
              END;  { IF AnidadoString = NomParam3 }
              IF AnidadoString = NomFor1 THEN BEGIN
                AnidadoIdentificador      :=
                  AnidadoParametroFor( NomFor1, Parametro1CalculoNITI );
                Exit;
              END;  { IF AnidadoString = NomFor1 }
              IF AnidadoString = NomFor2 THEN BEGIN
                AnidadoIdentificador      :=
                  AnidadoParametroFor( NomFor2, Parametro2CalculoNITI );
                Exit;
              END;  { IF AnidadoString = NomFor2 }
              IF AnidadoString = NomFor3 THEN BEGIN
                AnidadoIdentificador      :=
                  AnidadoParametroFor( NomFor3, Parametro3CalculoNITI );
                Exit;
              END;  { IF AnidadoString = NomFor3 }
            END;  { IF NOT( SubRegistro ) }
            AnidadoIdentificador        := FALSE;
          END;            { IF HojaDefault.IdentificadorValidoCasilla... }
        END;            { IF HojaDefault = NIL ELSE }
      END ELSE BEGIN  { IF Interprete = NIL ELSE }
        // Unicamente sirve para el caso simple Interprete.BanderaSimple
        PunteroActual.DatoInterpretado                  := Interprete;
        IdentificadorReturn             := Interprete.ValorInterpretado;
        AnidadoIdentificador            := Interprete.BanderaVariant AND
                                                Interprete.BanderaSimple;
      END;            { IF Interprete = NIL ELSE }
    END;  { WITH MyManejador }
  END;   { FUNCTION AnidadoIdentificador }
    { ANIDADO }

    { ANIDADO }
  FUNCTION AnidadoFuncion
    ( CONST AnidadoString       : ShortString;
            PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   AnidadoReturn       : Variant                       ) : Boolean;
  VAR
    AnidadoString2,
    InteriorString              : ShortString;
    Interprete                  : CAFE_Interprete2Sintactico;
    CaracterMacro               : CAFE_ConjuntoParametroBasico;
    Fila,
    Columna                     : LongInt;
    ParPiv1,
    ParPiv2,
    ParPiv3,
    Par1,
    Par2,
    Par3                        : SizeInt;
    DefaultNecesarios           : Byte;
    TotalParametrosPiv          : LongInt;
    PrimerReintento,
    BanderaPruebaMacro,
    BanderaNudillado,
    BanderaMacro,
    BanderaAnexar1,
    BanderaAnexar2,
    BanderaAnexar3,
    FilaBandera,
    ColumnaBandera              : Boolean;

  LABEL
    CicloReintento,
    SalidaVerdadera,
    SalidaReintento;

      { ANIDADO }
    FUNCTION AnidadoFor( DesFun : CAFE_TipoInterprete   ) : Boolean;
    VAR
      PivoteVarFor              : ShortString;
      PunteroPivotePar,
      PunteroPivoteFor          : CAFE_Nudo2Sintactico;
      NuevoInterprete           : CAFE_Interprete2Sintactico;
      MyPar1,
      MyPar2,
      MyPar3                    : SizeInt;
      NumeroFor                 : Byte;

    LABEL
      SalidaFalsa;

    BEGIN  { FUNCTION AnidadoFor }
      TotalParametrosPiv        :=
                        TotalDescendientesDirectos( PunteroActual );
      IF ( TotalParametrosPiv < 3 ) THEN GOTO SalidaFalsa;
      PunteroPivoteFor          :=
        PunteroActual.DescendienteVertical as CAFE_Nudo2Sintactico;
      PunteroPivotePar          :=
        PunteroPivoteFor.DescendienteHorizontal as CAFE_Nudo2Sintactico;
      IF CAFE_TipoVariante( PunteroPivotePar.DatoElemento ) <> varString
      THEN GOTO SalidaFalsa;
      PivoteVarFor              := PunteroPivotePar.DatoElemento;
      IF ( Length( PivoteVarFor ) = 0 ) THEN GOTO SalidaFalsa;
      IF PivoteVarFor[ Length( PivoteVarFor ) ] = ')' THEN GOTO SalidaFalsa;
      IF NomFor3 <> '' THEN GOTO SalidaFalsa;
      NumeroFor                 := 3;
      IF NomFor2 = '' THEN NumeroFor    := 2;
      IF NomFor1 = '' THEN NumeroFor    := 1;
      NuevoInterprete           := CAFE_Interprete2Sintactico.Create;
      WITH NuevoInterprete DO BEGIN
        NombreIdentificador     := PivoteVarFor;
        ValorInterpretado       := 0.0;
        BanderaVariant          := FALSE;
        BanderaSimple           := TRUE;
        DescriptorInterprete    :=
                [ ActivoNITI, ParametroCalculoNITI, NudilladoNITI ];
        CASE NumeroFor OF
          1     : Include( DescriptorInterprete, Parametro1CalculoNITI );
          2     : Include( DescriptorInterprete, Parametro2CalculoNITI );
          3     : Include( DescriptorInterprete, Parametro3CalculoNITI );
        END;  { CASE NumeroFor }
      END;  { WITH Interprete }
      PunteroPivotePar.DatoInterpretado         := NuevoInterprete;
      CASE NumeroFor OF
        1       : IF NOT( PunteroPivoteFor.
                        InterpretarMacroFuncion( Manejador, AnidadoReturn,
                        Msg, NomParam1, NomParam2, NomParam3,
                        PivoteVarFor ) )
                        THEN GOTO SalidaFalsa;
        2       : IF NOT( PunteroPivoteFor.
                        InterpretarMacroFuncion( Manejador, AnidadoReturn,
                        Msg, NomParam1, NomParam2, NomParam3,
                        NomFor1, PivoteVarFor ) )
                        THEN GOTO SalidaFalsa;
        3       : IF NOT( PunteroPivoteFor.
                        InterpretarMacroFuncion( Manejador, AnidadoReturn,
                        Msg, NomParam1, NomParam2, NomParam3,
                        NomFor1, NomFor2, PivoteVarFor ) )
                        THEN GOTO SalidaFalsa;
      END;  { CASE NumeroFor OF }
      IF NOT( ImplementationOverloadTypeSimpleValorCompatible
        ( varDouble, CAFE_TipoVariante( AnidadoReturn ) ) )
      THEN GOTO SalidaFalsa;
      IF NOT( AnidadoObtenerTipoParametros
               ( PunteroPivotePar, MyPar1, MyPar2, MyPar3, FALSE ) )
      THEN GOTO SalidaFalsa;
      CASE DesFun OF
        SumatoriaNITI,
        ProductoriaNITI         :
            IF NOT( ImplementationOverloadTypeSimpleValorCompatible
                 ( varInteger, MyPar1 ) AND
                 ImplementationOverloadTypeSimpleValorCompatible
                 ( varInteger, MyPar2 ) AND
                 ( MyPar3 = varNull ) ) THEN GOTO SalidaFalsa;
        IntegralNITI            :
            IF NOT( ImplementationOverloadTypeSimpleValorCompatible
                 ( varDouble, MyPar1 ) AND
                 ImplementationOverloadTypeSimpleValorCompatible
                 ( varDouble, MyPar2 ) AND
                 CAFE_TypeSimpleValorCompatible
                 ( varDouble, MyPar3 ) ) THEN GOTO SalidaFalsa;
        DerivadaNITI    :
            IF NOT( ImplementationOverloadTypeSimpleValorCompatible
                 ( varDouble, MyPar1 ) AND
                 CAFE_TypeSimpleValorCompatible
                 ( varDouble, MyPar2 ) AND
                 CAFE_TypeSimpleValorCompatible
                 ( varDouble, MyPar3 ) ) THEN GOTO SalidaFalsa;
        SolveNITI,
        SolveMaximoNITI,
        SolveMinimoNITI :
            IF NOT( ImplementationOverloadTypeSimpleValorCompatible
                 ( varDouble, MyPar1 ) AND
                 ImplementationOverloadTypeSimpleValorCompatible
                 ( varDouble, MyPar2 ) AND
                 CAFE_TypeSimpleValorCompatible
                 ( varDouble, MyPar3 ) ) THEN GOTO SalidaFalsa;
      END;  { CASE DesFun }
      NuevoInterprete           := CAFE_Interprete2Sintactico.Create;
      WITH NuevoInterprete DO BEGIN
        NombreIdentificador     := AnidadoString;
        ValorInterpretado       := 0.0;
        BanderaVariant          := FALSE;
        BanderaSimple           := TRUE;
        DescriptorInterprete    :=
                [ ActivoNITI, OrdenCalculoNITI, NudilladoNITI, DesFun ];
      END;  { WITH Interprete }
      PunteroActual.DatoInterpretado            := NuevoInterprete;
      AnidadoFor                                := TRUE;
      Exit;
SalidaFalsa :
      AnidadoFor                := FALSE;
    END;   { FUNCTION AnidadoFor }
      { ANIDADO }

      { ANIDADO }
    FUNCTION AnidadoSecuenciaRectangular                        : Boolean;
    VAR
      PunteroMovil              : CAFE_Nudo2Sintactico;
      NuevoInterprete           : CAFE_Interprete2Sintactico;
      Fila,
      Columna                   : LongInt;
      RepiteCasilla             : Byte;
      FilaBandera,
      ColumnaBandera            : Boolean;

    LABEL
      SalidaFalsa;

    BEGIN  { FUNCTION AnidadoSecuenciaRectangular }
      PunteroMovil              :=
                PunteroActual.DescendienteVertical as CAFE_Nudo2Sintactico;
      FOR RepiteCasilla := 1 TO 2 DO BEGIN
        IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
        IF NOT( CAFE_TipoVariante( PunteroMovil.DatoElemento )  = varString )
        THEN GOTO SalidaFalsa;
        IF NOT( MyManejador.HojaDefault.IdentificadorValidoCasilla(
                  PunteroMovil.DatoElemento,
                  FilaBandera, Fila, ColumnaBandera, Columna ) )
        THEN GOTO SalidaFalsa;
        NuevoInterprete         := NIL;
        NuevoInterprete         := CAFE_Interprete2Sintactico.Create;
        NuevoInterprete.EstablecerCasillaHojaDefault
                          ( FilaBandera, Fila, ColumnaBandera, Columna );
        PunteroMovil.DatoInterpretado    := NuevoInterprete;
        PunteroMovil            :=
                PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
      END;  { FOR RepiteCasilla }
      AnidadoReturn             := Null;
      NuevoInterprete           := NIL;
      NuevoInterprete           := CAFE_Interprete2Sintactico.Create;
      WITH NuevoInterprete DO BEGIN
        NombreIdentificador     :=
                CAFE_SecuenciaRectangularHojaTraducidoOperadorBasico;
        ValorInterpretado       := 0;
        BanderaVariant          := FALSE;
        BanderaSimple           := TRUE;
        DescriptorInterprete    :=
                [ ActivoNITI, OperadorSectorNITI, NudilladoNITI ];
        ClaveInterpretado       := ClaveEjesExtraTipoSector;
      END;  { WITH NuevoInterprete }
      PunteroActual.DatoInterpretado            := NuevoInterprete;
      AnidadoSecuenciaRectangular               := PunteroMovil = NIL;
      Exit;
SalidaFalsa :
      AnidadoSecuenciaRectangular               := FALSE;
    END;   { FUNCTION AnidadoSecuenciaRectangular }
      { ANIDADO }

      { ANIDADO }
    FUNCTION AnidadoSilenciarSector                             : Boolean;
    VAR
      PunteroMovil                      : CAFE_NudoSintactico;

    BEGIN  { FUNCTION AnidadoSilenciarSector }
      PunteroMovil              :=
                PunteroActual.DescendienteVertical as CAFE_Nudo2Sintactico;
      WHILE PunteroMovil <> NIL DO BEGIN
        IF PunteroMovil.DatoInterpretado <> NIL THEN BEGIN
          WITH PunteroMovil.DatoInterpretado as CAFE_Interprete2Sintactico
          DO BEGIN
            IF ClaveInterpretado = ClaveEjesExtraTipoSector THEN BEGIN
              Include( DescriptorInterprete, SilenciarSectorNITI );
            END;  { IF ClaveInterpretado = ClaveEjesExtraTipoSector }
          END;  { WITH PunteroMovil.DatoInterpretado as ... }
        END;  { IF PunteroMovil.DatoInterpretado <> NIL }
        PunteroMovil            :=
                PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
      END;  { WHILE PunteroMovil <> NIL }
      AnidadoSilenciarSector    := TRUE;
    END;   { FUNCTION AnidadoSilenciarSector }
      { ANIDADO }

      { ANIDADO }
    FUNCTION AnidadoManejadorParalelo                           : Boolean;
    VAR
      Cadenita                  : ShortString;
      PunteroMovil              : CAFE_Nudo2Sintactico;
      PunteroInterprete,
      NuevoInterprete           : CAFE_Interprete2Sintactico;
      OtroManejadorBasico       : CAFE_ManejadorBasico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
      OtroManejador             : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
      NuevoNumeroManejador      : LongInt;

    LABEL
      SalidaFalsa;

    BEGIN  { FUNCTION AnidadoManejadorParalelo }
      PunteroMovil              :=
                PunteroActual.DescendienteVertical as CAFE_Nudo2Sintactico;
      IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
      IF NOT( CAFE_TipoVariante( PunteroMovil.DatoElemento )  = varString )
      THEN GOTO SalidaFalsa;
      Cadenita                  := PunteroMovil.DatoElemento;
      // Poco elegante...
      IF Cadenita = 'MISMO' THEN Cadenita := CAFE_CadenaIdentificadorSelf;
      PunteroInterprete         := NIL;
      PunteroMovil.DatoInterpretado             := NIL;
      REPEAT
        PunteroInterprete       := MyManejador.PaquetePredefinido.
                BusquedaNombreIdentificador( Cadenita, PunteroInterprete );
        IF PunteroInterprete <> NIL THEN BEGIN
          IF [ ActivoNITI, RegistroAsociadoNITI, ManejadorPrincipalNITI ] <=
                                PunteroInterprete.DescriptorInterprete
          THEN BEGIN
            PunteroMovil.DatoInterpretado       := PunteroInterprete;
            NuevoNumeroManejador                :=
                                PunteroInterprete.ValorInterpretado;
            OtroManejadorBasico                 :=
                CAFE_RaizManejadores.ID[ NuevoNumeroManejador ];
            IF OtroManejadorBasico = NIL THEN GOTO SalidaFalsa;
            IF Cadenita <> CAFE_CadenaIdentificadorSelf THEN BEGIN
              IF OtroManejadorBasico.DisplayNombre <> Cadenita
              THEN GOTO SalidaFalsa;
            END;  { IF ClaveEjesIdentificadorSelf }
            OtroManejadorBasico.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, OtroManejador );
          END;
          { IF [ ActivoNITI, RegistroAsociadoNITI ... ] <= ... }
        END ELSE GOTO SalidaFalsa;
          { IF PunteroInterprete <> NIL }
      UNTIL PunteroMovil.DatoInterpretado <> NIL;
      PunteroMovil              :=
                PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
      IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
      IF NOT( CAFE_TipoVariante( PunteroMovil.DatoElemento )  = varString )
      THEN GOTO SalidaFalsa;
      IF NOT( PunteroMovil.InterpretarMacroFuncion(
                OtroManejador, AnidadoReturn, Msg,
                NomParam1, NomParam2, NomParam3,
                NomFor1, NomFor2, NomFor3, TRUE ) ) THEN GOTO SalidaFalsa;
      NuevoInterprete           := NIL;
      NuevoInterprete           := CAFE_Interprete2Sintactico.Create;
      WITH NuevoInterprete DO BEGIN
        NombreIdentificador     :=
                CAFE_OperadorRegistroCampoTraducidoOperadorBasico;
        ValorInterpretado       := 0;
        BanderaVariant          := FALSE;
        BanderaSimple           := TRUE;
        DescriptorInterprete    :=
                [ ActivoNITI, OperadorRegistroNITI, NudilladoNITI ];
        ClaveInterpretado       := ClaveEjesExtraTipoRegistro;
      END;  { WITH NuevoInterprete }
      PunteroActual.DatoInterpretado            := NuevoInterprete;
      AnidadoManejadorParalelo                  :=
                        PunteroMovil.DescendienteHorizontal = NIL;
      Exit;
SalidaFalsa :
      AnidadoManejadorParalelo                  := FALSE;
    END;   { FUNCTION AnidadoManejadorParalelo }
      { ANIDADO }

  BEGIN  { FUNCTION AnidadoFuncion }
    IF AnidadoString = CAFE_OperadorRegistroCampoTraducidoOperadorBasico
    THEN BEGIN
      AnidadoFuncion            := AnidadoManejadorParalelo;
      Exit;
    END;  { IF AnidadoString = CAFE_OperadorRegistroCampoTraducido... }
    IF AnidadoString = CAFE_SecuenciaRectangularHojaTraducidoOperadorBasico
    THEN BEGIN
      AnidadoFuncion            := AnidadoSecuenciaRectangular;
      Exit;
    END;  { IF AnidadoString = CAFE_SecuenciaRectangularHojaTraducido... }
    IF AnidadoString = CAFE_StringSumatoria THEN BEGIN
      AnidadoFuncion            := AnidadoFor( SumatoriaNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringSumatoria }
    IF AnidadoString = CAFE_StringProductoria THEN BEGIN
      AnidadoFuncion            := AnidadoFor( ProductoriaNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringProductoria }
    IF AnidadoString = CAFE_StringIntegral THEN BEGIN
      AnidadoFuncion            := AnidadoFor( IntegralNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringIntegral }
    IF AnidadoString = CAFE_StringDerivada THEN BEGIN
      AnidadoFuncion            := AnidadoFor( DerivadaNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringDerivada }
    IF AnidadoString = CAFE_StringSolve THEN BEGIN
      AnidadoFuncion            := AnidadoFor( SolveNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringSolve }
    IF AnidadoString = CAFE_StringSolveMaximo THEN BEGIN
      AnidadoFuncion            := AnidadoFor( SolveMaximoNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringSolveMaximo }
    IF AnidadoString = CAFE_StringSolveMinimo THEN BEGIN
      AnidadoFuncion            := AnidadoFor( SolveMinimoNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringSolveMinimo }
    IF AnidadoString = CAFE_StringSumatoria2 THEN BEGIN
      AnidadoFuncion            := AnidadoFor( SumatoriaNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringSumatoria2 }
    IF AnidadoString = CAFE_StringProductoria2 THEN BEGIN
      AnidadoFuncion            := AnidadoFor( ProductoriaNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringProductoria2 }
    IF AnidadoString = CAFE_StringIntegral2 THEN BEGIN
      AnidadoFuncion            := AnidadoFor( IntegralNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringIntegral2 }
    IF AnidadoString = CAFE_StringDerivada2 THEN BEGIN
      AnidadoFuncion            := AnidadoFor( DerivadaNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringDerivada2 }
    IF AnidadoString = CAFE_StringSolve2 THEN BEGIN
      AnidadoFuncion            := AnidadoFor( SolveNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringSolve2 }
    IF AnidadoString = CAFE_StringSolveMaximo2 THEN BEGIN
      AnidadoFuncion            := AnidadoFor( SolveMaximoNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringSolveMaximo2 }
    IF AnidadoString = CAFE_StringSolveMinimo2 THEN BEGIN
      AnidadoFuncion            := AnidadoFor( SolveMinimoNITI );
      Exit;
    END;  { IF AnidadoString = CAFE_StringSolveMinimo2 }
    WITH MyManejador DO BEGIN
      Interprete                :=
        PaquetePredefinido.BusquedaNombreIdentificador( AnidadoString );
      IF Interprete = NIL THEN BEGIN
        AnidadoString2          := PaqueteIdioma.Values[ AnidadoString ];
        IF AnidadoString2 <> ''
        THEN Interprete                :=
          PaquetePredefinido.BusquedaNombreIdentificador( AnidadoString2 );
      END ELSE BEGIN  { IF Interprete = NIL ELSE }
        AnidadoString2          := AnidadoString;
      END;            { IF Interprete = NIL ELSE }
      IF Interprete = NIL THEN BEGIN
        IF HojaDefault = NIL THEN BEGIN
          AnidadoFuncion                := FALSE;
        END ELSE BEGIN  { IF HojaDefault = NIL ELSE }
          InteriorString                :=
                Copy( AnidadoString, 0, Length( AnidadoString )-2 );
          IF HojaDefault.IdentificadorValidoCasilla( InteriorString,
                FilaBandera, Fila, ColumnaBandera, Columna ) THEN BEGIN
            Interprete          := CAFE_Interprete2Sintactico.Create;
            Interprete.EstablecerCasillaHojaDefault
                        ( FilaBandera, Fila, ColumnaBandera, Columna );
            PunteroActual.DatoInterpretado              := Interprete;
            AnidadoReturn               := CAFE_DefaultNuloVariant(
                        HojaDefault.LecturaTipo
               ( Fila, Columna, BanderaNudillado,
                        BanderaMacro, CaracterMacro ) );
            IF BanderaMacro THEN BEGIN
              // Maximo tres Parametros, lo siento...
              AnidadoReturn             :=
                        CAFE_DefaultNuloVariant( varDouble );
              TotalParametrosPiv        :=
                        TotalDescendientesDirectos( PunteroActual );
              CASE TotalParametrosPiv OF
                1                       : BanderaPruebaMacro    :=
                  [ ActivoHCGM, BasicoStandardHCGM, Real1DHCGM ] <=
                                                        CaracterMacro;
                2                       : BanderaPruebaMacro    :=
                  [ ActivoHCGM, BasicoStandardHCGM, Real2DHCGM ] <=
                                                        CaracterMacro;
                3                       : BanderaPruebaMacro    :=
                  [ ActivoHCGM, BasicoStandardHCGM, Real3DHCGM ] <=
                                                        CaracterMacro;
                ELSE                      BanderaPruebaMacro    := FALSE;
              END;  { CASE TotalParametrosPiv }
              IF BanderaPruebaMacro THEN BEGIN
                // Maximo tres parametros, lo siento
                IF AnidadoObtenerTipoParametros
                        ( PunteroActual, Par1, Par2, Par3 )
                THEN BEGIN
                  AnidadoFuncion        :=
                        CAFE_TypeSimpleValorCompatible( varDouble, Par1 ) AND
                        CAFE_TypeSimpleValorCompatible( varDouble, Par2 ) AND
                        CAFE_TypeSimpleValorCompatible( varDouble, Par3 );
                END ELSE BEGIN  { IF AnidadoObtenerTipoParametros... ELSE }
                  AnidadoFuncion        := FALSE;
                END;            { IF AnidadoObtenerTipoParametros... ELSE }
              END ELSE BEGIN  { IF BanderaPruebaMacro ELSE }
                AnidadoFuncion          := FALSE;
              END;            { IF BanderaPruebaMacro ELSE }
            END ELSE BEGIN  { IF BanderaMacro ELSE }
              // entonces es una funcion...
              AnidadoFuncion            := FALSE;
              Exit;
            END;            { IF BanderaMacro ELSE }
          END ELSE BEGIN  { IF HojaDefault.IdentificadorValidoCasilla... }
            AnidadoFuncion              := FALSE;
          END;            { IF HojaDefault.IdentificadorValidoCasilla... }
        END;            { IF HojaDefault = NIL ELSE }
      END ELSE BEGIN  { IF Interprete = NIL ELSE }
        // Unicamente sirve para el caso simple Interprete.BanderaSimple
        { Ahora si es una funcion de verdad con Overload y todo... }
        PrimerReintento                 := TRUE;
CicloReintento:
        CAFE_VarCast( AnidadoReturn, Interprete.ValorInterpretado,
                        Interprete.ResultadoPrincipal );
        IF NOT( Interprete.BanderaSimple ) THEN GOTO SalidaReintento;
        TotalParametrosPiv              :=
                TotalDescendientesDirectos( PunteroActual );
        IF ( TotalParametrosPiv > Interprete.TotalParametros ) OR
           ( ( TotalParametrosPiv <> Interprete.TotalParametros ) AND
           NOT( ActivarDefaultNITI IN Interprete.DescriptorInterprete ) )
        THEN GOTO SalidaReintento;
        IF Interprete.TotalParametros > 0 THEN BEGIN
          IF PrimerReintento THEN BEGIN
            IF NOT(AnidadoObtenerTipoParametros
                        ( PunteroActual, ParPiv1, ParPiv2, ParPiv3 ) )
            THEN BEGIN  { IF NOT( AnidadoObtenerTipoParametros... ) }
              AnidadoFuncion            := FALSE;
              Exit;
            END;        { IF NOT( AnidadoObtenerTipoParametros... ) }
            PrimerReintento             := FALSE;
          END;  { IF PrimerReintento }
          Par1                          := ParPiv1;
          Par2                          := ParPiv2;
          Par3                          := ParPiv3;
          IF NOT( ActivarDefaultNITI IN Interprete.DescriptorInterprete )
          THEN BEGIN
            IF ( ImplementationOverloadTypeSimpleValorCompatible
                              ( Interprete.ParametroUno, Par1 ) AND
                 ImplementationOverloadTypeSimpleValorCompatible
                              ( Interprete.ParametroDos, Par2 ) AND
                 ImplementationOverloadTypeSimpleValorCompatible
                              ( Interprete.ParametroTres, Par3 ) )
            THEN GOTO SalidaVerdadera
            ELSE GOTO SalidaReintento;
          END ELSE BEGIN  { IF NOT( ActivarDefaultNITI ... ) ELSE }
            BanderaAnexar1            := FALSE;
            BanderaAnexar2            := FALSE;
            BanderaAnexar3            := FALSE;
            DefaultNecesarios         :=
                      Interprete.TotalParametros-TotalParametrosPiv;
            IF NOT( ImplementationOverloadTypeSimpleValorCompatible
                      ( Interprete.ParametroUno, Par1 ) ) THEN BEGIN
              IF ( ( DefaultNecesarios = 0 ) OR
                      NOT( PrimeroDefaultNITI IN
                      Interprete.DescriptorInterprete ) )
              THEN BEGIN
                GOTO SalidaReintento;
              END ELSE BEGIN  { IF ( ( DefaultNecesarios ... ) ELSE }
                Dec( DefaultNecesarios );
                BanderaAnexar1        := TRUE;
                Par3                  := Par2;
                Par2                  := Par1;
              END;            { IF ( ( DefaultNecesarios ... ) ELSE }
            END;  { IF NOT( CAFE_TypeSimpleValorCompatible( ... ) ) }
            IF NOT( ImplementationOverloadTypeSimpleValorCompatible
                      ( Interprete.ParametroDos, Par2 ) ) THEN BEGIN
              IF ( ( DefaultNecesarios = 0 ) OR
                      NOT( SegundoDefaultNITI IN
                      Interprete.DescriptorInterprete ) )
              THEN BEGIN
                GOTO SalidaReintento;
              END ELSE BEGIN  { IF ( ( DefaultNecesarios ... ) ELSE }
                Dec( DefaultNecesarios );
                BanderaAnexar2        := TRUE;
                Par3                  := Par2;
              END;            { IF ( ( DefaultNecesarios ... ) ELSE }
            END;  { IF NOT( CAFE_TypeSimpleValorCompatible( ... ) ) }
            IF NOT( ImplementationOverloadTypeSimpleValorCompatible
                      ( Interprete.ParametroTres, Par3 ) )
            THEN BEGIN
              IF ( ( DefaultNecesarios = 0 ) OR
                      NOT( TerceroDefaultNITI IN
                      Interprete.DescriptorInterprete ) )
              THEN BEGIN
                GOTO SalidaReintento;
              END ELSE BEGIN  { IF ( ( DefaultNecesarios ... ) ELSE }
                Dec( DefaultNecesarios );
                BanderaAnexar3        := TRUE;
              END;            { IF ( ( DefaultNecesarios ... ) ELSE }
            END;  { IF NOT( CAFE_TypeSimpleValorCompatible( ... ) ) }
            IF ( AnularDefaultNITI IN Interprete.DescriptorInterprete )
            THEN BEGIN
              AnidadoAnularDefault( PunteroActual,
                      BanderaAnexar1, Interprete.ParametroUno,
                      BanderaAnexar2, Interprete.ParametroDos,
                      BanderaAnexar3, Interprete.ParametroTres );
            END ELSE BEGIN  { IF ( AnularDefaultNITI IN ... ) ELSE }
              // De momento AnularDefaultNITI es obligatorio
              // en versiones futuras se permitirian otros valores Default
              GOTO SalidaReintento;
            END;            { IF ( AnularDefaultNITI IN ... ) ELSE }
          END;            { IF NOT( ActivarDefaultNITI ... ) ELSE }
        END;  {IF Interprete.TotalParametros > 0 }
SalidaVerdadera:
        PunteroActual.DatoInterpretado                  := Interprete;
        AnidadoFuncion                  := TRUE;
        IF [ SectorNITI, SilenciarSectorNITI ] <=
                         Interprete.DescriptorInterprete THEN BEGIN
          AnidadoFuncion                := AnidadoSilenciarSector;
        END;  { IF [ SectorNITI, SilenciarSectorNITI ] <=  ... }
        Exit;
SalidaReintento:
        IF OverloadNITI IN Interprete.DescriptorInterprete THEN BEGIN
          Interprete                    :=
                Interprete.BusquedaNombreIdentificador
                                ( AnidadoString2,  Interprete );
          IF Interprete <> NIL THEN GOTO CicloReintento;
        END;  { IF OverloadNITI IN Interprete.DescriptorInterprete }
        AnidadoFuncion                  := FALSE;
      END;            { IF Interprete = NIL ELSE }
    END;  { WITH MyManejador }
  END;   { FUNCTION AnidadoFuncion }
    { ANIDADO }

    { ANIDADO }
  FUNCTION AnidadoObtenerTipoParametros
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   Par1                : SizeInt;
      OUT   Par2                : SizeInt;
      OUT   Par3                : SizeInt;
            BanderaVertical     : Boolean       = TRUE          ) : Boolean;
    // Sugerencia, una mejora es usar ARRAY
  VAR
    PunteroPariente             : CAFE_NudoSintactico;
    MyString                    : ShortString;
    TipoObtenido                : Variant;
    NumeroParametro             : Byte;
    InterpretarPivote           : Boolean;

  LABEL
    SiguienteParametro;

  BEGIN  { PROCEDURE AnidadoObtenerTipoParametros }
    Par1                        := varNull;
    Par2                        := varNull;
    Par3                        := varNull;
    NumeroParametro             := 1;
    WITH MyManejador DO BEGIN
      IF BanderaVertical
      THEN PunteroPariente      := PunteroActual.DescendienteVertical
      ELSE PunteroPariente      := PunteroActual.DescendienteHorizontal;
      WHILE PunteroPariente <> NIL DO BEGIN
        WITH PunteroPariente as CAFE_Nudo2Sintactico DO BEGIN
          TipoObtenido            := DatoElemento;
          InterpretarPivote       := TRUE;
          IF CAFE_TipoVariante( TipoObtenido ) = varString THEN BEGIN
            MyString              := DatoElemento;
            IF ( MyString[ Ord( MyString[ 0 ] ) ] = ')' ) THEN BEGIN
              InterpretarPivote                     :=
                  AnidadoFuncion( MyString,
                        PunteroPariente as CAFE_Nudo2Sintactico,
                        TipoObtenido );
              IF MyString =
                 CAFE_SecuenciaRectangularHojaTraducidoOperadorBasico
              THEN BEGIN
                IF InterpretarPivote THEN BEGIN
                  CASE NumeroParametro OF
                    1   : Par1  := varArray;
                    2   : Par2  := varArray;
                    3   : Par3  := varArray;
                    ELSE BEGIN
                           AnidadoObtenerTipoParametros := FALSE;
                           Exit;
                         END;  { CASE ELSE }
                  END;  { CASE NumeroParametro }
                END ELSE BEGIN  { IF InterpretarPivote ELSE }
                  AnidadoObtenerTipoParametros          := FALSE;
                  IF CAFE_PosicionInfructuosoSintactico <> 0 THEN Exit;
                  IF Msg = '' THEN BEGIN
                    Msg       := 'Error al definir sector rectangular';
                    CAFE_PosicionInfructuosoSintactico  :=
                                CAFE_4ErrorDefinirSectorRectangular;
                    CAFE_MensajeInfructuosoSintactico   := Msg;
                    CAFE_IntentoInfructuosoSintactico   := TRUE;
                  END;  { IF Msg = '' }
                  Exit;
                END;            { IF InterpretarPivote ELSE }
                GOTO SiguienteParametro;
              END;  { IF MyString = CAFE_SecuenciaTraducidoOperadorBasico }
            END ELSE BEGIN  { IF PivoteString ... ELSE }
              InterpretarPivote                     :=
                        AnidadoIdentificador( MyString,
                        PunteroPariente as CAFE_Nudo2Sintactico,
                        TipoObtenido );
            END;            { IF PivoteString ... ELSE }
          END;  { IF TipoObtenido = varString }
          IF InterpretarPivote THEN BEGIN
            CASE NumeroParametro OF
              1         : Par1  := CAFE_TipoVariante( TipoObtenido );
              2         : Par2  := CAFE_TipoVariante( TipoObtenido );
              3         : Par3  := CAFE_TipoVariante( TipoObtenido );
              ELSE BEGIN
                     AnidadoObtenerTipoParametros         := FALSE;
                     Exit;
                   END;  { CASE ELSE }
            END;  { CASE NumeroParametro }
          END ELSE BEGIN  { IF InterpretarPivote ELSE }
            IF ( Msg = '' ) AND
               ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
              CAFE_PosicionInfructuosoSintactico        :=
                                        CAFE_4ErrorParametrosSubOrden;
              Msg                       := MyString;
              CAFE_MensajeInfructuosoSintactico         := Msg;
              CAFE_IntentoInfructuosoSintactico         := TRUE;
            END;  { IF CAFE_PosicionInfructuosoSintactico }
            AnidadoObtenerTipoParametros                  := FALSE;
            Exit;
          END;            { IF InterpretarPivote ELSE }
SiguienteParametro :
          Inc( NumeroParametro );
          PunteroPariente           :=
            PunteroPariente.DescendienteHorizontal as CAFE_Nudo2Sintactico;
        END;  { WITH PunteroPariente as CAFE_Nudo2Sintactico }
      END;  { WHILE PunteroPariente <> NIL }
    END;  { WITH MyManejador }
    AnidadoObtenerTipoParametros                := TRUE;
  END;   { PROCEDURE AnidadoObtenerTipoParametros }
    { ANIDADO }

BEGIN  { FUNCTION CAFE_Nudo2Sintactico.InterpretarMacroFuncion }
  Msg                         := '';
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
  WITH MyManejador DO BEGIN
    IF CAFE_TipoVariante( DatoElemento ) = varString THEN BEGIN
      PivoteString                      := DatoElemento;
      IF ( PivoteString[ Ord( PivoteString[ 0 ] ) ] = ')' ) THEN BEGIN
        SubRegistro             := FALSE;
        InterpretarMacroFuncion                 :=
          AnidadoFuncion( PivoteString, Self, FuncionReturn );
      END ELSE BEGIN  { IF PivoteString ... ELSE }
        InterpretarMacroFuncion                 :=
          AnidadoIdentificador( PivoteString, Self, FuncionReturn );
      END;            { IF PivoteString ... ELSE }
    END ELSE BEGIN  { IF CAFE_TipoVariante( DatoElemento ) = varString ELSE }
      FuncionReturn                             := DatoElemento;
      InterpretarMacroFuncion                   := TRUE;
    END;            { IF CAFE_TipoVariante( DatoElemento ) = varString ELSE }
  END;  { WITH MyManejador }
END;   { FUNCTION CAFE_Nudo2Sintactico.InterpretarMacroFuncion }

FUNCTION    CAFE_Nudo2Sintactico.InterpretarMacro
  (       Manejador             : CAFE_InterfaceBasico;
    OUT   Msg                   : ShortString;
    CONST NomParam1             : ShortString;
    CONST NomParam2             : ShortString   = '';
    CONST NomParam3             : ShortString   = ''            ) : Boolean;
VAR
  PivoteReal                    : Variant;

BEGIN  { FUNCTION CAFE_Nudo2Sintactico.InterpretarMacro }
  IF InterpretarMacroFuncion( Manejador, PivoteReal, Msg,
                NomParam1, NomParam2, NomParam3 ) THEN BEGIN
    IF ImplementationOverloadTypeSimpleValorCompatible
                ( varDouble, CAFE_TipoVariante( PivoteReal ) )
    THEN BEGIN
      InterpretarMacro          := TRUE;
    END ELSE BEGIN  { IF CAFE_TipoVariante( PivoteReal ) = varDouble ELSE }
      InterpretarMacro          := FALSE;
      IF CAFE_PosicionInfructuosoSintactico <> 0 THEN Exit;
      IF Msg = '' THEN BEGIN
        Msg      := 'Unicamente se reconocen macros reales';
        CAFE_PosicionInfructuosoSintactico      :=
                CAFE_4ErrorMacroRecibeArgumentosReales;
        CAFE_MensajeInfructuosoSintactico       := Msg;
        CAFE_IntentoInfructuosoSintactico       := TRUE;
      END;  { IF Msg = '' }
      InterpretarMacro          := FALSE;
    END;            { IF CAFE_TipoVariante( PivoteReal ) = varDouble ELSE }
  END ELSE BEGIN  { IF InterpretarMacroFuncion... ELSE }
    InterpretarMacro            := FALSE;
  END;            { IF InterpretarMacroFuncion... ELSE }
END;   { FUNCTION CAFE_Nudo2Sintactico.InterpretarMacro }

FUNCTION    CAFE_Nudo2Sintactico.InterpretarFuncion
  (       Manejador             : CAFE_InterfaceBasico;
    OUT   FuncionReturn         : Variant;
    OUT   Msg                   : ShortString                   ) : Boolean;
{ virtual; }
BEGIN  { FUNCTION CAFE_Nudo2Sintactico.InterpretarFuncion }
  InterpretarFuncion            :=
                InterpretarMacroFuncion( Manejador, FuncionReturn, Msg );
END;   { FUNCTION CAFE_Nudo2Sintactico.InterpretarFuncion }

FUNCTION    CAFE_Nudo2Sintactico.EvaluarFuncion
  ( OUT   VariantFuncion        : Variant;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          CicloSintactico       : LongInt       = 0             ) : Boolean;

BEGIN  { FUNCTION CAFE_Nudo2Sintactico.EvaluarFuncion }
  EvaluarFuncion                :=
        EvaluarMacroFuncion( VariantFuncion, Msg, Manejador,
                        0, 0.0, 0.0, 0.0, CicloSintactico );
END;   { FUNCTION CAFE_Nudo2Sintactico.EvaluarFuncion }

FUNCTION    CAFE_Nudo2Sintactico.ReescribirEnCopiaCasilla
  (       Fila, Columna         : LongInt;
          NuevaFila, NuevaColumna               : LongInt;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
    CONST FuncionLiteral        : ShortString;
    OUT   CopiaLiteral          : ShortString;
          FilaProtegida         : LongInt       = 0;
          ColumnaProtegida      : LongInt       = 0;
          DolarValido           : Boolean       = TRUE;
          BanderaSuperposicion  : Boolean       = FALSE         ) : Boolean;
{ virtual; }
VAR
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  Sustituto                     : ShortString;

    { ANIDADO }
  FUNCTION AnidadoReescribir
    (       PunteroActual       : CAFE_Nudo2Sintactico;
            CicloMascara        : Boolean                       ) : Boolean;
  VAR
    Original,
    Sustituto                   : ShortString;
    FilaActual,
    ColumnaActual               : LongInt;
    BanderaFilaFija,
    BanderaColumnaFija          : Boolean;

  LABEL
    SalidaVerdadera,
    SalidaFalsa;

  BEGIN  { FUNCTION AnidadoReescribir }
    IF PunteroActual = NIL THEN BEGIN
      AnidadoReescribir         := TRUE;
      Exit;
    END;  { IF PunteroActual = NIL }
    IF PunteroActual.DatoInterpretado = NIL THEN GOTO SalidaVerdadera;
    IF PunteroActual.DescendienteVertical = NIL THEN BEGIN
      WITH ( PunteroActual.DatoInterpretado as CAFE_Interprete2Sintactico )
      DO BEGIN
        IF ( [ ActivoNITI, CasillaHojaNITI, HojaDefaultNITI ] <=
                         DescriptorInterprete ) THEN BEGIN
          FilaActual            := ValorInterpretado[ 1 ];
          ColumnaActual         := ValorInterpretado[ 2 ];
          BanderaFilaFija       :=
            ( AbsolutoFilaNITI IN DescriptorInterprete ) AND DolarValido
                        OR ( FilaActual < FilaProtegida );
          BanderaColumnaFija    :=
            ( AbsolutoColumnaNITI IN DescriptorInterprete ) AND DolarValido
                        OR ( ColumnaActual < ColumnaProtegida );
          IF NOT( BanderaFilaFija )
          THEN FilaActual
               +=       ( NuevaFila-Fila );
          IF NOT( BanderaColumnaFija )
          THEN ColumnaActual
               +=       ( NuevaColumna-Columna );
          IF NOT( InRange( FilaActual, 0,
                        Pred( MyManejador.HojaDefault.FilasEnHoja ) ) ) OR
             NOT( InRange( ColumnaActual, 0,
                        Pred( MyManejador.HojaDefault.ColumnasEnHoja ) ) )
          THEN BEGIN  { IF NOT( InRange... ) }
            Msg                 := NombreIdentificador;
            CAFE_PosicionInfructuosoSintactico  :=
                        CAFE_4ErrorCopiaProvocaRangoNoPermitido;
            CAFE_MensajeInfructuosoSintactico   := Msg;
            CAFE_IntentoInfructuosoSintactico   := TRUE;
            GOTO SalidaFalsa;
          END;        { IF NOT( InRange... ) }
          GenerarNombreCasillaHoja( Sustituto,
                AbsolutoColumnaNITI IN DescriptorInterprete, ColumnaActual,
                AbsolutoFilaNITI IN DescriptorInterprete, FilaActual );
          IF CicloMascara THEN BEGIN
            CASE Sustituto[ Length( Sustituto ) ] OF
              '0'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible0;
              '1'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible1;
              '2'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible2;
              '3'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible3;
              '4'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible4;
              '5'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible5;
              '6'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible6;
              '7'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible7;
              '8'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible8;
              '9'       : Sustituto[ Length( Sustituto ) ]      :=
                                                  CAFE_CharImposible9;
            END;  { CASE Sustituto[ Length( Sustituto ) ] }
            ImplementationSintactico.
                BuscarSustituirIdentificadorDobleEnmascarado
                ( MyManejador.GramaticaCharByte,
                        NombreIdentificador, Sustituto );
          END ELSE BEGIN  { IF CicloMascara ELSE }
            Original            := Sustituto;
            CASE Sustituto[ Length( Sustituto ) ] OF
              '0'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible0;
              '1'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible1;
              '2'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible2;
              '3'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible3;
              '4'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible4;
              '5'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible5;
              '6'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible6;
              '7'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible7;
              '8'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible8;
              '9'       : Original[ Length( Sustituto ) ]       :=
                                                  CAFE_CharImposible9;
            END;  { CASE Sustituto[ Length( Sustituto ) ] }
            ImplementationSintactico.
                BuscarSustituirIdentificadorDobleEnmascarado
                ( MyManejador.GramaticaCharByte, Original, Sustituto );
          END;            { IF CicloMascara ELSE }
          IF CAFE_IntentoInfructuosoSintactico
          THEN GOTO SalidaFalsa;
        END;  { IF [ ActivoNITI, CasillaHojaNITI, HojaDefaultNITI ] }
      END;  { WITH ( ...DatoInterpretado as CAFE_Interprete2Sintactico ) }
    END; { IF DescendienteVertical = NIL }
SalidaVerdadera :
    IF AnidadoReescribir
         ( PunteroActual.DescendienteHorizontal as
                        CAFE_Nudo2Sintactico, CicloMascara )
    THEN BEGIN
      IF NOT( AnidadoReescribir
            ( PunteroActual.DescendienteVertical as
                        CAFE_Nudo2Sintactico, CicloMascara ) )
      THEN GOTO SalidaFalsa;
    END ELSE BEGIN  { IF AnidadoReescribir( ...DescendienteHorizontal ) ELSE }
      GOTO SalidaFalsa;
    END;            { IF AnidadoReescribir( ...DescendienteHorizontal ) ELSE }
    AnidadoReescribir           := TRUE;
    Exit;
SalidaFalsa :
    AnidadoReescribir           := FALSE;
  END;   { FUNCTION AnidadoReescribir }
    { ANIDADO }

BEGIN  { FUNCTION CAFE_Nudo2Sintactico.ReescribirEnCopiaCasilla }
  Msg                           := '';
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
  DolarValido                   :=
        ( FilaProtegida <= 0 ) AND ( ColumnaProtegida <= 0 ) AND DolarValido;
  WITH MyManejador DO BEGIN
    GramaticaCharByte.InsertarString( FuncionLiteral );
    IF ( NuevaFila <> Fila ) AND BanderaSuperposicion THEN BEGIN
      Str( ABS( NuevaFila-Fila ), Sustituto );
      IF NuevaFila >= Fila
      THEN Sustituto                            :=
                '('+CAFE_StringFijarEnColumna+'+'+Sustituto+')'
      ELSE Sustituto                            :=
                '('+CAFE_StringFijarEnColumna+'-'+Sustituto+')';
      ImplementationSintactico.BuscarSustituirIdentificadorDobleEnmascarado
        ( GramaticaCharByte, CAFE_StringFijarEnColumna, Sustituto );
    END;  { IF ( NuevaColumna <> Columna ) }
    IF ( NuevaColumna <> Columna ) AND BanderaSuperposicion
    THEN BEGIN
      Str( ABS( NuevaColumna-Columna ), Sustituto );
      IF NuevaColumna >= Columna
      THEN Sustituto                            :=
                '('+CAFE_StringFijarEnFila+'+'+Sustituto+')'
      ELSE Sustituto                            :=
                '('+CAFE_StringFijarEnFila+'-'+Sustituto+')';
      ImplementationSintactico.BuscarSustituirIdentificadorDobleEnmascarado
        ( GramaticaCharByte, CAFE_StringFijarEnFila, Sustituto );
    END;  { IF ( NuevaColumna <> Columna ) }
    IF HojaDefault <> NIL THEN BEGIN
      IF NOT( AnidadoReescribir( Self, TRUE  ) )
      THEN BEGIN
        ReescribirEnCopiaCasilla        := FALSE;
        Exit;
      END;  { IF NOT( AnidadoReescribir( Self ) ) }
      IF NOT( AnidadoReescribir( Self, FALSE ) )
      THEN BEGIN
        ReescribirEnCopiaCasilla        := FALSE;
        Exit;
      END;  { IF NOT( AnidadoReescribir( Self ) ) }
    END;  { IF HojaDefault <> NIL }
    ReescribirEnCopiaCasilla            := TRUE;
    CopiaLiteral                        :=
                GramaticaCharByte.ExtraerString;
  END;  { WITH MyManejador }
END;   { FUNCTION CAFE_Nudo2Sintactico.ReescribirEnCopiaCasilla }

  { IMPLEMENTATION }
CONST
  FactorP0IntegralOctavoImpar           = -3632/2835;  //-1.281128748
                { Integral( -4, 4, (16-x2)(9-x2)(4-x2)(1-x2)/(4!4!) ) }
  FactorP1IntegralOctavoImpar           = 41984/14175; //2.961834215;
                { Integral( -4, 4, (16-x2)(9-x2)(4-x2)(1+x)x/(5!3!) ) }
  FactorP2IntegralOctavoImpar           = -3712/14175; // -0.2618694885;
                { Integral( -4, 4, (16-x2)(9-x2)(2+x)x(x2-1)/(6!2!) ) }
  FactorP3IntegralOctavoImpar           = 23552/14175; // 1.661516755;
                { Integral( -4, 4, (16-x2)(3+x)x(x2-4)(x2-1)/(7!1!) ) }
  FactorP4IntegralOctavoImpar           = 3956/14175;  //0.2790828924;
                { Integral( -4, 4, (4+x)x(x2-9)(x2-4)(x2-1)/(8!0!)  ) }
  { IMPLEMENTATION }

  { IMPLEMENTATION }
FUNCTION  ImplementationSolveBusqueda
  ( OUT   ResultadoRaiz           : Double;
    VAR   X1  , X2                : Double;
          Func                    : CAFE_FuncionUnSingle;
          PunteroParametros       : Pointer;
          TotalSectores           : LongInt;
          SelectorBusqueda        : Byte                        ) : Boolean;
    // 1 Raiz 2 Mayor 3 Menor
VAR
  ValorRecorre,
  PosicionRecorre,
  ValorOptimo,
  PosicionOptimo,
  DeltaBusqueda                 : Double;
  I                             : LongInt;

BEGIN  { FUNCTION ImplementationSolveBusqueda }
  IF X1 > X2 THEN BEGIN
    PosicionRecorre             := X1;
    X1                          := X2;
    X2                          := PosicionRecorre;
  END;  { IF X1 > X2 }
  DeltaBusqueda                 := ( X2-X1 )/TotalSectores;
  PosicionOptimo                := X1+DeltaBusqueda/2;
  TRY
    ValorOptimo                 := Func( PosicionOptimo, PunteroParametros );
  EXCEPT
    ON Exception DO BEGIN
      ImplementationSolveBusqueda               := FALSE;
      ResultadoRaiz             := 0.0;
      Exit;
    END;  { ON Exception }
  END;  { TRY }
  PosicionRecorre               := PosicionOptimo;
  FOR I := 1 TO TotalSectores DO BEGIN
    TRY
      ValorRecorre              := Func( PosicionRecorre, PunteroParametros );
    EXCEPT
      ON Exception DO BEGIN
        ImplementationSolveBusqueda             := FALSE;
        ResultadoRaiz           := 0.0;
        Exit;
      END;  { ON Exception }
    END;  { TRY }
    CASE SelectorBusqueda OF
      1  : IF ABS( ValorRecorre ) < ABS( ValorOptimo ) THEN BEGIN
             ValorOptimo        := ValorRecorre;
             PosicionOptimo     := PosicionRecorre;
           END;  { CASE 1 }
      2  : IF ValorRecorre > ValorOptimo THEN BEGIN
             ValorOptimo        := ValorRecorre;
             PosicionOptimo     := PosicionRecorre;
           END;  { CASE 2 }
      3  : IF ValorRecorre < ValorOptimo THEN BEGIN
             ValorOptimo        := ValorRecorre;
             PosicionOptimo     := PosicionRecorre;
           END;  { CASE 3 }
    END;  { CASE SelectorBusqueda }
    PosicionRecorre
    +=      DeltaBusqueda;
  END;  { FOR I }
  ResultadoRaiz                 := PosicionOptimo;
  X1                            :=
                       Max( PosicionOptimo-DeltaBusqueda, X1 );
  X2                            :=
                       Min( PosicionOptimo+DeltaBusqueda, X2 );
  ImplementationSolveBusqueda   := TRUE;
END;   { FUNCTION ImplementationSolveBusqueda }
  { IMPLEMENTATION }

FUNCTION  CAFE_SolvePuntoMedioZonaNula
  ( OUT ResultadoFuncion        : Double;
        X1, X2                  : Double;
        Func                    : CAFE_FuncionUnSingle;
        PunteroParametros       : Pointer;
        ToleranciaPermitida     : Double                        ) : Boolean;
VAR
  Inf,
  FInf,
  Sup,
  FSup,
  Med,
  FMed                          : Double;
  SInf,
  SSup,
  SMed,
  CicloContador,
  NumeroCiclosObjetivo          : LongInt;

    { ANIDADO }
  PROCEDURE AnidadoColocaInf;
  BEGIN  { PROCEDURE AnidadoColocaInf }
    Inf                         := Med;
    FInf                        := FMed;
    SInf                        := SMed;
  END;   { PROCEDURE AnidadoColocaInf }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoColocaSup;
  BEGIN  { PROCEDURE AnidadoColocaSup }
    Sup                         := Med;
    FSup                        := FMed;
    SSup                        := SMed;
  END;   { PROCEDURE AnidadoColocaSup }
    { ANIDADO }

BEGIN  { FUNCTION CAFE_SolvePuntoMedioZonaNula }
  ToleranciaPermitida           := ABS( ToleranciaPermitida );
  IF ( ABS( X1-X2 ) < ToleranciaPermitida ) OR ( ToleranciaPermitida = 0 )
  THEN BEGIN
    ResultadoFuncion                    := ( X1+X2 )/2;
    CAFE_SolvePuntoMedioZonaNula        := TRUE;
    Exit;
  END;  { IF ( ABS( X1-X2 ) < ToleranciaPermitida ) OR ... }
  IF CAFE_PreliminarSolveFuncional <> 0 THEN BEGIN
    IF NOT( ImplementationSolveBusqueda( ResultadoFuncion, X1, X2, Func,
                  PunteroParametros, CAFE_PreliminarSolveFuncional, 1 ) )
    THEN BEGIN
      ResultadoFuncion                    := 0.0;
      CAFE_SolvePuntoMedioZonaNula        := FALSE;
      Exit;
    END;  { IF NOT( ImplementationSolveBusqueda... ) }
  END;  { IF CAFE_PreliminarSolveFuncional <> 0 }
  Inf                           := X1;
  TRY
    FInf                        := Func( X1, PunteroParametros );
  EXCEPT
    ON Exception DO BEGIN
      CAFE_SolvePuntoMedioZonaNula      := FALSE;
      ResultadoFuncion          := 0.0;
      Exit;
    END;  { ON Exception }
  END;  { TRY }
  SInf                          := Sign( FInf );
  Sup                           := X2;
  TRY
    FSup                        := Func( X2, PunteroParametros );
  EXCEPT
    ON Exception DO BEGIN
      CAFE_SolvePuntoMedioZonaNula              := FALSE;
      ResultadoFuncion          := 0.0;
      Exit;
    END;  { ON Exception }
  END;  { TRY }
  SSup                          := Sign( FSup );
  NumeroCiclosObjetivo          :=
        Trunc( ABS( Ln( ABS( X2-X1 )/ToleranciaPermitida )/Ln( 2 ) ) )+1;
  IF NumeroCiclosObjetivo > CAFE_MaximoCiclosFuncionalSolve
  THEN NumeroCiclosObjetivo := CAFE_MaximoCiclosFuncionalSolve;
  FOR CicloContador := 1 TO NumeroCiclosObjetivo DO BEGIN
    Med                         := ( Inf+Sup )/2;
    TRY
      FMed                      := Func( Med, PunteroParametros );
    EXCEPT
      ON Exception DO BEGIN
        CAFE_SolvePuntoMedioZonaNula            := FALSE;
        ResultadoFuncion        := 0.0;
        Exit;
      END;  { ON Exception }
    END;  { TRY }
    SMed                        := Sign( FMed );
    IF SInf = SSup THEN BEGIN
      AnidadoColocaInf;
    END ELSE BEGIN  { IF SInf = SSup ELSE }
      IF SInf = 0 THEN BEGIN
        IF SMed = 0 THEN AnidadoColocaInf
                        ELSE AnidadoColocaSup;
      END ELSE BEGIN  { IF SInf = 0 ELSE }
        IF SSup = 0 THEN BEGIN
          IF SMed = 0 THEN AnidadoColocaSup
                        ELSE AnidadoColocaInf;
        END ELSE BEGIN  { IF SSup = 0 ELSE }
          IF SMed = 0 THEN BEGIN
            AnidadoColocaInf;
          END ELSE BEGIN  { IF SMed = 0 ELSE }
            IF SInf = SMed THEN AnidadoColocaInf
                                ELSE AnidadoColocaSup;
          END;            { IF SMed = 0 ELSE }
        END;            { IF SSup = 0 ELSE }
      END;            { IF SInf = 0 ELSE }
    END;            { IF SInf = SSup ELSE }
  END;  { FOR CicloContador }
  CAFE_SolvePuntoMedioZonaNula  := TRUE;
  ResultadoFuncion              := ( Sup+Inf )/2;
END;   { FUNCTION CAFE_SolvePuntoMedioZonaNula }

FUNCTION    CAFE_IntegralOctavoImpar
  ( OUT   ResultadoFuncion      : Double;
          X1  , X2              : Double;
          Func                  : CAFE_FuncionUnSingle;
          PunteroParametros     : Pointer;
          DiferenciaConsecutiva : Double;
          Manejador             : CAFE_InterfaceManejador       = NIL   )
                                                                : Boolean;
VAR
  FactorL,
  Desplazado,
  Intervalo,
  AnteriorEstimacion,
  NuevaEstimacion,
  Suma0,
  Suma1,
  Suma2,
  Suma3,
  Suma4,
  DiferenciaEstimacion,
  BaseRepite                    : Double;
  K,
  CicloOctavo,
  CuentaCiclo                   : LongInt;

LABEL
  SalidaFalsa;

    { ANIDADO }
  FUNCTION      AnidadoRepite ( VAR ValorRepite : Double        ) : Boolean;
  BEGIN  { PROCEDURE AnidadoRepite }
    TRY
      BaseRepite                  := BaseRepite+Desplazado;
      ValorRepite                 := ValorRepite+
                Func( BaseRepite, PunteroParametros );
      AnidadoRepite               := TRUE;
    EXCEPT
      ON Exception DO BEGIN
        ResultadoFuncion          := 0;
        AnidadoRepite             := FALSE;
        CAFE_IntegralOctavoImpar  := FALSE;
        Exit;
      END;  { ON Exception }
    END;  { TRY }
  END;   { PROCEDURE AnidadoRepite }
    { ANIDADO }

BEGIN  { FUNCTION CAFE_IntegralOctavoImpar }
  FactorL                       := X2-X1;
  IF DiferenciaConsecutiva <= 0 THEN GOTO SalidaFalsa;
  TRY
    Suma0                       :=
        Func( ( X1+X2 )/2, PunteroParametros );
  EXCEPT
    ON Exception DO BEGIN
      CAFE_IntegralOctavoImpar  := FALSE;
      ResultadoFuncion          := 0.0;
      Exit;
    END;  { ON Exception }
  END;  { TRY }
  TRY
    Suma2                       :=
        Func( ( 3*X1+X2 )/4, PunteroParametros );
  EXCEPT
    ON Exception DO BEGIN
      CAFE_IntegralOctavoImpar  := FALSE;
      ResultadoFuncion          := 0.0;
      Exit;
    END;  { ON Exception }
  END;  { TRY }
  TRY
    Suma2                       := Suma2+
        Func( ( X1+3*X2 )/4, PunteroParametros );
  EXCEPT
    ON Exception DO BEGIN
      CAFE_IntegralOctavoImpar  := FALSE;
      ResultadoFuncion          := 0.0;
      Exit;
    END;  { ON Exception }
  END;  { TRY }
  TRY
    Suma4                       :=
        Func( X1, PunteroParametros );
  EXCEPT
    ON Exception DO BEGIN
      CAFE_IntegralOctavoImpar  := FALSE;
      ResultadoFuncion          := 0.0;
      Exit;
    END;  { ON Exception }
  END;  { TRY }
  TRY
    Suma4                       := Suma4+
        Func( X2, PunteroParametros );
  EXCEPT
    ON Exception DO BEGIN
      CAFE_IntegralOctavoImpar  := FALSE;
      ResultadoFuncion          := 0.0;
      Exit;
    END;  { ON Exception }
  END;  { TRY }
  NuevaEstimacion               := ( 12*Suma0+32*Suma2+7*Suma4 )*FactorL/90;
  AnteriorEstimacion            := ( Suma4+4*Suma0 )*FactorL/6;
  K                             := 1;
  DiferenciaEstimacion          := ABS( NuevaEstimacion-AnteriorEstimacion );
  Desplazado                    := FactorL/4;
  Intervalo                     := FactorL/8;
  CicloOctavo                   := 1;
  IF Manejador = NIL
  THEN Manejador                := ImplementationManejador;
  WHILE ( ( DiferenciaEstimacion > DiferenciaConsecutiva ) AND
                ( K < Manejador.
                        ValorMaximaIteracionIntegralOctavoImparFuncion ) )
  DO BEGIN
    BaseRepite                  := X1-Intervalo;
    Suma1                       := 0;
    Suma3                       := 0;
    FOR CuentaCiclo := 1 TO CicloOctavo DO BEGIN
      IF NOT( AnidadoRepite( Suma3 ) ) THEN GOTO SalidaFalsa;
      IF NOT( AnidadoRepite( Suma1 ) ) THEN GOTO SalidaFalsa;
      IF NOT( AnidadoRepite( Suma1 ) ) THEN GOTO SalidaFalsa;
      IF NOT( AnidadoRepite( Suma3 ) ) THEN GOTO SalidaFalsa;
    END;  { FOR CuentaCiclo }
    AnteriorEstimacion          := NuevaEstimacion;
    NuevaEstimacion             :=
        Intervalo*( FactorP0IntegralOctavoImpar*Suma0+
                FactorP1IntegralOctavoImpar*Suma1+
                FactorP2IntegralOctavoImpar*Suma2+
                FactorP3IntegralOctavoImpar*Suma3+
                FactorP4IntegralOctavoImpar*Suma4 );
    DiferenciaEstimacion        := ABS( NuevaEstimacion-AnteriorEstimacion );
    Desplazado                  := Desplazado/2;
    Intervalo                   := Intervalo/2;
    Suma4                       := 2*Suma0+Suma4;
    Suma0                       := Suma2;
    Suma2                       := Suma1+Suma3;
    Inc( K );
    CicloOctavo                 := 2*CicloOctavo;
  END;  { ( ( DiferenciaEstimacion > DiferenciaConsecutiva ) AND ... ) }
  DiferenciaConsecutiva         := DiferenciaEstimacion;
  ResultadoFuncion              := NuevaEstimacion;
  CAFE_IntegralOctavoImpar      := TRUE;
  Exit;
SalidaFalsa :
  ResultadoFuncion              := 0.0;
  CAFE_IntegralOctavoImpar      := FALSE;
END;   { FUNCTION CAFE_IntegralOctavoImpar }


FUNCTION    CAFE_Nudo2Sintactico.EvaluarMacroFuncion
  ( OUT   ResultMacro           : Variant;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          TotalParMacro         : LongInt       = 0;
          Param1                : Double        = 0.0;
          Param2                : Double        = 0.0;
          Param3                : Double        = 0.0;
          CicloSintactico       : LongInt       = 0;
          ForParam1             : Double        = 0.0;
          ForParam2             : Double        = 0.0;
          ForParam3             : Double        = 0.0           ) : Boolean;
VAR
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  FactorRedondeo                : Double;

    { ANIDADO }
  FUNCTION AnidadoCompatible
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   ResultadoAnidado    : Variant;
            TipoSolicitado      : SizeInt       = varNull       ) : Boolean;
                                forward;
    { ANIDADO }

    { ANIDADO }
  FUNCTION AnidadoParametroSimple
    (       PunteroActual       : CAFE_Nudo2Sintactico;
            PideParametros      : Byte;
      OUT   Resultado1          : Variant;
            TipoSolicitado1     : SizeInt;
      OUT   Resultado2          : Variant;
            TipoSolicitado2     : SizeInt;
      OUT   Resultado3          : Variant;
            TipoSolicitado3     : SizeInt;
            BanderaVertical     : Boolean       = TRUE          ) : Boolean;
  VAR
    PunteroMovil                : CAFE_Nudo2Sintactico;
    RecorreParametro            : Byte;

  LABEL
    SalidaFalsa;

  BEGIN  { FUNCTION AnidadoParametroSimple }
    IF BanderaVertical
    THEN PunteroMovil           :=
                PunteroActual.DescendienteVertical as CAFE_Nudo2Sintactico
    ELSE PunteroMovil           :=
                PunteroActual.DescendienteHorizontal as CAFE_Nudo2Sintactico;
    FOR RecorreParametro := 1 TO PideParametros DO BEGIN
      IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
      CASE RecorreParametro OF
        1               : IF NOT( AnidadoCompatible
                                ( PunteroMovil, Resultado1, TipoSolicitado1 ) )
                          THEN GOTO SalidaFalsa;
        2               : IF NOT( AnidadoCompatible
                                ( PunteroMovil, Resultado2, TipoSolicitado2 ) )
                          THEN GOTO SalidaFalsa;
        3               : IF NOT( AnidadoCompatible
                                ( PunteroMovil, Resultado3, TipoSolicitado3 ) )
                          THEN GOTO SalidaFalsa;
        ELSE GOTO SalidaFalsa;
      END;  { CASE RecorreParametro }
      PunteroMovil              :=
                PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
    END;  { FOR RecorreParametro }
    AnidadoParametroSimple      := PunteroMovil = NIL;
    Exit;
SalidaFalsa:
    AnidadoParametroSimple      := FALSE;
    IF ( Msg = '' ) AND ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
      CAFE_PosicionInfructuosoSintactico        :=
                                CAFE_4ErrorParametrosSubOrden;
      Msg                       := PunteroActual.DatoElemento;
      CAFE_MensajeInfructuosoSintactico         := Msg;
      CAFE_IntentoInfructuosoSintactico         := TRUE;
    END;  { IF CAFE_PosicionInfructuosoSintactico }
  END;   { FUNCTION AnidadoParametroSimple }
    { ANIDADO }

    { ANIDADO }
  FUNCTION AnidadoParametroIF
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   Resultado1          : Variant;
            TipoSolicitado1     : SizeInt;
      OUT   Resultado2          : Variant;
            TipoSolicitado2     : SizeInt;
      OUT   Resultado3          : Variant;
            TipoSolicitado3     : SizeInt;
            ClaveIf             : LongInt                       ) : Boolean;
  VAR
    PunteroMovil                : CAFE_Nudo2Sintactico;

  LABEL
    SalidaFalsa;

  BEGIN  { FUNCTION AnidadoParametroIF }
    PunteroMovil                :=
                PunteroActual.DescendienteVertical as CAFE_Nudo2Sintactico;
    IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
    IF NOT( AnidadoCompatible( PunteroMovil, Resultado1, TipoSolicitado1 ) )
    THEN GOTO SalidaFalsa;
    PunteroMovil                :=
                PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
    IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
    IF Resultado1 THEN BEGIN
      IF NOT( AnidadoCompatible( PunteroMovil, Resultado2, TipoSolicitado2 ) )
                          THEN GOTO SalidaFalsa;
      PunteroMovil              :=
                PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
      IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
    END ELSE BEGIN  { IF Resultado1 ELSE }
      PunteroMovil              :=
                PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
      IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
      IF NOT( AnidadoCompatible( PunteroMovil, Resultado3, TipoSolicitado3 ) )
                          THEN GOTO SalidaFalsa;
      IF ClaveIf = ClaveIfDominioDouble THEN BEGIN
        IF MyManejador.HojaDefault <> NIL
        THEN Include
             ( MyManejador.HojaDefault.DescriptoresHoja, AlertaDominioCVDH );
      END;  { IF ClaveIf = ClaveIfDominioDouble }
    END;            { IF Resultado1 ELSE }
    PunteroMovil                :=
                PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
    AnidadoParametroIF          := PunteroMovil = NIL;
    Exit;
SalidaFalsa:
    AnidadoParametroIF          := FALSE;
    IF ( Msg = '' ) AND ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
      CAFE_PosicionInfructuosoSintactico        :=
                                CAFE_4ErrorParametrosSubOrden;
      Msg                       := PunteroActual.DatoElemento;
      CAFE_MensajeInfructuosoSintactico         := Msg;
      CAFE_IntentoInfructuosoSintactico         := TRUE;
    END;  { IF CAFE_PosicionInfructuosoSintactico }
  END;   { FUNCTION AnidadoParametroIF }
    { ANIDADO }

    { ANIDADO }
  FUNCTION AnidadoFuncionalSimple
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   ResultadoAnidado    : Variant;
            TipoSolicitado      : SizeInt       = varNull       ) : Boolean;
  VAR
    ValorUno,
    ValorDos,
    ValorTres                   : Variant;

  LABEL
    SalidaFalsa;

  BEGIN  { FUNCTION AnidadoFuncionalSimple }
    WITH ( PunteroActual.DatoInterpretado as CAFE_Interprete2Sintactico )
    DO BEGIN
      IF NOT( PredefinidoNITI IN DescriptorInterprete ) THEN GOTO SalidaFalsa;
      // Esperamos mayor versalitilidad en el futuro
      // Aun asi la hoja de calculo brinda bastantes opciones...
      IF ClaveInterpretado IN
                [ ClaveIfThenDouble, ClaveIfDominioDouble, ClaveIfThenInteger,
            ClaveIfThenBoolean, ClaveIfThenString, ClaveIfThenByte ]
      THEN BEGIN
        IF NOT( AnidadoParametroIf
              ( PunteroActual, ValorUno, ParametroUno,
                ValorDos, ParametroDos, ValorTres, ParametroTres,
                ClaveInterpretado ) )
        THEN GOTO SalidaFalsa;
      END ELSE BEGIN  { IF ClaveInterpretado IN ... ELSE }
        IF NOT( AnidadoParametroSimple
            ( PunteroActual, TotalParametros, ValorUno, ParametroUno,
              ValorDos, ParametroDos, ValorTres, ParametroTres ) )
        THEN GOTO SalidaFalsa;
      END;            { IF ClaveInterpretado IN ... ELSE }
      IF NOT( EvaluarPredefinidoFuncionalSimple
        ( Msg, ResultadoAnidado, ValorUno, ValorDos, ValorTres,
                                MyManejador, CicloSintactico ) )
      THEN GOTO SalidaFalsa;
    END;  { WITH PunteroActual.DatoInterpretado as ... }
    AnidadoFuncionalSimple      := CAFE_TypeSimpleValorCompatible
        ( TipoSolicitado, CAFE_TipoVariante( ResultadoAnidado ) );
    Exit;
SalidaFalsa:
    AnidadoFuncionalSimple      := FALSE;
    IF CAFE_PosicionInfructuosoSintactico <> 0 THEN Exit;
    IF Msg = '' THEN BEGIN
      CAFE_PosicionInfructuosoSintactico   := CAFE_4ErrorAlEvaluarEnLugar;
      Msg                                  := PunteroActual.DatoElemento;
      CAFE_IntentoInfructuosoSintactico    := TRUE;
      CAFE_MensajeInfructuosoSintactico    := Msg;
    END;  { IF Msg = '' }
  END;   { FUNCTION AnidadoFuncionalSimple }
    { ANIDADO }

    { ANIDADO }
  FUNCTION AnidadoCasillaHojaSimple
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   ResultadoAnidado    : Variant;
            TipoSolicitado      : SizeInt       = varNull       ) : Boolean;
  VAR
    CaracterMacro               : CAFE_ConjuntoParametroBasico;
    Resultado1,
    Resultado2,
    Resultado3                  : Variant;
    PivoteReal                  : Double;
    Fila,
    Columna                     : LongInt;
    ParametrosEnMacro           : Byte;
    BanderaNudillado,
    BanderaMacro                : Boolean;

  LABEL
    SalidaFalsa;

  BEGIN  { FUNCTION AnidadoCasillaHojaSimple }
    IF MyManejador.HojaDefault = NIL THEN GOTO SalidaFalsa;
    WITH ( PunteroActual.DatoInterpretado as CAFE_Interprete2Sintactico )
    DO BEGIN
      IF NOT( HojaDefaultNITI IN DescriptorInterprete ) THEN GOTO SalidaFalsa;
      // Esperamos en el futuro manejo a multiples hojas
      Fila                      := ValorInterpretado[ 1 ];
      Columna                   := ValorInterpretado[ 2 ];
      IF NOT( InRange( Fila, 0, Pred( MyManejador.HojaDefault.FilasEnHoja ) )
      AND ( InRange( Columna, 0,
                Pred( MyManejador.HojaDefault.ColumnasEnHoja ) ) ) )
      THEN GOTO SalidaFalsa;
      MyManejador.HojaDefault.LecturaTipo
               ( Fila, Columna, BanderaNudillado,
                        BanderaMacro, CaracterMacro );
      IF BanderaMacro THEN BEGIN
        ParametrosEnMacro       := 1;
        IF Real2DHCGM IN CaracterMacro THEN ParametrosEnMacro   := 2;
        IF Real3DHCGM IN CaracterMacro THEN ParametrosEnMacro   := 3;
        IF NOT( AnidadoParametroSimple( PunteroActual, ParametrosEnMacro,
                Resultado1, varDouble, Resultado2,
                varDouble, Resultado3, varDouble ) ) THEN GOTO SalidaFalsa;
        IF NOT( MyManejador.HojaDefault.EvaluarMacroSimple
                ( Fila, Columna, PivoteReal,
                  Msg, Manejador, ParametrosEnMacro, Resultado1,
                  Resultado2, Resultado3, CicloSintactico ) )
        THEN GOTO SalidaFalsa;
        ResultadoAnidado        := PivoteReal;
      END ELSE BEGIN  { IF BanderaMacro ELSE }
        IF NOT( MyManejador.HojaDefault.EvaluarFuncionSimple
                ( Fila, Columna, ResultadoAnidado,
                  Msg, Manejador, CicloSintactico ) )
        THEN GOTO SalidaFalsa;
        IF ResultadoAnidado = Null
        THEN VarCast( ResultadoAnidado, 0.0, varDouble);
      END;            { IF BanderaMacro ELSE }
    END;  { WITH PunteroActual.DatoInterpretado as ... }
    AnidadoCasillaHojaSimple    := CAFE_TypeSimpleValorCompatible
        ( TipoSolicitado, CAFE_TipoVariante( ResultadoAnidado ) );
    Exit;
SalidaFalsa:
    AnidadoCasillaHojaSimple    := FALSE;
    IF ( Msg = '' ) AND ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
      Msg                       := PunteroActual.DatoElemento;
      CAFE_MensajeInfructuosoSintactico         := Msg;
      CAFE_PosicionInfructuosoSintactico        :=
                        CAFE_4ErrorIrregularAccesoCasilla;
      CAFE_IntentoInfructuosoSintactico         := TRUE;
    END;  { IF ( Msg = '' ) AND ... }
  END;   { FUNCTION AnidadoCasillaHojaSimple }
    { ANIDADO }

    { ANIDADO }
  {$IFDEF       SILENCIAR       }
  {$NOTES       OFF             }
  {$ENDIF                       }
  FUNCTION AnidadoCalculoNITI
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   ResultadoAnidado    : Variant                       ) : Boolean;
  VAR
    Acumulado,
    PivFor1,
    PivFor2,
    PivFor3,
    Resultado1,
    Resultado2,
    Resultado3                  : Variant;
    PunteroPivoteFor,
    PunteroPivoteNombre         : CAFE_Nudo2Sintactico;
    DesPar,
    DesFun                      : CAFE_TipoInterprete;
    PivoteSolve,
    PivoteDerivada,
    PivoteIntegral              : Double;
    RecorreFor                  : LongInt;
    TotalParCalculo             : Byte;
    BanderaRecolocar            : Boolean;

  LABEL
    SalidaFinalCalculo,
    SalidaFalsaCalculo;

      { ANIDADO }
    FUNCTION  DerivadaContinuaInterpolada
      ( OUT Derivada                : Double;
            X                       : Double;
            MyParametro             : CAFE_TipoInterprete;
            DiferenciaInicial       : Double;
            DiferenciaConsecutiva   : Double                    ) : Boolean;
    VAR
      EstimacionDerivada,
      EstimacionDerivadaAnterior,
      DiferenciaSimple,
      DiferenciaDoble               : Double;
      BanderaHacer,
      BanderaPivote                 : Boolean;
      CuentaCiclo                   : Word;

    CONST
      DosTercios                    = 2/3;
      UnDoceavo                     = 1/12;

    LABEL
      SalidaFalsaDerivada;

        { ANIDADO }
      FUNCTION HacerUnSingle( ValorActual: Double ) : Double;
      VAR
        ResultadoHacer              : Variant;

      BEGIN  { FUNCTION HacerUnSingle }
        CASE MyParametro OF
          Parametro1CalculoNITI : PivFor1       := ValorActual;
          Parametro2CalculoNITI : PivFor2       := ValorActual;
          Parametro3CalculoNITI : PivFor3       := ValorActual ;
        END;  { CASE MyParametro }
        IF NOT( PunteroPivoteFor.EvaluarMacroFuncion
                ( ResultadoHacer, Msg, Manejador, TotalParMacro,
                        Param1, Param2, Param3, CicloSintactico,
                PivFor1, PivFor2, PivFor3 ) ) THEN BEGIN
          BanderaHacer   := FALSE;
          HacerUnSingle  := 0.0;
          Exit;
        END;  { IF NOT... }
        TRY
          HacerUnSingle         := ResultadoHacer;
          BanderaHacer          := TRUE;
        EXCEPT
          ON Exception
          DO BEGIN
            HacerUnSingle       := 0.0;
            BanderaHacer        := FALSE;
          END;  { ON Exception }
        END;
      END;   { FUNCTION HacerUnSingle }
        { ANIDADO }

    BEGIN  { FUNCTION DerivadaContinuaInterpolada }
      IF DiferenciaConsecutiva <= 0 THEN BEGIN
        GOTO SalidaFalsaDerivada;
      END;  { IF DiferenciaConsecutiva <= 0 }
      IF DiferenciaInicial = 0 THEN BEGIN
        GOTO SalidaFalsaDerivada;
      END;  { IF DiferenciaInicial = 0 }
      BanderaPivote                 := FALSE;
      CuentaCiclo                   := 0;
            { Aparentemente el Compilador tiene problemas al poner }
            { las dos llamadas HacerUnSingle en una misma llamada  }
      DiferenciaDoble               :=
            HacerUnSingle( X+DiferenciaInicial );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFalsaDerivada;
      DiferenciaDoble               := DiferenciaDoble
            -HacerUnSingle( X-DiferenciaInicial );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFalsaDerivada;
      EstimacionDerivadaAnterior    :=
                        DiferenciaDoble/( 2*DiferenciaInicial );
      REPEAT
        DiferenciaInicial           := DiferenciaInicial/2;
        DiferenciaSimple            :=
            HacerUnSingle( X+DiferenciaInicial );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFalsaDerivada;
        DiferenciaSimple            := DiferenciaSimple
            -HacerUnSingle( X-DiferenciaInicial );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFalsaDerivada;
        EstimacionDerivada          :=
                    ( DosTercios*DiferenciaSimple-UnDoceavo*DiferenciaDoble )
                    /DiferenciaInicial;
        Inc( CuentaCiclo );
        IF ABS( EstimacionDerivada-EstimacionDerivadaAnterior )
                    <= DiferenciaConsecutiva THEN BanderaPivote     := TRUE;
        EstimacionDerivadaAnterior  := EstimacionDerivada;
        DiferenciaDoble             := DiferenciaSimple;
      UNTIL BanderaPivote OR
                    ( CuentaCiclo >
                      CAFE_MaximaIteracionDerivadaContinuaInterpolada );
      DiferenciaConsecutiva         :=
                    ABS( EstimacionDerivada-EstimacionDerivadaAnterior );
      Derivada                      := EstimacionDerivada;
      DerivadaContinuaInterpolada   := ( DiferenciaConsecutiva >=
                ABS( EstimacionDerivada-EstimacionDerivadaAnterior ) );
      Exit;
SalidaFalsaDerivada :
      DerivadaContinuaInterpolada   := FALSE;
    END;   { FUNCTION DerivadaContinuaInterpolada }
      { ANIDADO }

      { ANIDADO }
      { Perdon y misericordia para con tu pueblo, Rey y Dios mio }
    FUNCTION    IntegralOctavoImpar
      ( OUT Integral                : Double;
            X1  , X2                : Double;
            PunteroParametros       : CAFE_TipoInterprete;
            DiferenciaConsecutiva   : Double                    ) : Boolean;
    VAR
      FactorL,
      Desplazado,
      Intervalo,
      AnteriorEstimacion,
      NuevaEstimacion,
      Suma0,
      Suma1,
      Suma2,
      Suma3,
      Suma4,
      DiferenciaEstimacion,
      BaseRepite                    : Double;
      K,
      CicloOctavo,
      CuentaCiclo                   : LongInt;
      BanderaHacer                  : Boolean;

    LABEL
      SalidaFracasoIntegral;

      FUNCTION HacerUnSingle( ValorActual: Double ) : Double;
      VAR
        ResultadoHacer              : Variant;

      BEGIN  { FUNCTION HacerUnSingle }
        CASE PunteroParametros OF
          Parametro1CalculoNITI : PivFor1       := ValorActual;
          Parametro2CalculoNITI : PivFor2       := ValorActual;
          Parametro3CalculoNITI : PivFor3       := ValorActual ;
        END;  { CASE PunteroParametros }
        IF NOT( PunteroPivoteFor.EvaluarMacroFuncion
                ( ResultadoHacer, Msg, Manejador, TotalParMacro,
                        Param1, Param2, Param3, CicloSintactico,
                PivFor1, PivFor2, PivFor3 ) ) THEN BEGIN
          BanderaHacer   := FALSE;
          HacerUnSingle  := 0.0;
          Exit;
        END;  { IF NOT... }
        TRY
          HacerUnSingle         := ResultadoHacer;
          BanderaHacer          := TRUE;
        EXCEPT
          ON Exception
          DO BEGIN
            HacerUnSingle       := 0.0;
            BanderaHacer        := FALSE;
          END;  { ON Exception }
        END;
      END;   { FUNCTION HacerUnSingle }

        { ANIDADO }
      PROCEDURE     AnidadoRepite ( VAR ValorRepite         : Double        );
      BEGIN  { PROCEDURE AnidadoRepite }
        BaseRepite                  := BaseRepite+Desplazado;
        ValorRepite                 := ValorRepite+
            HacerUnSingle( BaseRepite );
      END;   { PROCEDURE AnidadoRepite }
        { ANIDADO }

    BEGIN  { FUNCTION IntegralOctavoImpar }
      FactorL                       := X2-X1;
      IF DiferenciaConsecutiva <= 0 THEN BEGIN
        Integral                    := 0.0;
        IntegralOctavoImpar         := FALSE;
        Exit;
      END;  { IF DiferenciaConsecutiva <= 0 }
      Suma0                         :=
            HacerUnSingle( ( X1+X2 )/2 );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoIntegral;
      Suma2                         :=
            HacerUnSingle( ( 3*X1+X2 )/4 );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoIntegral;
      Suma2                         := Suma2+
            HacerUnSingle( ( X1+3*X2 )/4 );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoIntegral;
      Suma4                         :=
            HacerUnSingle( X1 );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoIntegral;
      Suma4                         := Suma4+
            HacerUnSingle( X2 );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoIntegral;
      NuevaEstimacion               := ( 12*Suma0+32*Suma2+7*Suma4 )*FactorL/90;
      AnteriorEstimacion            := ( Suma4+4*Suma0 )*FactorL/6;
      K                             := 1;
      DiferenciaEstimacion          := ABS( NuevaEstimacion-AnteriorEstimacion );
      Desplazado                    := FactorL/4;
      Intervalo                     := FactorL/8;
      CicloOctavo                   := 1;
      WHILE ( ( DiferenciaEstimacion > DiferenciaConsecutiva ) AND
        ( K < MyManejador.ValorMaximaIteracionIntegralOctavoImpar ) )
      DO BEGIN
        BaseRepite                  := X1-Intervalo;
        Suma1                       := 0;
        Suma3                       := 0;
        FOR CuentaCiclo := 1 TO CicloOctavo DO BEGIN
          AnidadoRepite( Suma3 );
          IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoIntegral;
          AnidadoRepite( Suma1 );
          IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoIntegral;
          AnidadoRepite( Suma1 );
          IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoIntegral;
          AnidadoRepite( Suma3 );
          IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoIntegral;
        END;  { FOR CuentaCiclo }
        AnteriorEstimacion          := NuevaEstimacion;
        NuevaEstimacion             :=
            Intervalo*( FactorP0IntegralOctavoImpar*Suma0+
                    FactorP1IntegralOctavoImpar*Suma1+
                    FactorP2IntegralOctavoImpar*Suma2+
                    FactorP3IntegralOctavoImpar*Suma3+
                    FactorP4IntegralOctavoImpar*Suma4 );
        DiferenciaEstimacion        := ABS( NuevaEstimacion-AnteriorEstimacion );
        Desplazado                  := Desplazado/2;
        Intervalo                   := Intervalo/2;
        Suma4                       := 2*Suma0+Suma4;
        Suma0                       := Suma2;
        Suma2                       := Suma1+Suma3;
        Inc( K );
        CicloOctavo                 := 2*CicloOctavo;
      END;  { ( ( DiferenciaEstimacion > DiferenciaConsecutiva ) AND ... ) }

      Integral                      := NuevaEstimacion;
      IF DiferenciaEstimacion <= DiferenciaConsecutiva THEN BEGIN
        IntegralOctavoImpar         := TRUE;
      END ELSE BEGIN  { IF DiferenciaEstimacion <= ... ELSE }
        IF K = MyManejador.ValorMaximaIteracionIntegralOctavoImpar
        THEN BEGIN
          IF ( Msg = '' ) AND ( CAFE_PosicionInfructuosoSintactico = 0 )
          THEN BEGIN
            CAFE_PosicionInfructuosoSintactico  :=
                        CAFE_4ErrorIntegralSuperoTotalCiclos;
            Msg                                 :=
        'La integral ha superado el valor de total de ciclos actual';
            CAFE_MensajeInfructuosoSintactico   := Msg;
            CAFE_IntentoInfructuosoSintactico   := TRUE;
          END;  { IF ( Msg = '' ) }
        END;  { IF ( Msg = '' ) }
        IntegralOctavoImpar         := FALSE;
      END;            { IF DiferenciaEstimacion <= ... ELSE }
      Exit;
SalidaFracasoIntegral :
      Integral                      := 0.0;
      IntegralOctavoImpar           := FALSE;
    END;   { FUNCTION IntegralOctavoImpar }
      { ANIDADO }

      { ANIDADO }
    FUNCTION  SolveBusqueda
      ( OUT ResultadoRaiz           : Double;
        VAR X1  , X2                : Double;
            PunteroParametros       : CAFE_TipoInterprete;
            TotalSectores           : LongInt;
            SelectorBusqueda        : Byte                      ) : Boolean;
    // 1 Raiz 2 Mayor 3 Menor
    VAR
      ValorRecorre,
      PosicionRecorre,
      ValorOptimo,
      PosicionOptimo,
      DeltaBusqueda                 : Double;
      I                             : LongInt;
      BanderaHacer                  : Boolean;

    LABEL
      SalidaFracasoBusqueda;

        { ANIDADO }
      FUNCTION HacerUnSingle( ValorActual: Double ) : Double;
      VAR
        ResultadoHacer              : Variant;

      BEGIN  { FUNCTION HacerUnSingle }
        CASE PunteroParametros OF
          Parametro1CalculoNITI : PivFor1       := ValorActual;
          Parametro2CalculoNITI : PivFor2       := ValorActual;
          Parametro3CalculoNITI : PivFor3       := ValorActual ;
        END;  { CASE PunteroParametros }
        IF NOT( PunteroPivoteFor.EvaluarMacroFuncion
                ( ResultadoHacer, Msg, Manejador, TotalParMacro,
                        Param1, Param2, Param3, CicloSintactico,
                PivFor1, PivFor2, PivFor3 ) ) THEN BEGIN
          BanderaHacer   := FALSE;
          HacerUnSingle  := 0.0;
          Exit;
        END;  { IF NOT... }
        TRY
          HacerUnSingle         := ResultadoHacer;
          BanderaHacer          := TRUE;
        EXCEPT
          ON Exception
          DO BEGIN
            HacerUnSingle       := 0.0;
            BanderaHacer        := FALSE;
          END;  { ON Exception }
        END;
      END;   { FUNCTION HacerUnSingle }
        { ANIDADO }

    BEGIN  { FUNCTION SolveBusqueda }
      IF X1 > X2 THEN BEGIN
        PosicionRecorre             := X1;
        X1                          := X2;
        X2                          := PosicionRecorre;
      END;  { IF X1 > X2 }
      DeltaBusqueda                 := ( X2-X1 )/TotalSectores;
      PosicionOptimo                := X1+DeltaBusqueda/2;
      ValorOptimo                   := HacerUnSingle( PosicionOptimo );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoBusqueda;
      PosicionRecorre               := PosicionOptimo;
      FOR I := 1 TO TotalSectores DO BEGIN
        ValorRecorre                := HacerUnSingle( PosicionRecorre );
        IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoBusqueda;
        CASE SelectorBusqueda OF
          1  : IF ABS( ValorRecorre ) < ABS( ValorOptimo ) THEN BEGIN
                 ValorOptimo        := ValorRecorre;
                 PosicionOptimo     := PosicionRecorre;
               END;  { CASE 1 }
          2  : IF ValorRecorre > ValorOptimo THEN BEGIN
                 ValorOptimo        := ValorRecorre;
                 PosicionOptimo     := PosicionRecorre;
               END;  { CASE 2 }
          3  : IF ValorRecorre < ValorOptimo THEN BEGIN
                 ValorOptimo        := ValorRecorre;
                 PosicionOptimo     := PosicionRecorre;
               END;  { CASE 3 }
        END;  { CASE SelectorBusqueda }
        PosicionRecorre
        +=      DeltaBusqueda;
      END;  { FOR I }
      ResultadoRaiz                 := PosicionOptimo;
      X1                            :=
                           Max( PosicionOptimo-DeltaBusqueda, X1 );
      X2                            :=
                           Min( PosicionOptimo+DeltaBusqueda, X2 );
      SolveBusqueda                 := TRUE;
      Exit;
SalidaFracasoBusqueda :
      SolveBusqueda                 := FALSE;
    END;   { FUNCTION SolveBusqueda }
      { ANIDADO }

      { ANIDADO }
    FUNCTION  SolvePuntoMedio
      ( OUT ResultadoRaiz           : Double;
            X1  , X2                : Double;
            PunteroParametros       : CAFE_TipoInterprete;
            DiferenciaConsecutiva   : Double                    ) : Boolean;
    VAR
      Inf,
      FInf,
      Sup,
      FSup,
      Med,
      FMed                          : Double;
      SInf,
      SSup,
      SMed,
      CicloContador,
      NumeroCiclosObjetivo          : LongInt;
      BanderaHacer                  : Boolean;

    LABEL
      SalidaFracasoSolve;

        { ANIDADO }
      FUNCTION HacerUnSingle( ValorActual: Double ) : Double;
      VAR
        ResultadoHacer              : Variant;

      BEGIN  { FUNCTION HacerUnSingle }
        CASE PunteroParametros OF
          Parametro1CalculoNITI : PivFor1       := ValorActual;
          Parametro2CalculoNITI : PivFor2       := ValorActual;
          Parametro3CalculoNITI : PivFor3       := ValorActual ;
        END;  { CASE PunteroParametros }
        IF NOT( PunteroPivoteFor.EvaluarMacroFuncion
                ( ResultadoHacer, Msg, Manejador, TotalParMacro,
                        Param1, Param2, Param3, CicloSintactico,
                PivFor1, PivFor2, PivFor3 ) ) THEN BEGIN
          BanderaHacer   := FALSE;
          HacerUnSingle  := 0.0;
          Exit;
        END;  { IF NOT... }
        TRY
          HacerUnSingle         := ResultadoHacer;
          BanderaHacer          := TRUE;
        EXCEPT
          ON Exception
          DO BEGIN
            HacerUnSingle       := 0.0;
            BanderaHacer        := FALSE;
          END;  { ON Exception }
        END;
      END;   { FUNCTION HacerUnSingle }
        { ANIDADO }

        { ANIDADO }
      PROCEDURE AnidadoColocaInf;
      BEGIN  { PROCEDURE AnidadoColocaInf }
        Inf                         := Med;
        FInf                        := FMed;
        SInf                        := SMed;
      END;   { PROCEDURE AnidadoColocaInf }
        { ANIDADO }

        { ANIDADO }
      PROCEDURE AnidadoColocaSup;
      BEGIN  { PROCEDURE AnidadoColocaSup }
        Sup                         := Med;
        FSup                        := FMed;
        SSup                        := SMed;
      END;   { PROCEDURE AnidadoColocaSup }
        { ANIDADO }

    BEGIN  { FUNCTION SolvePuntoMedio }
      DiferenciaConsecutiva         := ABS( DiferenciaConsecutiva );
      IF ( ABS( X1-X2 ) < DiferenciaConsecutiva ) OR
         ( DiferenciaConsecutiva = 0 )
      THEN BEGIN
        ResultadoRaiz               := ( X1+X2 )/2;
        SolvePuntoMedio             := TRUE;
        Exit;
      END;  { IF ( ABS( X1-X2 ) < DiferenciaConsecutiva ) OR ... }
      IF MyManejador.ValorPreliminarSolve <> 0 THEN BEGIN
        IF NOT( SolveBusqueda( ResultadoRaiz, X1, X2,
                  PunteroParametros, MyManejador.ValorPreliminarSolve, 1 ) )
        THEN GOTO SalidaFracasoSolve;
      END;  { IF ValorPreliminarSolve <> 0 }
      Inf                           := X1;
      FInf                          := HacerUnSingle( X1 );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoSolve;
      SInf                          := Sign( FInf );
      Sup                           := X2;
      FSup                          := HacerUnSingle( X2 );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoSolve;
      SSup                          := Sign( FSup );
      NumeroCiclosObjetivo          :=
            Trunc( ABS( Ln( ABS( X2-X1 )/
                        DiferenciaConsecutiva )/Ln( 2 ) ) )+1;
      IF NumeroCiclosObjetivo > CAFE_MaximoCiclosSolve THEN
                        NumeroCiclosObjetivo := CAFE_MaximoCiclosSolve;
      FOR CicloContador := 1 TO NumeroCiclosObjetivo DO BEGIN
        Med                         := ( Inf+Sup )/2;
        FMed                        := HacerUnSingle( Med );
        IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoSolve;
        SMed                        := Sign( FMed );
        IF SInf = SSup THEN BEGIN
          AnidadoColocaInf;
        END ELSE BEGIN  { IF SInf = SSup ELSE }
          IF SInf = 0 THEN BEGIN
            IF SMed = 0 THEN AnidadoColocaInf
                            ELSE AnidadoColocaSup;
          END ELSE BEGIN  { IF SInf = 0 ELSE }
            IF SSup = 0 THEN BEGIN
              IF SMed = 0 THEN AnidadoColocaSup
                            ELSE AnidadoColocaInf;
            END ELSE BEGIN  { IF SSup = 0 ELSE }
              IF SMed = 0 THEN BEGIN
                AnidadoColocaInf;
              END ELSE BEGIN  { IF SMed = 0 ELSE }
                IF SInf = SMed THEN AnidadoColocaInf
                                    ELSE AnidadoColocaSup;
              END;            { IF SMed = 0 ELSE }
            END;            { IF SSup = 0 ELSE }
          END;            { IF SInf = 0 ELSE }
        END;            { IF SInf = SSup ELSE }
      END;  { FOR CicloContador }
      ResultadoRaiz                 := ( Sup+Inf )/2;
      SolvePuntoMedio               := TRUE;
      Exit;
SalidaFracasoSolve :
      ResultadoRaiz                 := 0.0;
      SolvePuntoMedio               := FALSE;
    END;   { FUNCTION SolvePuntoMedio }
      { ANIDADO }

      { ANIDADO }
    FUNCTION  SolvePuntoMedioMaximo
      ( OUT ResultadoRaiz           : Double;
            X1  , X2                : Double;
            PunteroParametros       : CAFE_TipoInterprete;
            DiferenciaConsecutiva   : Double;
            MaximoMinimo            : Boolean                   ) : Boolean;
    VAR
      Inf,
      FInf,
      Sup,
      FSup,
      Med2,
      FMed2,
      Med,
      FMed                          : Double;
      CicloContador,
      NumeroCiclosObjetivo          : LongInt;
      BanderaHacer                  : Boolean;

   LABEL
     SalidaFracasoSolveMaximo;

        { ANIDADO }
      FUNCTION HacerUnSingle( ValorActual: Double ) : Double;
      VAR
        ResultadoHacer              : Variant;

      BEGIN  { FUNCTION HacerUnSingle }
        CASE PunteroParametros OF
          Parametro1CalculoNITI : PivFor1       := ValorActual;
          Parametro2CalculoNITI : PivFor2       := ValorActual;
          Parametro3CalculoNITI : PivFor3       := ValorActual ;
        END;  { CASE PunteroParametros }
        IF NOT( PunteroPivoteFor.EvaluarMacroFuncion
                ( ResultadoHacer, Msg, Manejador, TotalParMacro,
                        Param1, Param2, Param3, CicloSintactico,
                PivFor1, PivFor2, PivFor3 ) ) THEN BEGIN
          BanderaHacer   := FALSE;
          HacerUnSingle  := 0.0;
          Exit;
        END;  { IF NOT... }
        TRY
          IF MaximoMinimo
          THEN HacerUnSingle    := ResultadoHacer
          ELSE HacerUnSingle    := -ResultadoHacer;
          BanderaHacer          := TRUE;
        EXCEPT
          ON Exception
          DO BEGIN
            HacerUnSingle       := 0.0;
            BanderaHacer        := FALSE;
          END;  { ON Exception }
        END;
      END;   { FUNCTION HacerUnSingle }
        { ANIDADO }

    BEGIN  { FUNCTION SolvePuntoMedioMaximo }
      DiferenciaConsecutiva         := ABS( DiferenciaConsecutiva );
      IF ( ABS( X1-X2 ) < DiferenciaConsecutiva ) OR
         ( DiferenciaConsecutiva = 0 )
      THEN BEGIN
        ResultadoRaiz               := ( X1+X2 )/2;
        SolvePuntoMedioMaximo       := TRUE;
        Exit;
      END;  { IF ( ABS( X1-X2 ) < DiferenciaConsecutiva ) OR ... }
      IF MyManejador.ValorPreliminarSolve <> 0 THEN BEGIN
        IF NOT( SolveBusqueda( ResultadoRaiz, X1, X2,
                  PunteroParametros, MyManejador.ValorPreliminarSolve,
                  IFTHEN( MaximoMinimo, 2, 3 ) ) )
        THEN GOTO SalidaFracasoSolveMaximo;
      END;  { IF ValorPreliminarSolve <> 0 }
      Inf                           := X1;
      FInf                          := HacerUnSingle( X1 );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoSolveMaximo;
      Sup                           := X2;
      FSup                          := HacerUnSingle( X2 );
      IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoSolveMaximo;
      NumeroCiclosObjetivo          :=
            Trunc( ABS( Ln( ABS( X2-X1 )/
                        DiferenciaConsecutiva )/Ln( 2 ) ) )+1;
      IF NumeroCiclosObjetivo > CAFE_MaximoCiclosSolve THEN
                        NumeroCiclosObjetivo := CAFE_MaximoCiclosSolve;
      FOR CicloContador := 1 TO NumeroCiclosObjetivo DO BEGIN
        Med                         := ( Inf+Sup )/2;
        Med2                        := 0.01*( Sup-Inf );
        FMed                        := HacerUnSingle( Med-Med2 );
        IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoSolveMaximo;
        FMed2                       := HacerUnSingle( Med+Med2 );
        IF NOT( BanderaHacer ) THEN GOTO SalidaFracasoSolveMaximo;
        IF FMed <= FMed2
        THEN BEGIN
          Inf                       := Med;
          FInf                      := ( FMed+FMed2 )/2;
        END ELSE BEGIN  { IF FMed <= FMed2 ELSE }
          Sup                       := Med;
          FSup                      := ( FMed+FMed2 )/2;
        END;            { IF FMed <= FMed2 ELSE }
      END;  { FOR CicloContador }
      ResultadoRaiz                 := ( Sup+Inf )/2;
      SolvePuntoMedioMaximo         := TRUE;
      Exit;
SalidaFracasoSolveMaximo :
      ResultadoRaiz                 := 0.0;
      SolvePuntoMedioMaximo         := FALSE;
    END;   { FUNCTION SolvePuntoMedioMaximo }
      { ANIDADO }

  BEGIN  { FUNCTION AnidadoCalculoNITI }
    TotalParCalculo             :=
                PunteroActual.TotalDescendientesDirectos;
    IF TotalParCalculo < 3 THEN GOTO SalidaFalsaCalculo;
    PunteroPivoteFor            :=
        PunteroActual.DescendienteVertical as CAFE_Nudo2Sintactico;
    PunteroPivoteNombre         :=
        PunteroPivoteFor.DescendienteHorizontal as CAFE_Nudo2Sintactico;
    PivFor1                     := ForParam1;
    PivFor2                     := ForParam2;
    PivFor3                     := ForParam3;
    WITH ( PunteroPivoteNombre.DatoInterpretado as CAFE_Interprete2Sintactico )
    DO BEGIN
      IF Parametro1CalculoNITI IN DescriptorInterprete THEN BEGIN
        DesPar                    := Parametro1CalculoNITI;
      END;  { IF Parametro1CalculoNITI IN ... }
      IF Parametro2CalculoNITI IN DescriptorInterprete THEN BEGIN
        DesPar                    := Parametro2CalculoNITI;
      END;  { IF Parametro1CalculoNITI IN ... }
      IF Parametro3CalculoNITI IN DescriptorInterprete THEN BEGIN
        DesPar                    := Parametro3CalculoNITI;
      END;  { IF Parametro1CalculoNITI IN ... }
    END;  { WITH ...DatoInterpretado... }
    BanderaRecolocar            := FALSE;
    IF SumatoriaNITI IN ( PunteroActual.DatoInterpretado
      as CAFE_Interprete2Sintactico ).DescriptorInterprete THEN BEGIN
      DesFun                    := SumatoriaNITI;
      CAFE_VarCast( ResultadoAnidado, 0, varDouble );
      IF NOT( AnidadoParametroSimple( PunteroPivoteNombre, 2,
                Resultado1, varInteger, Resultado2, varInteger,
                Resultado3, varNull, FALSE ) ) THEN GOTO SalidaFalsaCalculo;
      FOR RecorreFor := Resultado1 TO Resultado2 DO BEGIN
        CASE DesPar OF
          Parametro1CalculoNITI : PivFor1       := RecorreFor;
          Parametro2CalculoNITI : PivFor2       := RecorreFor;
          Parametro3CalculoNITI : PivFor3       := RecorreFor;
        END;  { CASE DesPar }
        IF NOT( PunteroPivoteFor.EvaluarMacroFuncion
                ( Acumulado, Msg, Manejador, TotalParMacro,
                        Param1, Param2, Param3, CicloSintactico,
                PivFor1, PivFor2, PivFor3 ) ) THEN GOTO SalidaFalsaCalculo;
        TRY
          ResultadoAnidado      := ResultadoAnidado+Acumulado;
        EXCEPT
          ON Exception DO BanderaRecolocar      := TRUE;
        END;
        IF BanderaRecolocar THEN GOTO SalidaFalsaCalculo;
      END;  { FOR RecorreFor }
      GOTO SalidaFinalCalculo;
    END;  { IF SumatoriaNITI IN ( PunteroActual.DatoInterpretado ) }
    IF ProductoriaNITI IN ( PunteroActual.DatoInterpretado
      as CAFE_Interprete2Sintactico ).DescriptorInterprete THEN BEGIN
      DesFun                    := ProductoriaNITI;
      CAFE_VarCast( ResultadoAnidado, 1.0, varDouble );
      IF NOT( AnidadoParametroSimple( PunteroPivoteNombre, 2,
                Resultado1, varInteger, Resultado2, varInteger,
                Resultado3, varNull, FALSE ) ) THEN GOTO SalidaFalsaCalculo;
      FOR RecorreFor := Resultado1 TO Resultado2 DO BEGIN
        CASE DesPar OF
          Parametro1CalculoNITI : PivFor1       := RecorreFor;
          Parametro2CalculoNITI : PivFor2       := RecorreFor;
          Parametro3CalculoNITI : PivFor3       := RecorreFor;
        END;  { CASE DesPar }
        IF NOT( PunteroPivoteFor.EvaluarMacroFuncion
                ( Acumulado, Msg, Manejador, TotalParMacro,
                        Param1, Param2, Param3, CicloSintactico,
                PivFor1, PivFor2, PivFor3 ) ) THEN GOTO SalidaFalsaCalculo;
        TRY
          ResultadoAnidado      := ResultadoAnidado*Acumulado;
        EXCEPT
          ON Exception DO BanderaRecolocar      := TRUE;
        END;
        IF BanderaRecolocar THEN GOTO SalidaFalsaCalculo;
      END;  { FOR RecorreFor }
      GOTO SalidaFinalCalculo;
    END;  { IF ProductoriaNITI IN ( PunteroActual.DatoInterpretado ) }
    IF IntegralNITI IN ( PunteroActual.DatoInterpretado
      as CAFE_Interprete2Sintactico ).DescriptorInterprete THEN BEGIN
      DesFun                    := IntegralNITI;
      CAFE_VarCast( ResultadoAnidado, 0.0, varDouble );
      IF NOT( AnidadoParametroSimple( PunteroPivoteNombre, TotalParCalculo-2,
                Resultado1, varDouble, Resultado2, varDouble,
                Resultado3, varDouble, FALSE ) ) THEN GOTO SalidaFalsaCalculo;
      IF TotalParCalculo = 4 THEN
                Resultado3 := CAFE_DefaultToleranciaIntegral;
      IF IntegralOctavoImpar( PivoteIntegral, Resultado1, Resultado2,
                DesPar, Resultado3 ) THEN BEGIN
        FactorRedondeo          := Resultado3;
        ResultadoAnidado        := PivoteIntegral;
        GOTO SalidaFinalCalculo;
      END ELSE BEGIN  { IF IntegralOctavoImpar... ELSE }
        GOTO SalidaFalsaCalculo;
      END;            { IF IntegralOctavoImpar... ELSE }
    END;  { IF IntegralNITI IN ( PunteroActual.DatoInterpretado ) }
    IF DerivadaNITI IN ( PunteroActual.DatoInterpretado
      as CAFE_Interprete2Sintactico ).DescriptorInterprete THEN BEGIN
      DesFun                    := DerivadaNITI;
      CAFE_VarCast( ResultadoAnidado, 0.0, varDouble );
      IF NOT( AnidadoParametroSimple( PunteroPivoteNombre, TotalParCalculo-2,
                Resultado1, varDouble, Resultado2, varDouble,
                Resultado3, varDouble, FALSE ) ) THEN GOTO SalidaFalsaCalculo;
      IF TotalParCalculo = 3 THEN
                Resultado2 := CAFE_DeltaInicialDerivada;
      IF TotalParCalculo < 5 THEN
                Resultado3 := CAFE_DefaultToleranciaDerivada;
      IF DerivadaContinuaInterpolada( PivoteDerivada,
                Resultado1, DesPar, Resultado2, Resultado3 )
      THEN BEGIN
        ResultadoAnidado        := PivoteDerivada;
        FactorRedondeo          := Resultado3;
        GOTO SalidaFinalCalculo;
      END ELSE BEGIN  { IF DerivadaContinuaInterpolada... ELSE }
        GOTO SalidaFalsaCalculo;
      END;            { IF DerivadaContinuaInterpolada... ELSE }
    END;  { IF DerivadaNITI IN ( PunteroActual.DatoInterpretado ) }
    IF SolveNITI IN ( PunteroActual.DatoInterpretado
      as CAFE_Interprete2Sintactico ).DescriptorInterprete THEN BEGIN
      DesFun                    := SolveNITI;
      CAFE_VarCast( ResultadoAnidado, 0.0, varDouble );
      IF NOT( AnidadoParametroSimple( PunteroPivoteNombre, TotalParCalculo-2,
                Resultado1, varDouble, Resultado2, varDouble,
                Resultado3, varDouble, FALSE ) ) THEN GOTO SalidaFalsaCalculo;
      IF TotalParCalculo < 5 THEN
                Resultado3 := CAFE_DefaultToleranciaSolve;
      IF SolvePuntoMedio( PivoteSolve,
                Resultado1, Resultado2, DesPar, Resultado3 )
      THEN BEGIN
        FactorRedondeo          := Resultado3;
        ResultadoAnidado        := PivoteSolve;
        GOTO SalidaFinalCalculo;
      END ELSE BEGIN  { IF DerivadaContinuaInterpolada... ELSE }
        GOTO SalidaFalsaCalculo;
      END;            { IF DerivadaContinuaInterpolada... ELSE }
    END;  { IF SolveNITI IN ( PunteroActual.DatoInterpretado ) }
    IF SolveMaximoNITI IN ( PunteroActual.DatoInterpretado
      as CAFE_Interprete2Sintactico ).DescriptorInterprete THEN BEGIN
      DesFun                    := SolveMaximoNITI;
      CAFE_VarCast( ResultadoAnidado, 0.0, varDouble );
      IF NOT( AnidadoParametroSimple( PunteroPivoteNombre, TotalParCalculo-2,
                Resultado1, varDouble, Resultado2, varDouble,
                Resultado3, varDouble, FALSE ) ) THEN GOTO SalidaFalsaCalculo;
      IF TotalParCalculo < 5 THEN
                Resultado3 := CAFE_DefaultToleranciaSolve;
      IF SolvePuntoMedioMaximo( PivoteSolve,
                Resultado1, Resultado2, DesPar, Resultado3, TRUE )
      THEN BEGIN
        FactorRedondeo          := Resultado3;
        ResultadoAnidado        := PivoteSolve;
        GOTO SalidaFinalCalculo;
      END ELSE BEGIN  { IF DerivadaContinuaInterpolada... ELSE }
        GOTO SalidaFalsaCalculo;
      END;            { IF DerivadaContinuaInterpolada... ELSE }
    END;  { IF SolveMaximoNITI IN ( PunteroActual.DatoInterpretado ) }
    IF SolveMinimoNITI IN ( PunteroActual.DatoInterpretado
      as CAFE_Interprete2Sintactico ).DescriptorInterprete THEN BEGIN
      DesFun                    := SolveMinimoNITI;
      CAFE_VarCast( ResultadoAnidado, 0.0, varDouble );
      IF NOT( AnidadoParametroSimple( PunteroPivoteNombre, TotalParCalculo-2,
                Resultado1, varDouble, Resultado2, varDouble,
                Resultado3, varDouble, FALSE ) ) THEN GOTO SalidaFalsaCalculo;
      IF TotalParCalculo < 5 THEN
                Resultado3 := CAFE_DefaultToleranciaSolve;
      IF SolvePuntoMedioMaximo( PivoteSolve,
                Resultado1, Resultado2, DesPar, Resultado3, FALSE )
      THEN BEGIN
        FactorRedondeo          := Resultado3;
        ResultadoAnidado        := PivoteSolve;
        GOTO SalidaFinalCalculo;
      END ELSE BEGIN  { IF DerivadaContinuaInterpolada... ELSE }
        GOTO SalidaFalsaCalculo;
      END;            { IF DerivadaContinuaInterpolada... ELSE }
    END;  { IF SolveMinimoNITI IN ( PunteroActual.DatoInterpretado ) }
SalidaFinalCalculo :
    AnidadoCalculoNITI          := TRUE;
    Exit;
SalidaFalsaCalculo :
     AnidadoCalculoNITI         := FALSE;
  END;   { FUNCTION AnidadoCalculoNITI }
    { ANIDADO }
  {$IFDEF       SILENCIAR       }
  {$NOTES       ON              }
  {$ENDIF                       }

    { ANIDADO }
  FUNCTION AnidadoSectorNITI
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   ResultadoAnidado    : Variant;
            BanderaSilenciar    : Boolean               = FALSE ) : Boolean;
  VAR
    PivPaquete                  : CAFE_ItemRectangular;
    DatoVariante,
    DatoResultado,
    ResultadoReal,
    PivoteHoja                  : Variant;
    CaracterMacro               : CAFE_ConjuntoParametroBasico;
    PunteroMovil                : CAFE_Nudo2Sintactico;
    MyClavePaquete,
    PivoteEntero,
    RecorreFila,
    RecorreColumna,
    PivoteFila1,
    PivoteFila2,
    PivoteColumna1,
    PivoteColumna2              : LongInt;
    BanderaNudillado,
    BanderaMacro                : Boolean;

  LABEL
    SalidaFalsaSector;

  BEGIN  { FUNCTION AnidadoSectorNITI }
    IF MyManejador.HojaDefault = NIL THEN GOTO SalidaFalsaSector;
    PunteroMovil                :=
        PunteroActual.DescendienteVertical as CAFE_Nudo2Sintactico;
    WITH PunteroMovil.DatoInterpretado as CAFE_Interprete2Sintactico
    DO BEGIN
      IF NOT( [ ActivoNITI, CasillaHojaNITI, HojaDefaultNITI ]  <=
                                                DescriptorInterprete )
      THEN GOTO SalidaFalsaSector;
      PivoteFila1               :=
        EnsureRange( ValorInterpretado[ 1 ], 0,
                        MyManejador.HojaDefault.FilasEnHoja-1  );
      PivoteColumna1            :=
        EnsureRange( ValorInterpretado[ 2 ], 0,
                        MyManejador.HojaDefault.ColumnasEnHoja-1 );
    END;  { WITH PunteroMovil.DatoInterpretado as ... }
    PunteroMovil                :=
        PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
    WITH PunteroMovil.DatoInterpretado as CAFE_Interprete2Sintactico
    DO BEGIN
      IF NOT( [ ActivoNITI, CasillaHojaNITI, HojaDefaultNITI ] <=
                                                DescriptorInterprete )
      THEN GOTO SalidaFalsaSector;
      PivoteFila2               :=
        EnsureRange( ValorInterpretado[ 1 ], 0,
                        MyManejador.HojaDefault.FilasEnHoja-1  );
      PivoteColumna2            :=
        EnsureRange( ValorInterpretado[ 2 ], 0,
                        MyManejador.HojaDefault.ColumnasEnHoja-1  );
    END;  { WITH PunteroMovil.DatoInterpretado as ... }
    IF PivoteFila1 > PivoteFila2 THEN BEGIN
      PivoteEntero              := PivoteFila1;
      PivoteFila1               := PivoteFila2;
      PivoteFila2               := PivoteEntero;
    END;  { IF PivoteFila1 > PivoteFila2 }
    IF PivoteColumna1 > PivoteColumna2 THEN BEGIN
      PivoteEntero              := PivoteColumna1;
      PivoteColumna1            := PivoteColumna2;
      PivoteColumna2            := PivoteEntero;
    END;  { IF PivoteColumna1 > PivoteColumna2 }
    MyClavePaquete              := CAFE_GenerarPaqueteRectangular
                ( ABS( PivoteFila2-PivoteFila1+1 ),
                  ABS( PivoteColumna2-PivoteColumna1+1 ), CicloSintactico );
    PivPaquete                  :=
                CAFE_ItemListaRectangular.ID[ MyClavePaquete ];
    FOR RecorreFila := PivoteFila1 TO PivoteFila2 DO BEGIN
      FOR RecorreColumna := PivoteColumna1 TO PivoteColumna2 DO BEGIN
        IF BanderaSilenciar THEN BEGIN
          MyManejador.HojaDefault.LecturaTipo
                ( RecorreFila, RecorreColumna,
                        BanderaNudillado, BanderaMacro,
                        CaracterMacro, DatoVariante, DatoResultado );
          IF BanderaMacro THEN GOTO SalidaFalsaSector;
          IF BanderaNudillado
          THEN PivoteHoja       := DatoResultado
          ELSE PivoteHoja       := DatoVariante;
        END ELSE BEGIN  { IF BanderaSilenciar ELSE }
          IF NOT( MyManejador.HojaDefault.EvaluarFuncionSimple(
            RecorreFila, RecorreColumna,
            PivoteHoja, Msg, Manejador, CicloSintactico ) )
          THEN GOTO SalidaFalsaSector;
        END;            { IF BanderaSilenciar ELSE }
        IF NOT( CAFE_VarCast( ResultadoReal, PivoteHoja, varDouble ) )
        THEN GOTO SalidaFalsaSector;
        PivPaquete.EscribirDoubleItemRectangular
          ( ResultadoReal,
            RecorreFila-PivoteFila1, RecorreColumna-PivoteColumna1 );
      END;  { FOR RecorreColumna }
    END;  { FOR RecorreFila }
    ResultadoAnidado            := MyClavePaquete;
    AnidadoSectorNITI           := TRUE;
    Exit;
SalidaFalsaSector :
    AnidadoSectorNITI           := FALSE;
  END;  { FUNCTION AnidadoSectorNITI }
    { ANIDADO }

    { ANIDADO }
  FUNCTION AnidadoRegistroNITI
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   ResultadoAnidado    : Variant;
            TipoSolicitado      : SizeInt                       ) : Boolean;
  VAR
    Cadenita                    : ShortString;
    PunteroMovil                : CAFE_Nudo2Sintactico;
    PunteroInterprete           : CAFE_InterpreteSintactico;
    OtroManejadorBasico         : CAFE_ManejadorBasico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
    OtroManejador               : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
    NuevoNumeroManejador        : LongInt;

  LABEL
    SalidaFalsa;

  BEGIN
    PunteroMovil                :=
              PunteroActual.DescendienteVertical as CAFE_Nudo2Sintactico;
    IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
    PunteroInterprete           := PunteroMovil.DatoInterpretado;
    NuevoNumeroManejador        := PunteroInterprete.ValorInterpretado;
    Cadenita                    := PunteroInterprete.NombreIdentificador;
    OtroManejadorBasico         :=
        CAFE_RaizManejadores.ID[ NuevoNumeroManejador ];
    IF OtroManejadorBasico = NIL THEN GOTO SalidaFalsa;
    IF Cadenita <> CAFE_CadenaIdentificadorSelf THEN BEGIN
      IF OtroManejadorBasico.DisplayNombre <> Cadenita
      THEN GOTO SalidaFalsa;
    END;  { IF ClaveEjesIdentificadorSelf }
    OtroManejadorBasico.GetInterfaceByStr
        ( CAFE_GUIDInterfaceManejador, OtroManejador );
    PunteroMovil                :=
              PunteroMovil.DescendienteHorizontal as CAFE_Nudo2Sintactico;
    IF PunteroMovil = NIL THEN GOTO SalidaFalsa;
    IF NOT( PunteroMovil.EvaluarMacroFuncion(
        ResultadoAnidado, Msg, OtroManejador,
        TotalParMacro, Param1, Param2, Param3,
        CicloSintactico, ForParam1, ForParam2, ForParam3 ) )
    THEN GOTO SalidaFalsa;
    AnidadoRegistroNITI         := CAFE_TypeSimpleValorCompatible
      ( TipoSolicitado, CAFE_TipoVariante( ResultadoAnidado ) );
    Exit;
SalidaFalsa :
    AnidadoRegistroNITI         := FALSE;
  END;  { FUNCTION AnidadoRegistroNITI }
    { ANIDADO }

  FUNCTION AnidadoCompatible
    (       PunteroActual       : CAFE_Nudo2Sintactico;
      OUT   ResultadoAnidado    : Variant;
            TipoSolicitado      : SizeInt       = varNull       ) : Boolean;
  VAR
    PivoteFecha                 : TDateTime;
    PivoteReal                  : Double;

  BEGIN  { FUNCTION AnidadoCompatible }
    IF PunteroActual.DatoInterpretado = NIL THEN BEGIN
      ResultadoAnidado          := PunteroActual.DatoElemento;
      AnidadoCompatible         := CAFE_TypeSimpleValorCompatible
          ( TipoSolicitado, CAFE_TipoVariante( ResultadoAnidado ) );
    END ELSE BEGIN  { IF PunteroActual.DatoInterpretado = NIL ELSE }
      WITH ( PunteroActual.DatoInterpretado as CAFE_Interprete2Sintactico )
      DO BEGIN
        IF BanderaSimple THEN BEGIN
          IF BanderaVariant THEN BEGIN
            ResultadoAnidado    := ValorInterpretado;
            IF ClaveInterpretado = ClaveEjesIdentificadorRandom
            THEN BEGIN
              PivoteReal        := Random;
              ResultadoAnidado  := PivoteReal;
            END;  { IF ClaveInterpretado = ClaveEjesIdentificadorRandom }
            IF ClaveInterpretado = ClaveEjesIdentificadorHoy
            THEN BEGIN
              PivoteFecha       := Today;
              ResultadoAnidado  := PivoteFecha;
            END;  { IF ClaveInterpretado = ClaveEjesIdentificadorHoy }
            AnidadoCompatible   := CAFE_TypeSimpleValorCompatible
                ( TipoSolicitado, CAFE_TipoVariante( ResultadoAnidado ) );
          END ELSE BEGIN  { IF BanderaVariant ELSE }
            IF ActivoNITI IN DescriptorInterprete THEN BEGIN
              IF CasillaHojaNITI IN DescriptorInterprete THEN BEGIN
                IF AnidadoCasillaHojaSimple
                      ( PunteroActual, ResultadoAnidado, TipoSolicitado )
                THEN BEGIN
                  AnidadoCompatible           := TRUE;
                END ELSE BEGIN  { IF AnidadoMacroSimple... ELSE }
                  IF ( Msg = '' )  AND
                     ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
                    CAFE_PosicionInfructuosoSintactico   :=
                                        CAFE_4ErrorAlEvaluarEnLugar;
                    Msg                                  :=
                                        NombreIdentificador;
                    CAFE_IntentoInfructuosoSintactico    := TRUE;
                    CAFE_MensajeInfructuosoSintactico    := Msg;
                  END;  { IF Msg = '' }
                  AnidadoCompatible           := FALSE;
                END;            { IF AnidadoMacroSimple... ELSE }
              END ELSE BEGIN  { IF CasillaHojaNITI IN ... ELSE }
                IF OrdenCalculoNITI IN DescriptorInterprete THEN BEGIN
                  AnidadoCompatible           :=
                    AnidadoCalculoNITI( PunteroActual, ResultadoAnidado );
                  Exit;
                END;  { IF OperarCalculo IN DescriptorInterprete }
                IF OperadorSectorNITI IN DescriptorInterprete THEN BEGIN
                  IF NOT( TipoSolicitado = varArray )
                  THEN AnidadoCompatible        := FALSE
                  ELSE AnidadoCompatible        :=
                        AnidadoSectorNITI( PunteroActual, ResultadoAnidado,
                                SilenciarSectorNITI IN DescriptorInterprete );
                  Exit;
                END;  { IF OperadorSectorNITI IN DescriptorInterprete }
                IF OperadorRegistroNITI IN DescriptorInterprete THEN BEGIN
                  IF AnidadoRegistroNITI( PunteroActual, ResultadoAnidado,
                                TipoSolicitado )
                  THEN BEGIN
                    AnidadoCompatible           := TRUE;
                  END ELSE BEGIN  { IF AnidadoFuncionalSimple... ELSE }
                    IF ( Msg = '' ) AND
                       ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
                      CAFE_PosicionInfructuosoSintactico   :=
                                                CAFE_4ErrorAlEvaluarEnLugar;
                      Msg                                  :=
                                                'acceso externo';
                      CAFE_IntentoInfructuosoSintactico    := TRUE;
                      CAFE_MensajeInfructuosoSintactico    := Msg;
                    END;  { IF Msg = '' }
                    AnidadoCompatible           := FALSE;
                  END;            { IF AnidadoFuncionalSimple... ELSE }
                  Exit;
                END;  { IF OperadorSectorNITI IN DescriptorInterprete }
                IF FuncionalNITI IN DescriptorInterprete THEN BEGIN
                  IF AnidadoFuncionalSimple
                        ( PunteroActual, ResultadoAnidado, TipoSolicitado )
                  THEN BEGIN
                    AnidadoCompatible           := TRUE;
                  END ELSE BEGIN  { IF AnidadoFuncionalSimple... ELSE }
                    IF ( Msg = '' ) AND
                       ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
                      CAFE_PosicionInfructuosoSintactico   :=
                                        CAFE_4ErrorAlEvaluarEnLugar;
                      Msg                                  :=
                                        NombreIdentificador;
                      CAFE_IntentoInfructuosoSintactico    := TRUE;
                      CAFE_MensajeInfructuosoSintactico    := Msg;
                    END;  { IF Msg = '' }
                    AnidadoCompatible           := FALSE;
                  END;            { IF AnidadoFuncionalSimple... ELSE }
                END ELSE BEGIN  { IF FuncionalNITI IN ... ELSE }
                  IF ParametroMacroNITI IN DescriptorInterprete THEN BEGIN
                    IF CAFE_TypeSimpleValorCompatible
                                ( varDouble, TipoSolicitado )
                    THEN BEGIN
                      IF Parametro1DNITI IN DescriptorInterprete THEN BEGIN
                        ResultadoAnidado        := Param1;
                      END;  { IF Parametro1DNITI IN ... }
                      IF Parametro2DNITI IN DescriptorInterprete THEN BEGIN
                        ResultadoAnidado        := Param2;
                      END;  { IF Parametro2DNITI IN ... }
                      IF Parametro3DNITI IN DescriptorInterprete THEN BEGIN
                        ResultadoAnidado        := Param3;
                      END;  { IF Parametro3DNITI IN ... }
                      AnidadoCompatible         := TRUE;
                    END ELSE BEGIN
                        { IF CAFE_TypeSimpleValorCompatible... ELSE }
                      AnidadoCompatible         := FALSE;
                    END;
                  END ELSE BEGIN  { IF ParametroMacroNITI IN ... ELSE }
                    IF ParametroCalculoNITI IN DescriptorInterprete THEN BEGIN
                      IF Parametro1CalculoNITI IN DescriptorInterprete
                      THEN ResultadoAnidado     := ForParam1;
                      IF Parametro2CalculoNITI IN DescriptorInterprete
                      THEN ResultadoAnidado     := ForParam2;
                      IF Parametro3CalculoNITI IN DescriptorInterprete
                      THEN ResultadoAnidado     := ForParam3;
                      AnidadoCompatible         := TRUE;
                    END ELSE BEGIN
                      AnidadoCompatible           := FALSE;
                    END;  { IF ParametroCalculoNITI IN ... ELSE }
                  END;            { IF ParametroMacroNITI IN ... ELSE }
                END;            { IF FuncionalNITI IN ... ELSE }
              END;            { IF CasillaHojaNITI IN ... ELSE }
            END ELSE BEGIN  { IF ActivoNITI IN DescriptorInterprete ELSE }
              AnidadoCompatible := FALSE;
            END;            { IF ActivoNITI IN DescriptorInterprete ELSE }
          END;            { IF BanderaVariant ELSE }
        END ELSE BEGIN  { IF BanderaSimple ELSE }
          // En el futuro se preveen mas caracteristicas
          AnidadoCompatible     := FALSE;
        END;            { IF BanderaSimple ELSE }
      END;  { WITH PunteroActual.DatoInterpretado }
    END;            { IF PunteroActual.DatoInterpretado = NIL ELSE }
  END;   { FUNCTION AnidadoCompatible }
    { ANIDADO }

    { ANIDADO }
BEGIN  { FUNCTION CAFE_Nudo2Sintactico.EvaluarMacroFuncion }
  Msg                         := '';
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
  WITH MyManejador DO BEGIN
    IF CicloSintactico = 0 THEN BEGIN
      Inc( CAFE_IdentificadorCicloSintactico,
                          CAFE_IncrementoIdentificadorCicloSintactico );
      CicloSintactico     := CAFE_IdentificadorCicloSintactico;
      // Se asigna un valor para asegurar la destruccion
      // de los paquetes rectangulares de datos si se generan
    END;  { IF CicloSintactico = 0 }
    IF TotalParMacro = 0 THEN BEGIN
      IF AnidadoCompatible( Self, ResultMacro ) THEN BEGIN
        IF CAFE_RedondeoFinalCalculoNITI THEN BEGIN
          IF DatoInterpretado <> NIL THEN BEGIN
            WITH DatoInterpretado as CAFE_Interprete2Sintactico DO BEGIN
              IF BanderaSimple THEN BEGIN
                IF [ ActivoNITI, OrdenCalculoNITI ] <= DescriptorInterprete
                THEN BEGIN
                  IF ( ( [ SolveNITI, SolveMaximoNITI, SolveMinimoNITI,
                       IntegralNITI, DerivadaNITI ]*DescriptorInterprete )
                                          <> [] ) THEN BEGIN
                    IF ImplementationOverloadTypeSimpleValorCompatible
                          ( varDouble, CAFE_TipoVariante( ResultMacro ) )
                    THEN ResultMacro      := CAFE_RedondeoTolerancia
                          ( ResultMacro, 2*FactorRedondeo );
                  END;  { IF ... }
                END;  { IF [ ActivoNITI, OrdenCalculoNITI ] ... }
              END;  { IF BanderaSimple }
            END;  { WITH DatoInterpretado as CAFE_Interprete2Sintactico }
          END;  { IF DatoInterpretado <> NIL }
        END;  { IF CAFE_RedondeoFinalCalculoNITI }
        EvaluarMacroFuncion                   := TRUE;
      END ELSE BEGIN  { IF AnidadoCompatible( Self, Result, varNull ) ELSE }
        IF ( Msg = '' ) AND ( CAFE_PosicionInfructuosoSintactico =  0 )
        THEN BEGIN
          CAFE_IntentoInfructuosoSintactico   := TRUE;
          CAFE_MensajeInfructuosoSintactico   := 'Fallo evaluacion';
          Msg                                 := 'Fallo evaluacion';
          CAFE_PosicionInfructuosoSintactico  := CAFE_4ErrorVarErrorEvaluar;
        END;  { IF NOT( CAFE_IntentoInfructuosoSintactico ) }
        EvaluarMacroFuncion                   := FALSE;
        Exit;
      END;            { IF AnidadoCompatible( Self, Result, varNull ) ELSE }
    END ELSE BEGIN  { IF TotalParMacro = 0 ELSE }
      IF AnidadoCompatible( Self, ResultMacro, varDouble ) THEN BEGIN
        EvaluarMacroFuncion                   := TRUE;
      END ELSE BEGIN  { IF AnidadoCompatible( Self, Result, varNull ) ELSE }
        IF ( Msg = '' ) AND ( CAFE_PosicionInfructuosoSintactico =  0 )
        THEN BEGIN
          CAFE_IntentoInfructuosoSintactico   := TRUE;
          CAFE_MensajeInfructuosoSintactico   := 'Fallo evaluacion';
          Msg                                 := 'Fallo evaluacion';
          CAFE_PosicionInfructuosoSintactico  := CAFE_4ErrorVarErrorEvaluar;
        END;  { IF NOT( CAFE_IntentoInfructuosoSintactico ) }
        EvaluarMacroFuncion                   := FALSE;
        Exit;
      END;            { IF AnidadoCompatible( Self, Result, varNull ) ELSE }
    END;            { IF TotalParMacro = 0 ELSE }
  END;  { WITH MyManejador }
END;   { FUNCTION CAFE_Nudo2Sintactico.EvaluarMacroFuncion }

FUNCTION    CAFE_Nudo2Sintactico.EvaluarMacro
  ( OUT   ResultMacro           : Double;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          TotalParMacro         : LongInt;
          Param1                : Double        = 0.0;
          Param2                : Double        = 0.0;
          Param3                : Double        = 0.0;
          CicloSintactico       : LongInt       = 0             ) : Boolean;
VAR
  PivoteReal                    : Variant;

BEGIN  { FUNCTION CAFE_Nudo2Sintactico.EvaluarMacro }
  IF EvaluarMacroFuncion( PivoteReal, Msg, Manejador,
        TotalParMacro, Param1, Param2, Param3, CicloSintactico ) THEN BEGIN
    IF ImplementationOverloadTypeSimpleValorCompatible
                ( varDouble, CAFE_TipoVariante( PivoteReal ) )
    THEN BEGIN
      ResultMacro               := PivoteReal;
      EvaluarMacro              := TRUE;
    END ELSE BEGIN  { IF CAFE_TipoVariante( PivoteReal ) = varDouble ELSE }
      ResultMacro               := 0.0;
      IF ( Msg = '' ) AND ( CAFE_PosicionInfructuosoSintactico = 0 )
      THEN BEGIN
        Msg                     := 'Inconsistencia de tipo en macro';
        CAFE_PosicionInfructuosoSintactico              :=
                                CAFE_4ErrorMacroResultadoNoReal;
        CAFE_IntentoInfructuosoSintactico               := TRUE;
        CAFE_MensajeInfructuosoSintactico               := Msg;
      END;  { IF ( Msg = '' ) AND ... }
      EvaluarMacro              := FALSE;
    END;            { IF CAFE_TipoVariante( PivoteReal ) = varDouble ELSE }
  END ELSE BEGIN  { IF EvaluarMacroFuncion... ELSE }
    ResultMacro                 := 0.0;
    EvaluarMacro                := FALSE;
  END;            { IF EvaluarMacroFuncion... ELSE }
END;   { FUNCTION CAFE_Nudo2Sintactico.EvaluarMacro }

DESTRUCTOR  CAFE_Nudo2Sintactico.Destroy;
BEGIN  { DESTRUCTOR CAFE_Nudo2Sintactico.Destroy }
  IF DatoInterpretado IS CAFE_Interprete2Sintactico THEN BEGIN
    IF NudilladoNITI IN
      ( DatoInterpretado as CAFE_Interprete2Sintactico ).DescriptorInterprete
    THEN FreeAndNil( DatoInterpretado );
  END;  { IF DatoInterpretado is CAFE_Interprete2Sintactico }
  Inherited Destroy;
END;   { DESTRUCTOR CAFE_Nudo2Sintactico.Destroy }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_ManejadorBasico.Create
  (       ACollection           : TCollection                   );
{ override; }
BEGIN  { CONSTRUCTOR CAFE_ManejadorBasico.Create }
  Inherited;
  HojaDefaultI                  := NIL;
  GramaticaCharByteI            := CAFE_MoldeManejadorCharByte.
                Create( CAFE_DefaultTamanoInicialCharByte )
                as CAFE_CharByte3Sintactico;
  GeneradorArbolSintacticoI     := CAFE_MoldeManejadorArbol.Create
                as CAFE_Nudo2Sintactico;
  NudilladoManejadorI           := CAFE_MoldeManejadorDatoCasilla.Create
                as CAFE_DatoNudillado;
  PaquetePredefinidoI           := CAFE_MoldeManejadorPaquete.Create
                as CAFE_Interprete2Sintactico;
  PaqueteVisibleI               := NIL;
  PaqueteIdiomaI                := CAFE_TStringList.Create;
  PaqueteIdiomaI.Sorted         := TRUE;
  PaqueteIdiomaI.Duplicates     := dupIgnore;
  PaqueteIdiomaI.CaseSensitive  := CAFE_IdentificadorUpIgualDown;
  PaqueteIdiomaI.NameValueSeparator             := CAFE_NameValueSeparator;
  PaqueteUndoI                  :=
                CAFE_TCollectionUndo.Create( Self, TCollectionItem );
  ValorBanderaSimularCalculoI   := CAFE_InicialBanderaSimularCalculo;
  ValorPreliminarSolveI         := CAFE_InicialPreliminarSolve;
  ValorMaximaIteracionIntegralOctavoImparI                      :=
                CAFE_InicialMaximaIteracionIntegralOctavoImpar;
  ValorMaximaIteracionIntegralOctavoImparFuncionI               :=
                CAFE_InicialMaximaIteracionIntegralOctavoImparFuncion;
  ValorEpsilonZeroI             := CAFE_InicialEpsilonZero;
  ValorDefaultToleranciaDeterminanteI                           :=
                CAFE_InicialToleranciaDeterminante;
END;   { CONSTRUCTOR CAFE_ManejadorBasico.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

PROCEDURE   CAFE_ManejadorBasico.ActivarModoBasico
  (     Hoja                    : CAFE_HojaCalculoBase;
        BanderaQuimico          : Boolean                               );
VAR
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyInterface                   : CAFE_InterfaceBasico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

BEGIN  { PROCEDURE CAFE_ManejadorBasico.ActivarModoBasico }
  HojaDefaultI                  := Hoja;
  GetInterfaceByStr( CAFE_GUIDInterfaceBasico, MyInterface );
  PaquetePredefinido.DefaultPredefinidos( MyInterface, BanderaQuimico );
  // CUIDADO antes de ActivarModoBasico y DefaultPredefinidos, debe existir
  // MyInterface.Actual.ID para variable Self, tener cuidado
  // al disenar futuras versiones del TStreamCollection.Add
  // aplicar primero el inherited deberia ser suficiente
END;   { PROCEDURE CAFE_ManejadorBasico.ActivarModoBasico }

FUNCTION    CAFE_ManejadorBasico.SustitucionHojaDefault
  (     NuevaHoja               : CAFE_HojaCalculoBase
                                                ) : CAFE_HojaCalculoBase;
BEGIN  { CAFE_ManejadorBasico.SustitucionHojaDefault }
  SustitucionHojaDefault        := HojaDefaultI;
  HojaDefaultI                  := NuevaHoja;
END;   { CAFE_ManejadorBasico.SustitucionHojaDefault }

FUNCTION    CAFE_ManejadorBasico.VincularPaquete
  ( CONST NuevoNombre           : CAFE_CadenaSintactica;
          NumeroControl         : LongInt                       ) : Boolean;
VAR
  PivoteNombre                  : ShortString;
  PunteroActual                 : CAFE_Interprete2Sintactico;

BEGIN  { FUNCTION CAFE_ManejadorBasico.VincularPaquete }
  IF CAFE_IdentificadorUpIgualDown
  THEN PivoteNombre             := UpperCase( NuevoNombre )
  ELSE PivoteNombre             := NuevoNombre;
  IF NOT( GramaticaCharByte.VerificarIdentificador( PivoteNombre ) )
  THEN Exit( FALSE );
  PunteroActual                 := NIL;
  REPEAT
    PunteroActual               := PaquetePredefinido.
                BusquedaNombreIdentificador( PivoteNombre );
    IF PunteroActual <> NIL THEN BEGIN
      IF [ ActivoNITI, ManejadorPrincipalNITI ] <=
                        PunteroActual.DescriptorInterprete
      THEN Exit( FALSE );
    END;  { IF PunteroActual <> }
  UNTIL PunteroActual = NIL;
  PaquetePredefinido.
        AnexarManejadorPrincipal( PivoteNombre, NumeroControl, FALSE );
  VincularPaquete               := TRUE;
END;   { PROCEDURE CAFE_ManejadorBasico.VincularPaquete }

FUNCTION    CAFE_ManejadorBasico.DesVincularPaquete
  ( CONST NombreBorrar          : CAFE_CadenaSintactica;
          NumeroControl         : LongInt                       ) : Boolean;
VAR
  PunteroActual                 : CAFE_Interprete2Sintactico;

BEGIN  { FUNCTION CAFE_ManejadorBasico.DesvincularPaquete }
  PunteroActual                 := NIL;
  REPEAT
    PunteroActual               := PaquetePredefinido.
        BusquedaNombreIdentificador( NombreBorrar, PunteroActual );
    IF PunteroActual <> NIL THEN BEGIN
      IF [ ActivoNITI, ManejadorPrincipalNITI ] <=
                        PunteroActual.DescriptorInterprete
      THEN BEGIN
        IF NOT( ManejadorSelfNITI IN PunteroActual.DescriptorInterprete )
        THEN BEGIN
          Exclude( PunteroActual.DescriptorInterprete, ActivoNITI );
          IF NumeroControl <> PunteroActual.ValorInterpretado
          THEN Exit( FALSE );
          Exit( TRUE );
        END;  { IF NOT( ManejadorSelfNITI IN ... ) }
      END;
        { IF [ ActivoNITI, ManejadorPrincipalNITI ] <= ... }
      // En el futuro probablemente se borre
    END;  { IF PunteroActual <> NIL }
  UNTIL PunteroActual = NIL;
  DesvincularPaquete            := FALSE;
END;   { FUNCTION CAFE_ManejadorBasico.DesvincularPaquete }

FUNCTION    CAFE_ManejadorBasico.EstablecerNombrePaquete
  ( CONST NuevoNombre           : CAFE_CadenaSintactica         ) : Boolean;
VAR
  PunteroActual                 : CAFE_Interprete2Sintactico;
  PivoteNombre2,
  PivoteNombre                  : ShortString;
  PivoteID                      : LongInt;

BEGIN  { FUNCTION CAFE_ManejadorBasico.EstablecerNombrePaquete }
  IF CAFE_IdentificadorUpIgualDown
  THEN PivoteNombre2            := UpperCase( NuevoNombre )
  ELSE PivoteNombre2            := NuevoNombre;
  IF NOT( GramaticaCharByte.VerificarIdentificador( PivoteNombre2 ) )
  THEN Exit( False );
  PivoteNombre                  := DisplayNombre;
  PivoteID                      := ID;
  PunteroActual                 := NIL;
  IF PivoteNombre <> '' THEN
  REPEAT
    PunteroActual               := PaquetePredefinido.
        BusquedaNombreIdentificador( PivoteNombre, PunteroActual );
    IF PunteroActual <> NIL THEN BEGIN
      IF [ ActivoNITI, ManejadorPrincipalNITI ] <=
                PunteroActual.DescriptorInterprete
      THEN BEGIN
        IF ManejadorSelfNITI IN PunteroActual.DescriptorInterprete
        THEN BEGIN
          PunteroActual.NombreIdentificador       := PivoteNombre2;
          SetDisplayNameI( PivoteNombre2 );
          IF PivoteID <> PunteroActual.ValorInterpretado
          THEN RAISE CAFE_Exception.
                  Create( 'Error numero ID manejador no concuerda' );
          Exit( TRUE );
        END ELSE Exit( FALSE );
      END;
        { IF [ ActivonITI, ManejadorPrincipalNITI ] <= ... }
    END;  { IF PunteroActual <> NIL }
  UNTIL PunteroActual = NIL;
  VincularPaquete( PivoteNombre2, PivoteID );
  Include( PaquetePredefinido.UltimoLista.DescriptorInterprete,
                                ManejadorSelfNITI );
  SetDisplayNameI( PivoteNombre2 );
  EstablecerNombrePaquete       := TRUE;
END;   { FUNCTION CAFE_ManejadorBasico.EstablecerNombrePaquete }

FUNCTION    CAFE_ManejadorBasico.
                Leer_HojaDefault                : CAFE_HojaCalculoBase;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_HojaDefault }
  Leer_HojaDefault              := HojaDefaultI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_HojaDefault }

FUNCTION    CAFE_ManejadorBasico.
                Leer_GramaticaCharByte          : CAFE_CharByte3Sintactico;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_GramaticaCharByte }
  Leer_GramaticaCharByte        := GramaticaCharByteI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_GramaticaCharByte }

FUNCTION    CAFE_ManejadorBasico.
                Leer_GeneradorArbolSintactico   : CAFE_Nudo2Sintactico;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_GeneradorArbolSintactico }
  Leer_GeneradorArbolSintactico := GeneradorArbolSintacticoI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_GeneradorArbolSintactico }

FUNCTION    CAFE_ManejadorBasico.
                Leer_NudilladoManejador         : CAFE_DatoNudillado;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_NudilladoManejador }
  Leer_NudilladoManejador       := NudilladoManejadorI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_NudilladoManejador }

FUNCTION    CAFE_ManejadorBasico.
                Leer_PaquetePredefinido         : CAFE_Interprete2Sintactico;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_PaquetePredefinido }
  Leer_PaquetePredefinido       := PaquetePredefinidoI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_PaquetePredefinido }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_ManejadorBasico.
                Leer_PaqueteVisible             : CAFE_Interprete2Sintactico;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_PaqueteVisible }
  Leer_PaqueteVisible           := PaqueteVisibleI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_PaqueteVisible }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

FUNCTION    CAFE_ManejadorBasico.
                Leer_PaqueteIdioma              : CAFE_TStringList;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_PaqueteVisible }
  Leer_PaqueteIdioma            := PaqueteIdiomaI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_PaqueteVisible }

FUNCTION    CAFE_ManejadorBasico.
                Leer_PaqueteUndo                : CAFE_TCollectionUndo;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_PaqueteUndo }
  Leer_PaqueteUndo              := PaqueteUndoI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_PaqueteUndo }

FUNCTION    CAFE_ManejadorBasico.
                        Leer_ValorBanderaSimularCalculo         : Boolean;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_ValorBanderaSimularCalculo }
  Leer_ValorBanderaSimularCalculo       := ValorBanderaSimularCalculoI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_ValorBanderaSimularCalculo }

PROCEDURE   CAFE_ManejadorBasico.Escribir_ValorBanderaSimularCalculo
  (       NuevoValor            : Boolean                               );
BEGIN  { PROCEDURE CAFE_ManejadorBasico.Escribir_ValorBanderaSimularCalculo }
  ValorBanderaSimularCalculoI           := NuevoValor;
END;   { PROCEDURE CAFE_ManejadorBasico.Escribir_ValorBanderaSimularCalculo }

FUNCTION    CAFE_ManejadorBasico.
                Leer_ValorMaximaIteracionIntegralOctavoImpar    : LongInt;
BEGIN  { FUNCTION ...Leer_ValorMaximaIteracionIntegralOctavoImpar }
  Leer_ValorMaximaIteracionIntegralOctavoImpar  :=
                ValorMaximaIteracionIntegralOctavoImparI;
END;   { FUNCTION ...Leer_ValorMaximaIteracionIntegralOctavoImpar }

PROCEDURE   CAFE_ManejadorBasico.
                Escribir_ValorMaximaIteracionIntegralOctavoImpar
  (       NuevoValor            : LongInt                               );
BEGIN  { PROCEDURE ...Escribir_ValorMaximaIteracionIntegralOctavoImpar }
  IF NOT( InRange( NuevoValor, 4, 20 ) )
  THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorDatoFueraRangoAdmisible );
  ValorMaximaIteracionIntegralOctavoImparI      := NuevoValor;
END;   { PROCEDURE ...Escribir_ValorMaximaIteracionIntegralOctavoImpar }

FUNCTION    CAFE_ManejadorBasico.
            Leer_ValorMaximaIteracionIntegralOctavoImparFuncion : LongInt;
BEGIN  { FUNCTION ...Leer_ValorMaximaIteracionIntegralOctavoImparFuncion }
  Leer_ValorMaximaIteracionIntegralOctavoImparFuncion           :=
                ValorMaximaIteracionIntegralOctavoImparFuncionI;
END;   { FUNCTION ...Leer_ValorMaximaIteracionIntegralOctavoImparFuncion }

PROCEDURE   CAFE_ManejadorBasico.
                Escribir_ValorMaximaIteracionIntegralOctavoImparFuncion
  (       NuevoValor            : LongInt                               );
BEGIN  { PROCEDURE ...ValorMaximaIteracionIntegralOctavoImparFuncion }
  IF NOT( InRange( NuevoValor, 4, 20 ) )
  THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorDatoFueraRangoAdmisible );
  ValorMaximaIteracionIntegralOctavoImparFuncionI       := NuevoValor;
END;   { PROCEDURE ...ValorMaximaIteracionIntegralOctavoImparFuncion }

FUNCTION    CAFE_ManejadorBasico.
                Leer_ValorPreliminarSolve                       : LongInt;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_ValorPreliminarSolve }
  Leer_ValorPreliminarSolve     := ValorPreliminarSolveI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_ValorPreliminarSolve }

PROCEDURE   CAFE_ManejadorBasico.Escribir_ValorPreliminarSolve
  (       NuevoValor            : LongInt                               );
BEGIN  { PROCEDURE CAFE_ManejadorBasico.Escribir_ValorPreliminarSolve }
  IF NOT( InRange( NuevoValor, 0, 1000000 ) )
  THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorDatoFueraRangoAdmisible );
  ValorPreliminarSolveI         := NuevoValor;
END;   { PROCEDURE CAFE_ManejadorBasico.Escribir_ValorPreliminarSolve }

FUNCTION    CAFE_ManejadorBasico.
                Leer_ValorDefaultToleranciaDeterminante         : Double;
BEGIN  { FUNCTION ...Leer_ValorDefaultToleranciaDeterminante }
  Leer_ValorDefaultToleranciaDeterminante               :=
                ValorDefaultToleranciaDeterminanteI;
END;   { FUNCTION ...Leer_ValorDefaultToleranciaDeterminante }

PROCEDURE   CAFE_ManejadorBasico.Escribir_ValorDefaultToleranciaDeterminante
  (       NuevoValor            : Double                                );
BEGIN  { PROCEDURE ...Escribir_ValorDefaultToleranciaDeterminante }
  IF NOT( InRange( NuevoValor, 0, 1E100 ) )
  THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorDatoFueraRangoAdmisible );
  ValorDefaultToleranciaDeterminanteI           := NuevoValor;
END;   { PROCEDURE ...Escribir_ValorDefaultToleranciaDeterminante }

FUNCTION    CAFE_ManejadorBasico.
                Leer_ValorEpsilonZero                           : Double;
BEGIN  { FUNCTION CAFE_ManejadorBasico.Leer_ValorEpsilonZero }
  Leer_ValorEpsilonZero         := ValorEpsilonZeroI;
END;   { FUNCTION CAFE_ManejadorBasico.Leer_ValorEpsilonZero }

PROCEDURE   CAFE_ManejadorBasico.Escribir_ValorEpsilonZero
  (       NuevoValor            : Double                                );
BEGIN  { PROCEDURE CAFE_ManejadorBasico.Escribir_ValorEpsilonZero }
  IF NOT( InRange( NuevoValor, 0, 1E100 ) )
  THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorDatoFueraRangoAdmisible );
  ValorEpsilonZeroI             := NuevoValor;
END;   { PROCEDURE CAFE_ManejadorBasico.Escribir_ValorEpsilonZero }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
DESTRUCTOR  CAFE_ManejadorBasico.Destroy;
{ virtual; }

BEGIN  { DESTRUCTOR CAFE_ManejadorBasico.Destroy }
  HojaDefaultI                  := NIL;
  FreeAndNil( GramaticaCharByteI );
  FreeAndNil( GeneradorArbolSintacticoI );
  FreeAndNil( NudilladoManejadorI );
  FreeAndNil( PaquetePredefinidoI );
  FreeAndNil( PaqueteVisibleI );
  FreeAndNil( PaqueteIdiomaI );
  FreeAndNil( PaqueteUndoI );
  inherited;
END;   { DESTRUCTOR CAFE_ManejadorBasico.Destroy }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_DatoExtendido.Create;
BEGIN  { CONSTRUCTOR CAFE_ModeloExtendido.Create }
  ModeloExtendido               := CAFE_DatoExtendido;
  DescriptorExtendido           := TVarRecNull;
END;   { CONSTRUCTOR CAFE_ModeloExtendido.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_DatoExtendido.PeticionSimilar          : CAFE_DatoExtendido;
{ virtual; }
VAR
  PivoteResultado               : CAFE_DatoExtendido;

BEGIN  { FUNCTION CAFE_DatoExtendido.PeticionSimilar }
  PivoteResultado               := ModeloExtendido.Create;
  PivoteResultado.DescriptorExtendido           := AsimilarDescriptor;
  PeticionSimilar               := PivoteResultado;
END;   { FUNCTION CAFE_DatoNudillado.PeticionSimilar }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_DatoExtendido.AsimilarDescriptor               : TVarRec;
{ virtual; }
BEGIN  { FUNCTION CAFE_DatoExtendido.AsimilarDescriptor }
  AsimilarDescriptor                            := DescriptorExtendido;
END;   { FUNCTION CAFE_DatoExtendido.AsimilarDescriptor }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
DESTRUCTOR  CAFE_DatoExtendido.Destroy;
{ virtual; }
BEGIN  { DESTRUCTOR CAFE_DatoExtendido.Destroy }
  WITH DescriptorExtendido DO
    CASE DescriptorExtendido.vType  OF
        // No he verificado el buen funcionamiento de todos los DisposeANDNil
      vtExtended        : IF VExtended <> NIL THEN Dispose( VExtended );
      vtString          : Dispose( VString );
      vtPChar           : VPChar              := NIL;
      vtObject          : VObject             := NIL;
      vtCurrency        : IF VCurrency <> NIL THEN Dispose( VCurrency );
      vtVariant         : IF VVariant <> NIL THEN Dispose( VVariant );
      vtInt64           : IF VInt64 <> NIL THEN Dispose( VInt64 );
      vtQWord           : IF VQWord <> NIL THEN Dispose( VQWord );
    END;  { CASE DescriptorExtendido }
  DescriptorExtendido           := TVarRecNull;
END;   { DESTRUCTOR CAFE_DatoExtendido.Destroy }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

CONSTRUCTOR CAFE_DatoNudillado.Create;
BEGIN  { CONSTRUCTOR CAFE_DatoNudillado.Create }
  Inherited Create;
  ModeloExtendido               := CAFE_DatoNudillado;
  BanderaStandard               := TRUE;
  BanderaMacroFuncional         := FALSE;
  BanderaPeticionNudillar       := FALSE;
  BanderaPeticionCalculo        := FALSE;
  TipoReturn                    := Null;
  FuncionNudillado              := NIL;
  MarcaCicloSintactico          := 0;
  MacroParametro                := [];
  CicloConteo                   := 0;
  CicloConteoMaximo             := CAFE_CicloConteoMaximoDefault;
  NombreParametroUno            := '';
  NombreParametroDos            := '';
  NombreParametroTres           := '';
  ValorPruebaUno                := 0;
  ValorPruebaDos                := 0;
  ValorPruebaTres               := 0;
END;   { CONSTRUCTOR CAFE_DatoNudillado.Create }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_DatoNudillado.PeticionSimilar          : CAFE_DatoExtendido;
{ virtual; }
VAR
  PivoteResultado               : CAFE_DatoNudillado;

BEGIN  { FUNCTION CAFE_DatoNudillado.PeticionSimilar }
  PivoteResultado               :=
                ModeloExtendido.Create as CAFE_DatoNudillado;
  PivoteResultado.DescriptorExtendido           := AsimilarDescriptor;
  PivoteResultado.BanderaStandard               := BanderaStandard;
  PivoteResultado.BanderaMacroFuncional         := BanderaMacroFuncional;
  PivoteResultado.BanderaPeticionNudillar       := TRUE;
  PivoteResultado.BanderaPeticionCalculo        := TRUE;
  PivoteResultado.TipoReturn                    := TipoReturn;
  PivoteResultado.FuncionNudillado              := NIL;
  PivoteResultado.MacroParametro                := MacroParametro;
  PivoteResultado.MarcaCicloSintactico          := 0;
  PivoteResultado.CicloConteo                   := 0;
  PivoteResultado.CicloConteoMaximo             := CicloConteoMaximo;
  PivoteResultado.NombreParametroUno            := NombreParametroUno;
  PivoteResultado.NombreParametroDos            := NombreParametroDos;
  PivoteResultado.NombreParametroTres           := NombreParametroTres;
  PivoteResultado.ValorPruebaUno                := ValorPruebaUno;
  PivoteResultado.ValorPruebaDos                := ValorPruebaDos;
  PivoteResultado.ValorPruebaTres               := ValorPruebaTres;
  PeticionSimilar               := PivoteResultado;
END;   { FUNCTION CAFE_DatoNudillado.PeticionSimilar }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

FUNCTION    CAFE_DatoNudillado.Leer_CantidadParametros          : LongInt;
{ virtual; }
BEGIN  { FUNCTION CAFE_DatoNudillado.Leer_CantidadParametros }
  IF BanderaMacroFuncional THEN BEGIN
    IF Real1DHCGM IN MacroParametro
    THEN Leer_CantidadParametros        := 1;
    IF Real2DHCGM IN MacroParametro
    THEN Leer_CantidadParametros        := 2;
    IF Real3DHCGM IN MacroParametro
    THEN Leer_CantidadParametros        := 3;
  END ELSE BEGIN  { IF BanderaMacroFuncional ELSE }
    Leer_CantidadParametros     := 0;
  END;            { IF BanderaMacroFuncional ELSE }
END;   { FUNCTION CAFE_DatoNudillado.Leer_CantidadParametros }

PROCEDURE   CAFE_DatoNudillado.Escribir_CantidadParametros
  (       TotPar                : LongInt                       );
{ virtual; }
BEGIN  { PROCEDURE CAFE_DatoNudillado.Escribir_CantidadParametros }
  MacroParametro
  -=            [ Real1DHCGM, Real2DHCGM, Real3DHCGM ];
  BanderaMacroFuncional         := TRUE;
  CASE TotPar OF
    0           : BEGIN
                    BanderaMacroFuncional       := FALSE;
                  END;  { CASE 0 }
    1           : Include( MacroParametro, Real1DHCGM );
    2           : Include( MacroParametro, Real2DHCGM );
    3           : Include( MacroParametro, Real3DHCGM );
    ELSE RAISE CAFE_PipeHaltException.Create
        ( 'Nivel actual no permite exceso de parametros sobre 3' );
  END;  { CASE TotPar }
END;   { PROCEDURE CAFE_DatoNudillado.Escribir_CantidadParametros }

DESTRUCTOR  CAFE_DatoNudillado.Destroy;
BEGIN  { DESTRUCTOR CAFE_DatoNudillado.Destroy }
  Inherited Destroy;
  BanderaStandard               := TRUE;
  BanderaMacroFuncional         := FALSE;
  BanderaPeticionNudillar       := FALSE;
  BanderaPeticionCalculo        := FALSE;
  TipoReturn                    := Null;
  FreeAndNil( FuncionNudillado );
  MarcaCicloSintactico          := 0;
  MacroParametro                := [];
  CicloConteo                   := 0;
  CicloConteoMaximo             := CAFE_CicloConteoMaximoDefault;
  NombreParametroUno            := '';
  NombreParametroDos            := '';
  NombreParametroTres           := '';
END;   { DESTRUCTOR CAFE_DatoNudillado.Destroy }

OPERATOR    = ( CONST Left, Right       : TVarRec                       )
MyResult    : Boolean;
BEGIN  { OPERATOR = ( TVarRec, TVarRec ) }
  IF Left.VType <> Right.VType
  THEN MyResult                         := FALSE
  ELSE BEGIN  { IF Left.VType <> Right.VType ELSE }
    CASE Left.VType OF
      vtInteger         : MyResult      := Left.vInteger = Right.vInteger;
      vtBoolean         : MyResult      := Left.vBoolean = Right.vBoolean;
      vtChar            : MyResult      := Left.vChar = Right.vChar;
      vtWideChar        : MyResult      := Left.vWideChar = Right.vWideChar;
      vtExtended        : MyResult      := Left.vExtended = Right.vExtended;
      vtString          : MyResult      := Left.vString = Right.vString;
      vtPointer         : MyResult      := Left.vPointer = Right.vPointer;
      vtPChar           : MyResult      := Left.vPChar = Right.vPChar;
      vtObject          : MyResult      := Left.vObject = Right.vObject;
      vtClass           : MyResult      := Left.vClass = Right.vClass;
      vtPWideChar       : MyResult      := Left.vPWideChar = Right.vPWideChar;
      vtAnsiString      : MyResult := Left.vAnsiString = Right.vAnsiString;
      vtCurrency        : MyResult      := Left.vCurrency = Right.vCurrency;
      vtVariant         : MyResult      := Left.vVariant = Right.vVariant;
      vtInterface       : MyResult      := Left.vInterface = Right.vInterface;
      vtWideString      : MyResult := Left.vWideString = Right.vWideString;
      vtInt64           : MyResult      := Left.vInt64 = Right.vInt64;
      vtQWord           : MyResult      := Left.vQWord = Right.vQWord;
    END;  { CASE Left.VType }
  END;        { IF Left.VType <> Right.VType ELSE }
END;   { OPERATOR = ( TVarRec, TVarRec ) }

FUNCTION    NombreCasillaHoja
  ( CONST NombrePrueba                  : ShortString           ) : Boolean;
VAR
  Posicion                      : Byte;
  PivoteResultado               : Boolean;

LABEL
  IrFinal;

BEGIN  { FUNCTION NombreCasillaHoja }
  PivoteResultado               := FALSE;
  IF Length( NombrePrueba ) < 2 THEN GOTO IrFinal;
  Posicion                      := 1;
  IF NombrePrueba[ 1 ] = CAFE_ReferenciaAbsoluta THEN Inc( Posicion );
  IF NOT( NombrePrueba[ Posicion] IN CAFE_LetrasHoja ) THEN GOTO IrFinal;
  REPEAT
    Inc( Posicion );
    IF Posicion >= Length( NombrePrueba ) THEN GOTO IrFinal;
  UNTIL NOT( NombrePrueba[ Posicion ] IN CAFE_LetrasHoja );
  IF NombrePrueba[ Posicion ] = CAFE_ReferenciaAbsoluta THEN Inc( Posicion );
  WHILE ( Posicion < Length( NombrePrueba ) ) DO BEGIN
    IF NOT( NombrePrueba[ Posicion ] IN CAFE_NumerosHoja ) THEN GOTO IrFinal;
    Inc( Posicion );
  END;
  IF NOT( NombrePrueba[ Posicion ] IN CAFE_NumerosHoja ) THEN GOTO IrFinal;
  PivoteResultado               := TRUE;
IrFinal:
  NombreCasillaHoja             := PivoteResultado;
END;   { FUNCTION NombreCasillaHoja }

  { DOBLE CODIGO }
  {$IFDEF CPUI386_CPU32}
FUNCTION    NombreCasillaHoja
  ( CONST NombrePrueba                  : ShortString;
    OUT   DolarColumna                  : Boolean;
    OUT   Columna                       : LongInt;
    OUT   DolarFila                     : Boolean;
    OUT   Fila                          : LongInt               ) : Boolean;
                                pascal; assembler;
CONST
  Parametros                    = 5*CPUBase;

VAR
  Acumulador                    : LongInt;
  BaseLetra                     : LongInt;

LABEL
  NoDolar1,
  FinDolar1,
  CicloLetra,
  IrNumero,
  NoDolar2,
  FinDolar2,
  CicloNumero,
  SalidaFalsa,
  SalidaComun;

ASM    { FUNCTION NombreCasillaHoja }
                                        { Funcion Principal             }
                                        { %ecx  = TamanoCadena          }
                                        { %edi  = ^Char en cadena       }
                                        { %esi  = Pos en cadena         }
  movl  NombrePrueba, %edi              { Direccion del ShortString     }
  xorl  %ecx, %ecx                      { Cargamos el tamano            }
  movb  (%edi), %cl                     { %ecx := NombrePrueba[ 0 ]     }
  cmpl  $1, %ecx                        { Su tamano debe ser            }
  jle   SalidaFalsa                     {   al menos 2 caracteres       }
  inc   %edi                            { Para comenzar nos ubicamos    }
  movl  $0, %esi                        {   en la primera posicion      }
  movl  DolarColumna, %ebx              { Comienza con dolar?           }
  movb  (%edi), %al                     {   en tal caso es necesario    }
  cmp   $CAFE_ReferenciaAbsoluta, %al   {   informar en DolarColumna    }
  jne   NoDolar1                        {   ademas hay que incrementar  }
  movb  True, (%ebx)                    {   a Pos 2 y corre el puntero  }
  inc   %edi                            {   por tanto inc %edi y %esi   }
  inc   %esi                            {   surge un IF ELSE            }
  jmp   FinDolar1                       {   segun el dolar              }
NoDolar1:
  movb  False, (%ebx)                   { El caso FALSE es facil        }
FinDolar1:
  movl  $0, Acumulador                  { Calcular la columna           }
  movl  $0, BaseLetra
  xorl  %ebx, %ebx                      { Ahora es necesario            }
  movb  (%edi), %bl                     {   revisar el intervalo        }
  sub   $'A', %bl                       {   'A'..'Z' admisible          }
  js    SalidaFalsa                     {   al menos una vez            }
  cmp   $CAFE_TotalLetras, %ebx         { Si ni una letra es FALSE      }
  jg    SalidaFalsa                     {   por ello revisa antes       }
CicloLetra:
  movl  Acumulador, %eax                { Se acumula facil              }
  movl  $CAFE_TotalLetras, %edx         { Segun CAFE_TotalLetras        }
  mul   %edx                            {   que actua como Base         }
  addl  %ebx, %eax                      { Anterior*Base+Nuevo           }
  cmpl  $CAFE_TamanoHojaSeguridad, %eax { Para evitar excesos           }
  jg    SalidaFalsa                     {   se compara con un tope      }
  movl  %eax, Acumulador                { Si no sigue al siguiente      }
  movl  $CAFE_TotalLetras, %eax         { BaseLetra es una correccion   }
  mul   BaseLetra                       {   pues la numeracion          }
  movl  %eax, BaseLetra                 {   no tiene cero derecho       }
  inc   %edi                            { Requerimos un desplazamiento  }
  inc   %esi                            {   si se supera %ecx           }
  cmpl  %esi, %ecx                      {   el identificador es FALSE   }
  jl    SalidaFalsa                     {   pues termina en numero      }
  xorl  %ebx, %ebx                      { Ahora es necesario            }
  movb  (%edi), %bl                     {   revisar el intervalo        }
  sub   $'A', %bl                       {   'A'..'Z' admisible          }
  js    IrNumero                        {   nuevamente                  }
  cmp   $(CAFE_TotalLetras-1), %ebx     {   si la prueba falla se hace  }
  jg    IrNumero                        {   salto a IrNumero            }
  inc   BaseLetra                       { Prepara siguiente BaseLetra   }
  jmp   CicloLetra                      { Todavia detecta letras        }
IrNumero:
  movl  Columna, %ebx                   { Columna := Acumulador         }
  movl  Acumulador, %eax                {   puesto que es VAR           }
  addl  BaseLetra, %eax                 { Correcion sistema letra       }
  movl  %eax, (%ebx)                    {   se lee direccion            }
  movl  DolarFila, %ebx                 { Ahora direccion de DolarFila  }
  movb  (%edi), %al                     {   pues es tipo VAR            }
  cmp   $CAFE_ReferenciaAbsoluta, %al   { Informar en DolarFila         }
  jne   NoDolar2                        {   ademas hay que incrementar  }
  movb  True, (%ebx)                    {   Pos y corre el puntero      }
  inc   %edi                            {   por tanto inc %edi y %esi   }
  inc   %esi                            {   surge un IF ELSE            }
  jmp   FinDolar2                       {   segun el dolar              }
NoDolar2:
  movb  False, (%ebx)                   { El caso FALSE es facil        }
FinDolar2:
  cmp   %esi, %ecx                      { Cabe la posibilidad           }
  jle   SalidaFalsa                     {   que el dolar fuera el fin   }
  movl  $0, Acumulador                  { Inicializa el Acumulador      }
CicloNumero:
  xorl  %ebx, %ebx                      { Revisa el numero final        }
  movb  (%edi), %bl                     {   que se supone una secuencia }
  sub   $'0', %bl                       {   de unicamente digitos       }
  js    SalidaFalsa                     {   al menos uno                }
  cmp   $9, %bl                         { Desde '0' a '9' son 10        }
  jg    SalidaFalsa                     {   fuera de rango es FALSE     }
  movl  Acumulador, %eax                { Ahora a calcular el numero    }
  movl  $10, %edx                       { Segun base 10                 }
  mul   %edx                            {   que actua como Base         }
  addl  %ebx, %eax                      { Anterior*Base+Nuevo           }
  cmpl  $CAFE_TamanoHojaSeguridad, %eax { Para evitar excesos           }
  jg    SalidaFalsa                     {   se compara con un tope      }
  movl  %eax, Acumulador                { Si no sigue al siguiente      }
  inc   %edi                            { Requerimos un desplazamiento  }
  inc   %esi                            {   se repite el ciclo          }
  cmp   %esi, %ecx                      {   hasta verificar todos los   }
  jg    CicloNumero                     {   caracteres que quedan       }
  dec   Acumulador                      { Base 0 internamente no 1      }
  js    SalidaFalsa                     { No existe casilla 0 en Hoja   }
  movl  Fila, %ebx                      { Fila  := Acumulador           }
  movl  Acumulador, %eax                {   y ya es hora de terminar    }
  movl  %eax, (%ebx)                    { Simplemente manda TRUE        }
  movb  True, __Result                  {   a dos salidas posibles      }
  movl  True, %eax                      {   __Result y %eax prudencial  }
  jmp   SalidaComun                     { Y nos vamos                   }
SalidaFalsa:
  movl  DolarColumna, %eax              { El caso FALSE anula           }
  movb  False, (%eax)                   {   todas las salidas           }
  movl  Columna, %eax                   {   asignando ceros y FALSE     }
  movl  $0, (%eax)                      {   puesto que son tipo OUT     }
  movl  DolarFila, %eax                 {   carga direccion y luego     }
  movb  False, (%eax)                   {   envia el valor (%eax)       }
  movl  Fila, %eax                      {   DolarFila, DolarColumna,    }
  movl  $0, (%eax)                      {   Fila, Columna se finalizan  }
  movb  False, __Result                 { Doble salida funcional        }
  movl  False, %eax                     { para evitar problemas         }
SalidaComun:
  leave                                 { Salida comun tipica           }
  ret   $Parametros                     { Salida comun tipica           }
END;   { FUNCTION NombreCasillaHoja }
  {$ELSE}
FUNCTION    NombreCasillaHoja
  ( CONST NombrePrueba                  : ShortString;
    OUT   DolarColumna                  : Boolean;
    OUT   Columna                       : LongInt;
    OUT   DolarFila                     : Boolean;
    OUT   Fila                          : LongInt               ) : Boolean;
VAR
  BaseLetra                     : LongInt;
  Posicion                      : Byte;

LABEL
  IrFinal;

BEGIN  { FUNCTION NombreCasillaHoja }
  IF Length( NombrePrueba ) < 2 THEN GOTO IrFinal;
  Posicion                      := 1;
  IF NombrePrueba[ 1 ] = CAFE_ReferenciaAbsoluta THEN BEGIN
    Inc( Posicion );
    DolarColumna                := TRUE;
  END ELSE BEGIN  { IF NombrePrueba[ 1 ] = CAFE_ReferenciaAbsoluta ELSE }
    DolarColumna                := FALSE;
  END;            { IF NombrePrueba[ 1 ] = CAFE_ReferenciaAbsoluta ELSE }
  IF NOT( NombrePrueba[ Posicion] IN CAFE_LetrasHoja ) THEN GOTO IrFinal;
  Columna                       := 0;
  BaseLetra                     := 0;
  REPEAT
    BaseLetra
    *=                  CAFE_TotalLetras;
    Inc( BaseLetra );
    Columna
    *=                  CAFE_TotalLetras;
    Columna
    +=                  Ord( NombrePrueba[ Posicion ] )-Ord( 'A' );
    Inc( Posicion );
    IF Posicion > Length( NombrePrueba ) THEN GOTO IrFinal;
  UNTIL NOT( NombrePrueba[ Posicion ] IN CAFE_LetrasHoja );
  Columna
  +=                    Pred( BaseLetra );
  IF NombrePrueba[ Posicion ] = CAFE_ReferenciaAbsoluta THEN BEGIN
    Inc( Posicion );
    DolarFila                   := TRUE;
  END ELSE BEGIN  { IF NombrePrueba[ Posicion ] = ... ELSE }
    DolarFila                   := FALSE;
  END;            { IF NombrePrueba[ Posicion ] = ... ELSE }
  Fila                          := 0;
  WHILE ( Posicion < Length( NombrePrueba ) ) DO BEGIN
    IF NOT( NombrePrueba[ Posicion ] IN CAFE_NumerosHoja ) THEN GOTO IrFinal;
    Fila
    *=                  10;
    Fila
    +=                  Ord( NombrePrueba[ Posicion ] )-Ord( '0' );
    Inc( Posicion );
  END;  { IF ( Posicion < Length( NombrePrueba ) ) }
  IF NOT( NombrePrueba[ Posicion ] IN CAFE_NumerosHoja ) THEN GOTO IrFinal;
  Fila
  *=                    10;
  Fila
  +=                    Ord( NombrePrueba[ Posicion ] )-Ord( '0' );
  IF Fila = 0 THEN GOTO IrFinal;
  Dec( Fila );
  NombreCasillaHoja             := TRUE;
  Exit;
IrFinal:
  NombreCasillaHoja             := FALSE;
  Columna                       := 0;
  Fila                          := 0;
  DolarColumna                  := FALSE;
  DolarFila                     := FALSE;
END;   { FUNCTION NombreCasillaHoja }
  {$ENDIF}
  { DOBLE CODIGO }

  { DOBLE CODIGO }
  {$IFDEF CPUI386_CPU32}
PROCEDURE   GenerarNombreCasillaHoja
  ( OUT   NombreCasilla                 : ShortString;
          DolarColumna                  : Boolean;
          Columna                       : LongInt;
          DolarFila                     : Boolean;
          Fila                          : LongInt                       );
                                pascal; assembler;
CONST
  Parametros                    = 5*CPUBase;

VAR
  PivoteCadena          : ShortString;
  TotalCicloLetra       : Byte;

LABEL
  CicloNumero,
  SinDolar1,
  CicloTamanoLetra,
  FinCicloTamanoLetra,
  CicloLetra,
  SinDolar2;

ASM    { PROCEDURE GenerarNombreCasillaHoja }
                                        { Funcion Principal             }
                                        { %edi  := Final PivoteCadena   }
                                        {    se llena en orden inverso  }
                                        { %esi  := Total Bytes en %edi  }
  lea   PivoteCadena, %edi              { %edi  := @PivoteCadena        }
  movb  $255, (%edi)                    { Para depuracion facil         }
  addl  $255, %edi                      { %edi  := @PivoteCadena[255]   }
  movl  $0, %esi                        { %esi  := 0 bytes utiles       }
  movl  Fila, %eax                      { Fila se transforma en         }
  inc   %eax                            {   String mediante DIV MOD     }
  movl  $10, %ecx                       {   en base 10                  }
CicloNumero:
  xor   %edx, %edx                      { Prepara %edx                  }
  div   %ecx                            { DIV en %eax y MOD en %edx     }
  addl  $'0', %edx                      { %edx  := CHR %edx             }
  movb  %dl, (%edi)                     {    y se envia a %edi          }
  dec   %edi                            {    que se recorre inverso     }
  inc   %esi                            {    y total de Bytes en %esi   }
  cmp   $0, %eax                        { Si no hay residuo             }
  jnz   CicloNumero                     {    es el fin de ciclo         }
  movb  DolarFila, %al                  { Si la Fila tiene signo Dolar  }
  cmpb  True, %al                       {    se agrega el '$'           }
  jne   SinDolar1                       {    y se actualizan los        }
  movb  $CAFE_ReferenciaAbsoluta, (%edi)
                                        {    valores de %edi y %esi     }
  dec   %edi                            {    si False se ignora         }
  inc   %esi                            {    si True copia el dolar     }
SinDolar1:
  movl  $0, %eax                        { La base letra requiere un     }
  movb  %al, TotalCicloLetra            { Inicializa TotalCicloLetra    }
  movl  Columna, %ebx                   {    sistema diferente al de    }
  movl  $CAFE_TotalLetras, %ecx         {    base corriente             }
  movl  $CAFE_TotalLetras, %eax         { Inicializa el conteo          }
CicloTamanoLetra:
  inc   TotalCicloLetra                 { Por ejemplo AA no es cero     }
  subl  %eax, %ebx                      {    aunque A sola si es cero   }
  js    FinCicloTamanoLetra             {    en un sistema de base      }
  mul   %ecx                            {    numerica seria AA+BA       }
  jmp   CicloTamanoLetra                {    y AAAA seria AAAA+BBBA     }
FinCicloTamanoLetra:
  addl  %ebx, %eax                      { Por eso restamos BB...A       }
  movl  %ecx, %ebx                      {    segun el tamano calculado  }
  movzb TotalCicloLetra, %ecx           {    en TotalCicloLetra         }
CicloLetra:
  xor   %edx, %edx                      { Prepara %edx                  }
  div   %ebx                            { Hecha la resta ahora si es    }
  addl  $'A', %edx                      {    un sistema de base         }
  movb  %dl, (%edi)                     {    numerica usual por MOD DIV }
  dec   %edi                            {    y ahora el 'A' a la        }
  inc   %esi                            {    a la derecha vale 0        }
  loop  CicloLetra                      {    pero hay que conocer %ecx  }
  movb  DolarColumna, %al               { Quiero un Dolar en Columna    }
  cmpb  True, %al                       {    pues si es TRUE            }
  jne   SinDolar2                       {    se le agrega como usual    }
  movb  $CAFE_ReferenciaAbsoluta, (%edi)
                                        { Aqui el dolar                 }
  dec   %edi                            { Retrocedemos el puntero       }
  inc   %esi                            {   y un caracter mas           }
SinDolar2:
  movl  %esi, %ecx                      { Prepara el REP en %ecx        }
  movb  %cl, (%edi)
  movl  NombreCasilla, %esi             {   la salida en %ESI           }
  xchg  %esi, %edi                      {   asi que cambiamos papeles   }
  inc   %ecx                            { La cadena mas String[0]       }
  cld                                   {   en direccion usual          }
  REPB  MOVSB                           {   y listo se transfiere       }
  leave                                 { Salida comun tipica           }
  ret   $Parametros                     { Salida comun tipica           }
END;   { PROsCEDURE GenerarNombreCasillaHoja }
  {$ELSE}
  {$HINTS               OFF     }
PROCEDURE   GenerarNombreCasillaHoja
  ( OUT   NombrePrueba                  : ShortString;
          DolarColumna                  : Boolean;
          Columna                       : LongInt;
          DolarFila                     : Boolean;
          Fila                          : LongInt                       );
VAR
  FactorLetra,
  RecorreLetra,
  TotalLetra,
  Residuo                       : LongInt;

BEGIN  { PROCEDURE GenerarNombreCasillaHoja }
  NombrePrueba                  := '';
  Inc( Fila );
  WHILE ( Fila <> 0 ) DO BEGIN
    DivMod( Fila, 10, Fila, Residuo );
    NombrePrueba                := Chr( Residuo+Ord( '0' ) )+NombrePrueba;
  END;  { WHILE Fila <> 0 }
  IF DolarFila
  THEN NombrePrueba             := CAFE_ReferenciaAbsoluta+NombrePrueba;
  FactorLetra       := CAFE_TotalLetras;
  TotalLetra        := 1;
  WHILE Columna >= FactorLetra DO BEGIN
    Inc( TotalLetra );
    Columna
    -=          FactorLetra;
    FactorLetra
    *=          CAFE_TotalLetras;
  END;  { WHILE Columna >= FactorLetra }
  FOR RecorreLetra := 1 TO TotalLetra DO BEGIN
    DivMod( Columna, CAFE_TotalLetras, Columna, Residuo );
    NombrePrueba                := Chr( Residuo+Ord( 'A' ) )+NombrePrueba;
  END;  { FOR RecorreLetra }
  IF DolarColumna
  THEN NombrePrueba             := CAFE_ReferenciaAbsoluta+NombrePrueba;
END;   { PROCEDURE GenerarNombreCasillaHoja }
  {$HINTS               ON      }
  {$ENDIF}
  { DOBLE CODIGO }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_HojaCalculoBase.Create
  (       ACollection           : TCollection                           );
{ override; }
BEGIN  { CONSTRUCTOR CAFE_HojaCalculoBase.Create }
// Sustituir el ADD, en TStreamCollection por uno parametrico
  Inherited;
  IF ACollection = NIL THEN
  RAISE CAFE_Exception.Create( 'Debe indicar una coleccion para la Hoja' );
  FilasEnHoja                   := 0;
  ColumnasEnHoja                := 0;
  DescriptoresHoja              := CAFE_DescriptoresDefaultHoja;
  MoldeGeneradorHoja            := CAFE_HojaCalculoBase;
END;   { CONSTRUCTOR CAFE_HojaCalculoBase.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_HojaCalculoBase.Create
  (       ACollection           : TStreamCollection;
          Filas, Columnas       : LongInt                               );
VAR
  RecorreFila,
  RecorreColumna                : LongInt;

BEGIN  { CONSTRUCTOR CAFE_HojaCalculoBase.Create }
  TStreamCollectionItem.Create( ACollection );
  FilasEnHoja                   := Filas;
  ColumnasEnHoja                := Columnas;
  FormatosDefinidosCasilla      :=
                CAFE_TCollectionFormatoCasilla.Create( Self );
  SetLength( FormatoFila, FilasEnHoja );
  SetLength( FormatoColumna, ColumnasEnHoja );
  SetLength( FormatoHoja, FilasEnHoja, ColumnasEnHoja );
  SetLength( VariantHoja, FilasEnHoja, ColumnasEnHoja );
  SetLength( SintacticaHoja, FilasEnHoja, ColumnasEnHoja );
  FOR RecorreFila := Low( FormatoFila ) TO High( FormatoFila )
  DO FormatoFila[ RecorreFila ]         := NIL;
  FOR RecorreColumna := Low( FormatoColumna ) TO High( FormatoColumna )
  DO FormatoColumna[ RecorreColumna ]   := NIL;
  FOR RecorreFila := Low( FormatoHoja ) TO High( FormatoHoja ) DO BEGIN
    FOR RecorreColumna := Low( FormatoHoja[ RecorreFila ] ) TO
                          High( FormatoHoja[ RecorreFila ] ) DO BEGIN
      FormatoHoja[ RecorreFila ][ RecorreColumna ]      := NIL;
      VariantHoja[ RecorreFila ][ RecorreColumna ]      := Null;
      SintacticaHoja[ RecorreFila ][ RecorreColumna ]   := NIL;
    END;  { FOR RecorreColumna }
  END;  { FOR RecorreFila }
  DescriptoresHoja              := CAFE_DescriptoresDefaultHoja;
  MoldeGeneradorHoja            := CAFE_HojaCalculoBase;
END;   { CONSTRUCTOR CAFE_HojaCalculoBase.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

FUNCTION    CAFE_HojaCalculoBase.
                PeticionHojaSimilar             : CAFE_HojaCalculoBase;
{ virtual; }
VAR
  PivoteHoja                    : CAFE_HojaCalculoBase;
  Fila,
  Columna                       : LongInt;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.PeticionHojaSimilar }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  PivoteHoja                    :=
        MoldeGeneradorHoja.Create( NIL, FilasEnHoja, ColumnasEnHoja );
  // Se copia con el mismo nombre, esto podria no ser conveniente
  PivoteHoja.DescriptoresHoja   := DescriptoresHoja;
  FOR Fila := 0 TO Pred( FilasEnHoja ) DO BEGIN
    PivoteHoja.FormatoFila[ Fila ]        := FormatoFila[ Fila ];
  END;  { FOR Fila }
  FOR Columna := 0 TO Pred( ColumnasEnHoja ) DO BEGIN
    PivoteHoja.FormatoColumna[ Columna ]  := FormatoColumna[ Columna ];
  END;  { FOR Columna }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  FOR Fila := 0 TO Pred( FilasEnHoja ) DO BEGIN
    FOR Columna := 0 TO Pred( ColumnasEnHoja ) DO BEGIN
      IF SintacticaHoja[ Fila ][ Columna ] <> NIL THEN BEGIN
        PivoteHoja.SintacticaHoja[ Fila ][ Columna ]    :=
                SintacticaHoja[ Fila ][ Columna ].PeticionSimilar;
      END;  { IF SintacticaHoja[ Fila ][ Columna ] <> NIL }
      PivoteHoja.VariantHoja[ Fila ][ Columna ] :=
                                VariantHoja[ Fila ][ Columna ];
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
      PivoteHoja.FormatoHoja[ Fila ][ Columna ] :=
                                FormatoHoja[ Fila ][ Columna ];
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
    END;  { FOR Fila }
  END;  { FOR Columna }
  PivoteHoja.FormatosDefinidosCasilla           :=
                        FormatosDefinidosCasilla.PeticionFormatoSimilar;
  PeticionHojaSimilar           := PivoteHoja;
END;   { FUNCTION CAFE_HojaCalculoBase.PeticionHojaSimilar }

FUNCTION    CAFE_HojaCalculoBase.
                PeticionHojaSimilar
  (       NuevoTamanoFila       : LongInt;
          NuevoTamanoColumna    : LongInt       ) : CAFE_HojaCalculoBase;
{ virtual; }
VAR
  PivoteHoja                    : CAFE_HojaCalculoBase;
  Fila,
  Columna                       : LongInt;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.PeticionHojaSimilar }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  PivoteHoja                    :=
        MoldeGeneradorHoja.Create
        ( Collection as TStreamCollection,
                NuevoTamanoFila, NuevoTamanoColumna );
  // Se copia con el mismo nombre, esto podria no ser conveniente
  PivoteHoja.DescriptoresHoja   := DescriptoresHoja;
  FOR Fila := 0 TO Pred( Min( FilasEnHoja, NuevoTamanoFila ) ) DO BEGIN
    PivoteHoja.FormatoFila[ Fila ]        := FormatoFila[ Fila ];
  END;  { FOR Fila }
  FOR Columna := 0 TO Pred( Min( ColumnasEnHoja, NuevoTamanoColumna ) )
  DO BEGIN
    PivoteHoja.FormatoColumna[ Columna ]  := FormatoColumna[ Columna ];
  END;  { FOR Columna }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  FOR Fila := 0 TO Pred( Min( FilasEnHoja, NuevoTamanoFila ) ) DO BEGIN
    FOR Columna := 0 TO Pred( Min( ColumnasEnHoja, NuevoTamanoColumna ) )
    DO BEGIN
      IF SintacticaHoja[ Fila ][ Columna ] <> NIL THEN BEGIN
        PivoteHoja.SintacticaHoja[ Fila ][ Columna ]    :=
                SintacticaHoja[ Fila ][ Columna ].PeticionSimilar;
      END;  { IF SintacticaHoja[ Fila ][ Columna ] <> NIL }
      PivoteHoja.VariantHoja[ Fila ][ Columna ] :=
                                VariantHoja[ Fila ][ Columna ];
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
      PivoteHoja.FormatoHoja[ Fila ][ Columna ] :=
                                FormatoHoja[ Fila ][ Columna ];
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
    END;  { FOR Fila }
  END;  { FOR Columna }
  PeticionHojaSimilar           := PivoteHoja;
END;   { FUNCTION CAFE_HojaCalculoBase.PeticionHojaSimilar }

FUNCTION    CAFE_HojaCalculoBase.IdentificadorValidoCasilla
  ( CONST Nombre                : ShortString;
    OUT   FilaAbsoluta          : Boolean;
    OUT   Fila                  : LongInt;
    OUT   ColumnaAbsoluta       : Boolean;
    OUT   Columna               : LongInt                       ) : Boolean;
BEGIN  { FUNCTION CAFE_HojaCalculoBase.IdentificadorValidoCasilla }
  IF ActivoCVDH IN DescriptoresHoja THEN BEGIN
    IF NombreCasillaHoja
          ( Nombre, ColumnaAbsoluta, Columna, FilaAbsoluta, Fila ) THEN BEGIN
      IF InRange( Columna, 0, Pred( ColumnasEnHoja ) ) AND
         InRange( Fila   , 0, Pred( FilasEnHoja    ) ) THEN BEGIN
        IdentificadorValidoCasilla                := TRUE;
      END ELSE BEGIN
        IdentificadorValidoCasilla                := FALSE;
      END;
    END ELSE BEGIN  { IF NombreCasillaValido( ... ) ELSE }
      IdentificadorValidoCasilla                  := FALSE;
    END;            { IF NombreCasillaValido( ... ) ELSE }
  END ELSE BEGIN  { IF ActivoCVDH IN DescriptoresHoja }
    RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorHojaTrabajoInactiva );
  END             { IF ActivoCVDH IN DescriptoresHoja }
END;   { FUNCTION CAFE_HojaCalculoBase.IdentificadorValidoCasilla }

FUNCTION    CAFE_HojaCalculoBase.CasillaNull
  (       Fila, Columna         : LongInt                       ) : Boolean;
BEGIN  { CAFE_HojaCalculoBase.CasillaNull }
  CasillaNull                   := VariantHoja[ Fila ][ Columna ] = Null;
END;   { CAFE_HojaCalculoBase.CasillaNull }

  { Alabado sea Dios en sus angeles y en sus santos }
FUNCTION    CAFE_HojaCalculoBase.CompatibilidadSimple
  (       Fila, Columna         : LongInt;
          TypeVariant           : SizeInt               ) : Boolean;
{ virtual; }
VAR
  MyVariant                     : Variant;
  MyClass                       : CAFE_DatoExtendido;

LABEL
  SalidaVerdadera;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.CompatibilidadSimple }
  MyVariant                     := VariantHoja[ Fila ][ Columna ];
  IF MyVariant = Null THEN GOTO SalidaVerdadera;
  CASE CAFE_TipoVariante( MyVariant ) OF
    varDouble                   : BEGIN
                                    IF TypeVariant = varDouble THEN
                                        GOTO SalidaVerdadera;
                                  END;  { varDouble }
    varInteger                  : BEGIN
                                    IF ( TypeVariant = varDouble ) OR
                                       ( TypeVariant = varInteger ) OR
                                       ( TypeVariant = varByte ) THEN
                                        GOTO SalidaVerdadera;
                                  END;  { varInteger }
    varByte                     : BEGIN
                                    IF ( TypeVariant = varDouble ) OR
                                       ( TypeVariant = varInteger ) OR
                                       ( TypeVariant = varByte ) OR
                                       ( TypeVariant = varString ) THEN
                                        GOTO SalidaVerdadera;
                                  END;  { varByte }
    varBoolean                  : BEGIN
                                    IF TypeVariant = varBoolean THEN
                                        GOTO SalidaVerdadera;
                                  END;  { varBoolean }
    varString                   :
      BEGIN
        MyClass                 := SintacticaHoja[ Fila ][ Columna ];
        IF MyClass <> NIL THEN BEGIN
          IF ( MyClass is CAFE_DatoNudillado ) THEN BEGIN
            WITH ( MyClass as CAFE_DatoNudillado ) DO BEGIN
              IF NOT( BanderaMacroFuncional ) THEN BEGIN
                IF TipoReturn = Null THEN GOTO SalidaVerdadera;
                CASE CAFE_TipoVariante( TipoReturn ) OF
                  varDouble      : BEGIN
                                     IF TypeVariant = varDouble THEN
                                         GOTO SalidaVerdadera;
                                   END;  { CASE varDouble }
                  varInteger     : BEGIN
                                     IF ( TypeVariant = varDouble ) OR
                                        ( TypeVariant = varInteger ) OR
                                        ( TypeVariant = varByte ) THEN
                                         GOTO SalidaVerdadera;
                                   END;  { CASE varInteger }
                  varByte        : BEGIN
                                     IF ( TypeVariant = varDouble ) OR
                                        ( TypeVariant = varInteger ) OR
                                        ( TypeVariant = varByte ) OR
                                        ( TypeVariant = varString ) THEN
                                         GOTO SalidaVerdadera;
                                   END;  { varByte }
                  varBoolean     : BEGIN
                                     IF TypeVariant = varBoolean THEN
                                         GOTO SalidaVerdadera;
                                   END;  { CASE varBoolean }
                  varString      : BEGIN
                                     IF TypeVariant = varString THEN
                                       GOTO SalidaVerdadera;
                                   END;  { CASE varString }
                END;  { CASE CAFE_TipoVariante( TipoResult ) }
              END;  { IF NOT( BanderaMacroFuncional ) }
            END;  { WITH ( MyClass ) }
          END ELSE BEGIN { IF ( MyClass is CAFE_DatoNudillado ) ELSE }
            IF ( TypeVariant = varString ) OR ( TypeVariant = varByte )
            THEN GOTO SalidaVerdadera;
          END;           { IF ( MyClass is CAFE_DatoNudillado ) ELSE ) }
        END ELSE BEGIN  { IF MyClass <> NIL ELSE }
          IF ( TypeVariant = varString ) OR ( TypeVariant = varByte )
          THEN GOTO SalidaVerdadera;
        END;            { IF MyClase <> NIL ELSE }
      END;  { varString }
  END;  { CASE CAFE_TipoVariante( MyVariant ) }
  CompatibilidadSimple          := FALSE;
  Exit;
SalidaVerdadera :
  CompatibilidadSimple          := TRUE;
END;   { FUNCTION CAFE_HojaCalculoBase.CompatibilidadSimple }

FUNCTION    CAFE_HojaCalculoBase.LecturaTipo
  (       Fila, Columna         : LongInt;
    OUT   BanderaNudillado      : Boolean;
    OUT   BanderaMacro          : Boolean;
    OUT   CaracterMacro         : CAFE_ConjuntoParametroBasico  ) : SizeInt;
VAR
  MyClass                       : CAFE_DatoExtendido;
  VarianteProvisional           : SizeInt;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.LecturaTipo }
  VarianteProvisional           :=
                CAFE_TipoVariante( VariantHoja[ Fila ][ Columna ] );
  IF VarianteProvisional = VarEmpty THEN BEGIN
    LecturaTipo                 := VarEmpty;
    BanderaNudillado            := FALSE;
    BanderaMacro                := FALSE;
    CaracterMacro               := [];
  END;  { IF VariantProvisional = Null }
  IF VarianteProvisional = VarString THEN BEGIN
    MyClass                     := SintacticaHoja[ Fila ][ Columna ];
    IF MyClass <> NIL THEN BEGIN
      IF ( MyClass is CAFE_DatoNudillado ) THEN BEGIN
        WITH ( MyClass as CAFE_DatoNudillado ) DO BEGIN
          VarianteProvisional   := CAFE_TipoVariante( TipoReturn );
          IF CAFE_TypeSimpleValorCompatible( varDouble, VarianteProvisional )
          THEN LecturaTipo      := varDouble
          ELSE LecturaTipo      := VarianteProvisional;
          BanderaNudillado      := TRUE;
          BanderaMacro          := BanderaMacroFuncional;
          CaracterMacro         := MacroParametro;
          Exit;
        END;  { WITH ( MyClass as CAFE_DatoNudillado ) }
      END;  { IF ( MyClass is CAFE_DatoNudillado ) }
    END;  { IF MyClass <> NIL }
  END;  { IF VariantProvisional = VarString }
  IF CAFE_TypeSimpleValorCompatible( varDouble, VarianteProvisional )
  THEN LecturaTipo              := varDouble
  ELSE LecturaTipo              := VarianteProvisional;
  BanderaNudillado              := FALSE;
  BanderaMacro                  := FALSE;
  CaracterMacro                 := [];
END;   { FUNCTION CAFE_HojaCalculoBase.LecturaTipo }

FUNCTION    CAFE_HojaCalculoBase.LecturaTipo
  (       Fila, Columna         : LongInt;
    OUT   BanderaNudillado      : Boolean;
    OUT   BanderaMacro          : Boolean;
    OUT   CaracterMacro         : CAFE_ConjuntoParametroBasico;
    OUT   DatoVariante          : Variant;
    OUT   DatoResultado         : Variant                       ) : SizeInt;
VAR
  MyClass                       : CAFE_DatoExtendido;
  VarianteProvisional           : SizeInt;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.LecturaTipo }
  DatoVariante                  := VariantHoja[ Fila ][ Columna ];
  VarianteProvisional           := CAFE_TipoVariante( DatoVariante );
  IF VarianteProvisional = VarEmpty THEN BEGIN
    LecturaTipo                 := VarEmpty;
    DatoResultado               := Null;
    BanderaNudillado            := FALSE;
    BanderaMacro                := FALSE;
    CaracterMacro               := [];
  END;  { IF VariantProvisional = Null }
  IF VarianteProvisional = VarString THEN BEGIN
    MyClass                     := SintacticaHoja[ Fila ][ Columna ];
    IF MyClass <> NIL THEN BEGIN
      IF ( MyClass is CAFE_DatoNudillado ) THEN BEGIN
        WITH ( MyClass as CAFE_DatoNudillado ) DO BEGIN
          DatoResultado         := TipoReturn;
          VarianteProvisional   := CAFE_TipoVariante( TipoReturn );
          IF CAFE_TypeSimpleValorCompatible( varDouble, VarianteProvisional )
          THEN LecturaTipo      := varDouble
          ELSE LecturaTipo      := VarianteProvisional;
          BanderaNudillado      := TRUE;
          BanderaMacro          := BanderaMacroFuncional;
          CaracterMacro         := MacroParametro;
          Exit;
        END;  { WITH ( MyClass as CAFE_DatoNudillado ) }
      END;  { IF ( MyClass is CAFE_DatoNudillado ) }
    END;  { IF MyClass <> NIL }
  END;  { IF VariantProvisional = VarString }
  IF CAFE_TypeSimpleValorCompatible( varDouble, VarianteProvisional )
  THEN LecturaTipo              := varDouble
  ELSE LecturaTipo              := VarianteProvisional;
  BanderaNudillado              := FALSE;
  BanderaMacro                  := FALSE;
  CaracterMacro                 := [];
END;   { FUNCTION CAFE_HojaCalculoBase.LecturaTipo }

PROCEDURE   CAFE_HojaCalculoBase.ModificarMacroParametro
  (       Fila, Columna         : LongInt;
          AgregarCaracterMacro,
          RestarCaracterMacro   : CAFE_ConjuntoParametroBasico;
          ContadorMaximo        : LongInt               = -1            );
VAR
  MyClass                       : CAFE_DatoExtendido;

BEGIN  { PROCEDURE CAFE_HojaCalculoBase.ModificarMacroParametro }
  MyClass                       := SintacticaHoja[ Fila ][ Columna ];
  IF MyClass <> NIL THEN BEGIN
    IF MyClass is CAFE_DatoNudillado THEN BEGIN
      WITH ( MyClass as CAFE_DatoNudillado ) DO BEGIN
        MacroParametro          :=
                ( MacroParametro+AgregarCaracterMacro )-RestarCaracterMacro;
        IF ContadorMaximo <> -1
        THEN CicloConteoMaximo  := ContadorMaximo;
      END;  { WITH ( MyClass as CAFE_DatoNudillado ) }
    END;  { IF MyClass is CAFE_DatoNudillado }
  END;  { IF MyClass <> NIL }
END;   { PROCEDURE CAFE_HojacalculoBase.ModificarMacroParametro }

PROCEDURE   CAFE_HojaCalculoBase.EstablecerMacroParametro
  (       Fila, Columna         : LongInt;
          CaracterMacro         : CAFE_ConjuntoParametroBasico;
          ContadorMaximo        : LongInt                               );
VAR
  MyClass                       : CAFE_DatoExtendido;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.EstablecerMacroParametro }
  MyClass                       := SintacticaHoja[ Fila ][ Columna ];
  IF MyClass <> NIL THEN BEGIN
    IF MyClass is CAFE_DatoNudillado THEN BEGIN
      WITH ( MyClass as CAFE_DatoNudillado ) DO BEGIN
        MacroParametro          := CaracterMacro;
        CicloConteoMaximo       := ContadorMaximo;
      END;  { WITH ( MyClass as CAFE_DatoNudillado ) }
    END;  { IF MyClass is CAFE_DatoNudillado }
  END;  { IF MyClass <> NIL }
END;   { FUNCTION CAFE_HojaCalculoBase.EstablecerMacroParametro }


  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_HojaCalculoBase.LiberarCasilla
  (       Fila, Columna         : LongInt               ) : Boolean;
{ virtual; }
BEGIN  { CAFE_HojaCalculoBase.LiberarCasilla }
  FormatoHoja[ Fila ][ Columna ]                := NIL;
  VariantHoja[ Fila ][ Columna ]                := Null;
  FreeAndNil( SintacticaHoja[ Fila ][ Columna ] );
  LiberarCasilla                := TRUE;
END;   { CAFE_HojaCalculoBase.LiberarCasilla }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

FUNCTION    CAFE_HojaCalculoBase.AnularCasilla
  (       Fila, Columna         : LongInt               ) : Boolean;
{ virtual; }
BEGIN  { FUNCTION CAFE_HojaCalculoBase.AnularCasilla }
  VariantHoja[ Fila ][ Columna ]                := Null;
  FreeAndNil( SintacticaHoja[ Fila ][ Columna ] );
  AnularCasilla                                 := TRUE;
END;   { FUNCTION CAFE_HojaCalculoBase.AnularCasilla }

FUNCTION    CAFE_HojaCalculoBase.EscribirReal
  (       Fila, Columna         : LongInt;
          ValorReal             : Real                          ) : Boolean;
BEGIN  { FUNCTION CAFE_HojaCalculoBase.EscribirReal }
  IF AnularCasilla( Fila, Columna ) THEN BEGIN
    VariantHoja[ Fila ][ Columna ]              := ValorReal;
    EscribirReal                                := TRUE;
  END ELSE BEGIN  { IF AnularCasilla( Fila, Columna ) }
    EscribirReal                                := FALSE;
  END;            { IF AnularCasilla( Fila, Columna ) }
END;   { FUNCTION CAFE_HojaCalculoBase.EscribirReal }

FUNCTION    CAFE_HojaCalculoBase.EscribirEntero
  (       Fila, Columna         : LongInt;
          ValorEntero           : LongInt                       ) : Boolean;
BEGIN  { FUNCTION CAFE_HojaCalculoBase.EscribirEntero }
  IF AnularCasilla( Fila, Columna ) THEN BEGIN
    VariantHoja[ Fila ][ Columna ]              := ValorEntero;
    EscribirEntero                              := TRUE;
  END ELSE BEGIN  { IF AnularCasilla( Fila, Columna ) }
    EscribirEntero                              := FALSE;
  END;            { IF AnularCasilla( Fila, Columna ) }
END;   { FUNCTION CAFE_HojaCalculoBase.EscribirEntero }

FUNCTION    CAFE_HojaCalculoBase.EscribirDate
  (       Fila, Columna         : LongInt;
          ValorFecha            : TDateTime                     ) : Boolean;
BEGIN  { FUNCTION CAFE_HojaCalculoBase.EscribirDate }
  IF AnularCasilla( Fila, Columna ) THEN BEGIN
    EscribirDate                :=
        CAFE_VarCast( VariantHoja[ Fila ][ Columna ], ValorFecha, varDate );
  END ELSE BEGIN  { IF AnularCasilla( Fila, Columna ) }
    EscribirDate                                := FALSE;
  END;            { IF AnularCasilla( Fila, Columna ) }
END;   { FUNCTION CAFE_HojaCalculoBase.EscribirDate }

FUNCTION    CAFE_HojaCalculoBase.EscribirString
  (       Fila, Columna         : LongInt;
    CONST Msg                   : ShortString                   ) : Boolean;
BEGIN  { FUNCTION CAFE_HojaCalculoBase.EscribirString }
  IF AnularCasilla( Fila, Columna ) THEN BEGIN
    VariantHoja[ Fila ][ Columna ]              := Msg;
    EscribirString                              := TRUE;
  END ELSE BEGIN  { IF AnularCasilla( Fila, Columna ) }
    EscribirString                              := FALSE;
  END;            { IF AnularCasilla( Fila, Columna ) }
END;   { FUNCTION CAFE_HojaCalculoBase.EscribirString }

FUNCTION    CAFE_HojaCalculoBase.EscribirMacroSimple
  (       Fila, Columna         : LongInt;
    CONST MacroLiteral          : ShortString;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
    CONST NomParam1             : ShortString;
          Valor1                : Double;
    CONST NomParam2             : ShortString   = '';
          Valor2                : Double        = 0.0;
    CONST NomParam3             : ShortString   = '';
          Valor3                : Double        = 0.0;
          BanderaPendiente      : Boolean       = FALSE         ) : Boolean;
VAR
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  PivoteArbol                   : CAFE_Nudo2Sintactico;
  CicloSintactico               : LongInt;
  PivoteReal                    : Double;
  TotPar                        : Word;
  BanderaPivoteSimular          : Boolean;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.EscribirMacroSimple }
  IF EscribirString( Fila, Columna, MacroLiteral ) THEN BEGIN
    Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
    WITH MyManejador DO BEGIN
     IF GramaticaCharByte.GramaticaOperadores( MacroLiteral )
     THEN BEGIN
       PivoteArbol      := GeneradorArbolSintactico.
                                NuevoArbol( GramaticaCharByte );
       IF PivoteArbol <> NIL THEN BEGIN
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
         SintacticaHoja[ Fila ][ Columna ]      :=
                        NudilladoManejador.ModeloExtendido.Create;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
         WITH SintacticaHoja[ Fila ][ Columna ] as CAFE_DatoNudillado DO BEGIN
           IF BanderaPendiente THEN BEGIN
             BanderaStandard                    := TRUE;
             BanderaMacroFuncional              := TRUE;
             BanderaPeticionNudillar            := TRUE;
             BanderaPeticionCalculo             := TRUE;
             IF CAFE_HabilitarUnCiclo
             THEN MacroParametro                :=
                        [ ActivoHCGM, BasicoStandardHCGM,
                          ActivarCicloHCGM, CicloTomarVariantHCGM ]
             ELSE MacroParametro                :=
                        [ ActivoHCGM, BasicoStandardHCGM ];
             CAFE_HabilitarUnCiclo              := FALSE;
             FuncionNudillado                   := NIL;
             EscribirMacroSimple                := TRUE;
             ValorPruebaUno                     := Valor1;
             ValorPruebaDos                     := Valor2;
             ValorPruebaTres                    := Valor3;
             NombreParametroUno                 := NomParam1;
             IF NomParam3 <> '' THEN BEGIN
               Include( MacroParametro, Real3DHCGM );
               NombreParametroDos               := NomParam2;
               NombreParametroTres              := NomParam3;
             END ELSE BEGIN  { IF NomParam3 <> '' ELSE }
               IF NomParam2 <> '' THEN BEGIN
                 Include( MacroParametro, Real2DHCGM );
                 NombreParametroDos             := NomParam2;
               END ELSE Include( MacroParametro, Real1DHCGM );
             END;            { IF NomParam3 <> '' ELSE }
             Exit;
           END;  { IF BanderaPendiente }
           BanderaStandard                      := TRUE;
           BanderaMacroFuncional                := TRUE;
           IF CAFE_HabilitarUnCiclo
           THEN MacroParametro                  :=
                [ ActivoHCGM, BasicoStandardHCGM,
                        ActivarCicloHCGM, CicloTomarVariantHCGM ]
           ELSE MacroParametro                  :=
                [ ActivoHCGM, BasicoStandardHCGM ];
           CAFE_HabilitarUnCiclo                := FALSE;
           TotPar                               := 1;
           NombreParametroUno                   := NomParam1;
           ValorPruebaUno                       := Valor1;
           ValorPruebaDos                       := Valor2;
           ValorPruebaTres                      := Valor3;
           IF NomParam3 <> '' THEN BEGIN
             Include( MacroParametro, Real3DHCGM );
             TotPar                             := 3;
             NombreParametroDos                 := NomParam2;
             NombreParametroTres                := NomParam3;
           END ELSE BEGIN  { IF NomParam3 <> '' ELSE }
             IF NomParam2 <> '' THEN BEGIN
               Include( MacroParametro, Real2DHCGM );
               TotPar                           := 2;
               NombreParametroDos               := NomParam2;
             END ELSE Include( MacroParametro, Real1DHCGM );
           END;            { IF NomParam3 <> '' ELSE }
           BanderaPeticionNudillar              := FALSE;
           BanderaPeticionCalculo               := TRUE;
           FuncionNudillado                     := PivoteArbol;
           TipoReturn                           := Valor1;
           IF PivoteArbol.InterpretarMacro
                ( Manejador, Msg, NomParam1, NomParam2, NomParam3 )
           THEN BEGIN
             BanderaPeticionNudillar            := FALSE;
             BanderaPivoteSimular               :=
                                        ValorBanderaSimularCalculo;
             ValorBanderaSimularCalculo         := TRUE;
             Inc( CAFE_IdentificadorCicloSintactico,
                              CAFE_IncrementoIdentificadorCicloSintactico );
             CicloSintactico                    :=
                                CAFE_IdentificadorCicloSintactico;
             MarcaCicloSintactico               := CicloSintactico;
             IF PivoteArbol.EvaluarMacro
               ( PivoteReal, Msg, Manejador, TotPar,
                                Valor1, Valor2, Valor3, CicloSintactico )
             THEN BEGIN
               TipoReturn                       := PivoteReal;
               BanderaPeticionCalculo           := FALSE;
               EscribirMacroSimple              := TRUE;
               ValorBanderaSimularCalculo       := BanderaPivoteSimular;
               Exit;
             END ELSE BEGIN  { ...EvaluarArbol( TipoReturn, Manejador ) ELSE }
               FreeAndNil( FuncionNudillado );
               BanderaPeticionNudillar          := TRUE;
               EscribirMacroSimple              := FALSE;
               ValorBanderaSimularCalculo       := BanderaPivoteSimular;
               Exit;
             END;            { ...EvaluarArbol( TipoReturn, Manejador ) ELSE }
           END ELSE BEGIN  { IF PivoteArbol.InterpretarFuncion( Manejador ) }
             BanderaPeticionNudillar            := TRUE;
             FreeAndNil( FuncionNudillado );
             EscribirMacroSimple                := FALSE;
           END;            { IF PivoteArbol.InterpretarFuncion( Manejador ) }
         END;  { WITH SintacticaHoja[ Fila ][ Columna ] }
       END ELSE BEGIN  { IF PivoteArbol <> NIL ELSE }
         IF CAFE_MensajeInfructuosoSintactico = '' THEN BEGIN
           CAFE_IntentoInfructuosoSintactico    := TRUE;
           CAFE_MensajeInfructuosoSintactico    := 'Error de sintaxis';
           CAFE_PosicionInfructuosoSintactico   :=
                                CAFE_4ErrorNudilladoGeneral;
           EscribirMacroSimple                  := FALSE;
           Exit;
         END;         { IF CAFE_MensajeIntentoInfructuoso = '' }
       END;            { IF PivoteArbol <> NIL ELSE }
     END ELSE BEGIN { IF GramaticaCharByte.GramaticaOperadores... ELSE }
       IF CAFE_MensajeInfructuosoSintactico = '' THEN BEGIN
         CAFE_IntentoInfructuosoSintactico      := TRUE;
         CAFE_MensajeInfructuosoSintactico      := 'Error de sintaxis';
         CAFE_PosicionInfructuosoSintactico     :=
                        CAFE_4ErrorGramaticaOperadoresGeneral;
         EscribirMacroSimple                    := FALSE;
         Exit;
       END;         { IF CAFE_MensajeIntentoInfructuoso = '' }
     END;        { IF GramaticaCharByte.GramaticaOperadores... ELSE }
    END;  { WITH MyManejador }
  END ELSE BEGIN  { IF EscribirString( Fila, Columna, FuncionLiteral ) ELSE }
    EscribirMacroSimple         := FALSE;
  END;            { IF EscribirString( Fila, Columna, FuncionLiteral ) ELSE }
END;   { FUNCTION CAFE_HojaCalculoBase.EscribirMacroSimple }

FUNCTION    CAFE_HojaCalculoBase.EscribirFuncionSimple
  (       Fila, Columna         : LongInt;
    CONST FuncionLiteral        : ShortString;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          BanderaPendiente      : Boolean       = FALSE         ) : Boolean;
{ virtual; }
VAR
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  PivoteArbol                   : CAFE_Nudo2Sintactico;
  CicloSintactico               : LongInt;
  BanderaPivoteSimular          : Boolean;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.EscribirFuncionSimple }
  Msg                           := '';
  IF EscribirString( Fila, Columna, FuncionLiteral ) THEN BEGIN
    Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
    WITH MyManejador DO BEGIN
     IF GramaticaCharByte.GramaticaOperadores( FuncionLiteral )
     THEN BEGIN
       PivoteArbol      := GeneradorArbolSintactico.
                                NuevoArbol( GramaticaCharByte );
       IF PivoteArbol <> NIL THEN BEGIN
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
         SintacticaHoja[ Fila ][ Columna ]      :=
                        NudilladoManejador.ModeloExtendido.Create;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
         WITH SintacticaHoja[ Fila ][ Columna ] as CAFE_DatoNudillado DO BEGIN
           IF BanderaPendiente THEN BEGIN
             BanderaStandard                    := TRUE;
             BanderaMacroFuncional              := FALSE;
             BanderaPeticionNudillar            := TRUE;
             BanderaPeticionCalculo             := TRUE;
             FuncionNudillado                   := NIL;
             EscribirFuncionSimple              := TRUE;
             TipoReturn                         :=
                        CAFE_DefaultNuloVariant( varDouble );
             Exit;
           END;  { IF BanderaPendiente }
           BanderaStandard                      := TRUE;
           BanderaMacroFuncional                := FALSE;
           IF CAFE_HabilitarUnCiclo
           THEN MacroParametro                  :=
                [ ActivoHCGM, BasicoStandardHCGM,
                        ActivarCicloHCGM, CicloTomarVariantHCGM ]
           ELSE MacroParametro                  :=
                [ ActivoHCGM, BasicoStandardHCGM ];
           CAFE_HabilitarUnCiclo                := FALSE;
           BanderaPeticionNudillar              := FALSE;
           BanderaPeticionCalculo               := TRUE;
           FuncionNudillado                     := PivoteArbol;
           IF PivoteArbol.InterpretarFuncion( Manejador, TipoReturn, Msg )
           THEN BEGIN
             BanderaPeticionNudillar            := FALSE;
             Inc( CAFE_IdentificadorCicloSintactico,
                                CAFE_IncrementoIdentificadorCicloSintactico );
             CicloSintactico                    :=
                                CAFE_IdentificadorCicloSintactico;
             MarcaCicloSintactico               := CicloSintactico;
             BanderaPivoteSimular               :=
                                ValorBanderaSimularCalculo;
             ValorBanderaSimularCalculo         := TRUE;
             IF PivoteArbol.EvaluarFuncion
                        ( TipoReturn, Msg, Manejador, CicloSintactico )
             THEN BEGIN
               BanderaPeticionCalculo           := FALSE;
               EscribirFuncionSimple            := TRUE;
               ValorBanderaSimularCalculo       := BanderaPivoteSimular;
               Exit;
             END ELSE BEGIN  { ...EvaluarArbol( TipoReturn, Manejador ) ELSE }
               FreeAndNil( FuncionNudillado );
               BanderaPeticionNudillar          := TRUE;
               EscribirFuncionSimple            := FALSE;
               ValorBanderaSimularCalculo       := BanderaPivoteSimular;
               Exit;
             END;            { ...EvaluarArbol( TipoReturn, Manejador ) ELSE }
           END ELSE BEGIN  { IF PivoteArbol.InterpretarFuncion( Manejador ) }
             FreeAndNil( FuncionNudillado );
             EscribirFuncionSimple              := FALSE;
           END;            { IF PivoteArbol.InterpretarFuncion( Manejador ) }
         END;  { WITH SintacticaHoja[ Fila ][ Columna ] }
       END ELSE BEGIN  { IF PivoteArbol <> NIL ELSE }
         IF CAFE_PosicionInfructuosoSintactico = 0 THEN BEGIN
           CAFE_IntentoInfructuosoSintactico    := TRUE;
           CAFE_MensajeInfructuosoSintactico    := 'Error de sintaxis';
           CAFE_PosicionInfructuosoSintactico   :=
                                        CAFE_4ErrorNudilladoGeneral;
           EscribirFuncionSimple                := FALSE;
           Exit;
         END;         { IF CAFE_MensajeIntentoInfructuoso = '' }
       END;            { IF PivoteArbol <> NIL ELSE }
     END ELSE BEGIN { IF GramaticaCharByte.GramaticaOperadores... ELSE }
       IF CAFE_PosicionInfructuosoSintactico = 0 THEN BEGIN
         CAFE_IntentoInfructuosoSintactico      := TRUE;
         CAFE_MensajeInfructuosoSintactico      := 'Error de sintaxis';
         CAFE_PosicionInfructuosoSintactico     :=
                                CAFE_4ErrorGramaticaOperadoresGeneral;
         EscribirFuncionSimple                  := FALSE;
         Exit;
       END;         { IF CAFE_MensajeIntentoInfructuoso = '' }
     END;        { IF GramaticaCharByte.GramaticaOperadores... ELSE }
    END;  { WITH MyManejador }
  END ELSE BEGIN  { IF EscribirString( Fila, Columna, FuncionLiteral ) ELSE }
    EscribirFuncionSimple       := FALSE;
  END;            { IF EscribirString( Fila, Columna, FuncionLiteral ) ELSE }
END;   { FUNCTION CAFE_HojaCalculoBase.EscribirFuncionSimple }

FUNCTION   CAFE_HojaCalculoBase.EvaluarFuncionSimple
  (       Fila, Columna         : LongInt;
    OUT   ResultFuncion         : Variant;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          CicloSintactico       : LongInt       = 0             ) : Boolean;
BEGIN  { FUNCTION CAFE_HojaCalculoBase.EvaluarFuncionSimple }
  EvaluarFuncionSimple          := EvaluarMacroFuncionSimple
        ( Fila, Columna, ResultFuncion,
                Msg, Manejador, 0, 0.0, 0.0, 0.0, CicloSintactico );
END;   { FUNCTION CAFE_HojaCalculoBase.EvaluarFuncionSimple }

FUNCTION   CAFE_HojaCalculoBase.EvaluarMacroSimple
  (       Fila, Columna         : LongInt;
    OUT   ResultMacro           : Double;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          TotalParMacro         : LongInt;
          Param1                : Double        = 0.0;
          Param2                : Double        = 0.0;
          Param3                : Double        = 0.0;
          CicloSintactico       : LongInt       = 0             ) : Boolean;
VAR
  PivoteReal                    : Variant;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.EvaluarMacroSimple }
  IF EvaluarMacroFuncionSimple( Fila, Columna, PivoteReal, Msg, Manejador,
        TotalParMacro, Param1, Param2, Param3, CicloSintactico ) THEN BEGIN
    IF CAFE_TypeSimpleValorCompatible( varDouble,
                                CAFE_TipoVariante( PivoteReal ) )
    THEN BEGIN
      ResultMacro               := PivoteReal;
      EvaluarMacroSimple        := TRUE;
    END ELSE BEGIN  { IF CAFE_TipoVariante( PivoteReal ) = varDouble ELSE }
      ResultMacro               := 0.0;
      IF ( Msg = '' ) AND
         ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
        Msg      := 'Inconsistencia de tipo en macro';
        CAFE_PosicionInfructuosoSintactico              :=
                                CAFE_4ErrorMacroResultadoNoReal;
        CAFE_MensajeInfructuosoSintactico               := Msg;
        CAFE_IntentoInfructuosoSintactico               := TRUE;
      END;  { IF ( Msg = '' ) AND ... }
      EvaluarMacroSimple        := FALSE;
    END;            { IF CAFE_TipoVariante( PivoteReal ) = varDouble ELSE }
  END ELSE BEGIN  { IF EvaluarMacroFuncion... ELSE }
    ResultMacro                 := 0.0;
    EvaluarMacroSimple          := FALSE;
  END;            { IF EvaluarMacroFuncion... ELSE }
END;   { FUNCTION CAFE_HojaCalculoBase.EvaluarMacroSimple }

  {$IFDEF       SILENCIAR       }
  {$NOTES       OFF             }
  {$ENDIF                       }
FUNCTION   CAFE_HojaCalculoBase.EvaluarMacroFuncionSimple
  (       Fila, Columna         : LongInt;
    OUT   ResultMacro           : Variant;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          TotalParMacro         : LongInt       = 0;
          Param1                : Double        = 0.0;
          Param2                : Double        = 0.0;
          Param3                : Double        = 0.0;
          CicloSintactico       : LongInt       = 0             ) : Boolean;
VAR
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  MyRec                         : CAFE_DatoExtendido;
  BanderaIniciativa,
  PruebaMyRec                   : Boolean;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.EvaluarMacroFuncionSimple }
  Msg                           := '';
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
  WITH MyManejador DO BEGIN
    MyRec                       := SintacticaHoja[ Fila ][ Columna ];
    PruebaMyRec                 := MyRec = NIL;
    IF NOT( PruebaMyRec )
    THEN PruebaMyRec            := NOT( MyRec is CAFE_DatoNudillado );
    IF PruebaMyRec THEN BEGIN
      IF TotalParMacro = 0 THEN BEGIN
        ResultMacro             := VariantHoja[ Fila ][ Columna ];
        EvaluarMacroFuncionSimple               := TRUE;
        Exit;
      END ELSE BEGIN  { IF TotalParMacro = 0 ELSE }
        EvaluarMacroFuncionSimple               := FALSE;
        CAFE_PosicionInfructuosoSintactico      :=
                                        CAFE_4ErrorMacroSinParametros;
        Msg                                     := 'Macro indefinida';
        CAFE_MensajeInfructuosoSintactico       := Msg;
        CAFE_IntentoInfructuosoSintactico       := TRUE;
        Exit;
      END;            { IF TotalParMacro = 0 ELSE }
    END ELSE BEGIN  { IF PruebaMyRec ELSE }
      WITH ( MyRec as CAFE_DatoNudillado ) DO BEGIN
        ResultMacro                             := TipoReturn;
        IF CicloSintactico = 0 THEN BEGIN
          Inc( CAFE_IdentificadorCicloSintactico,
                              CAFE_IncrementoIdentificadorCicloSintactico );
          CicloSintactico     := CAFE_IdentificadorCicloSintactico;
          BanderaIniciativa   := FALSE;
        END ELSE BEGIN  { IF CicloSintactico = 0 ELSE }
          BanderaIniciativa   := TRUE;
        END;            { IF CicloSintactico = 0 ELSE }
        IF CicloSintactico = MarcaCicloSintactico THEN BEGIN
          IF BanderaPeticionNudillar THEN BEGIN
            EvaluarMacroFuncionSimple           := FALSE;
            Msg                 := 'Error al evaluar';
            CAFE_PosicionInfructuosoSintactico  :=
                                CAFE_4ErrorVarErrorEvaluar;
            CAFE_MensajeInfructuosoSintactico   := Msg;
            CAFE_IntentoInfructuosoSintactico   := TRUE;
            Exit;
          END;  { IF BanderaPeticionNudillar }
          IF TodoCicloProhibidoCVDH IN DescriptoresHoja THEN BEGIN
            EvaluarMacroFuncionSimple           := FALSE;
            CAFE_PosicionInfructuosoSintactico  := CAFE_4ErrorLlamadaCiclica;
            Msg                                 := 'Llamada Ciclica';
            CAFE_MensajeInfructuosoSintactico   := Msg;
            CAFE_IntentoInfructuosoSintactico   := TRUE;
            Exit;
          END;  { IF TodoCicloProhibidoCVDH IN DescriptoresHoja }
          IF ActivarCicloHCGM IN MacroParametro THEN BEGIN
            IF CicloTomarVariantHCGM IN MacroParametro THEN BEGIN
              EvaluarMacroFuncionSimple         := TRUE;
              Exit;
            END;  { IF CicloTomarVariantHCGM IN MacroParametro }
            IF CicloConteoHCGM IN MacroParametro THEN BEGIN
              IF CicloConteo = 0 THEN BEGIN
                IF FinConteoErrorHCGM IN MacroParametro
                THEN EvaluarMacroFuncionSimple  := FALSE
                ELSE EvaluarMacroFuncionSimple  := TRUE;
                Exit;
              END ELSE BEGIN  { IF CicloConteo = 0 ELSE }
                Dec( CicloConteo );
                Dec( ImplementationConteoCicloSeguridad );
              END;            { IF CicloConteo = 0 ELSE }
            END ELSE BEGIN  { IF CicloConteoHCGM IN MacroParametro ELSE }
              Inc( ImplementationConteoCicloSeguridad );
            END;            { IF CicloConteoHCGM IN MacroParametro ELSE }
            IF ( [ CicloConteoHCGM, CicloEvaluarHCGM ]*MacroParametro ) = []
            THEN BEGIN
              EvaluarMacroFuncionSimple         := FALSE;
              Msg                               :=
                        'Ejecucion invalida de ciclo';
              CAFE_PosicionInfructuosoSintactico        :=
                                        CAFE_4ErrorEstiloRecursivoIndefinido;
              CAFE_MensajeInfructuosoSintactico         := Msg;
              CAFE_IntentoInfructuosoSintactico         := TRUE;
              Exit;
            END;  { IF ( [ CicloConteoHCGM, CicloEvaluarHCGM ]*... ) }
            IF ImplementationConteoCicloSeguridad >=
                        CAFE_MaximoConteoCicloSeguridad
            THEN BEGIN
              EvaluarMacroFuncionSimple         := FALSE;
              Msg                               :=
                        'No se encontro fin de ciclo';
              CAFE_PosicionInfructuosoSintactico                :=
                                        CAFE_4ErrorFinCicloPendiente;
              CAFE_IntentoInfructuosoSintactico                 := TRUE;
              CAFE_MensajeInfructuosoSintactico                 := Msg;
              Exit;
            END;
              { IF ConteoCicloSeguridad >= CAFE_MaximoConteoCicloSeguridad }
          END ELSE BEGIN  { IF ActivarCicloHCGM IN MacroParametro ELSE }
            EvaluarMacroFuncionSimple           := FALSE;
            CAFE_PosicionInfructuosoSintactico  := CAFE_4ErrorLlamadaCiclica;
            Msg                                 := 'Llamada Ciclica';
            CAFE_MensajeInfructuosoSintactico   := Msg;
            CAFE_IntentoInfructuosoSintactico   := TRUE;
            Exit;
          END;            { IF ActivarCicloHCGM IN MacroParametro ELSE }
          IF ValorBanderaSimularCalculo THEN BEGIN
            EvaluarMacroFuncionSimple           := TRUE;
            Exit;
          END;  { IF ValorBanderaSimularCalculo }
        END ELSE BEGIN  { IF CicloSintactico = ControlCicloSintactico ELSE }
          MarcaCicloSintactico          := CicloSintactico;
          CicloConteo                   := CicloConteoMaximo;
          ImplementationConteoCicloSeguridad            := 0;
        END;            { IF CicloSintactico = ControlCicloSintactico ELSE }
        IF BanderaIniciativa THEN BEGIN
          IF ( CasillaIniciativaHCGM IN MacroParametro ) AND
                NOT( ForzarRecalculoTotalCVDH IN DescriptoresHoja ) AND
                NOT( BanderaPeticionNudillar ) AND
                NOT( BanderaMacroFuncional   ) THEN BEGIN
            EvaluarMacroFuncionSimple           := TRUE;
            Exit;
          END;  { IF CasillaIniciativaHCGM IN MacroParametro }
        END;  { IF BanderaIniciativa }
        IF PeticionCalculoObligadoCVDH IN DescriptoresHoja THEN BEGIN
          // Por defecto la evaluacion obliga recalculo
          // completo de todo lo pertinente, esta bandera permite usar
          // resultados previos
          // algunas hojas detalladas en procesadores lentos,
          // pueden ser muy lentas...
          // En tal caso se necesita BanderaPeticionCalculo
          // activa para reevaluar
          IF NOT( BanderaPeticionCalculo  OR
                  BanderaPeticionNudillar OR
                  BanderaMacroFuncional )
          THEN BEGIN
            IF NOT( ForzarRecalculoTotalCVDH IN DescriptoresHoja )
            THEN BEGIN
              IF NOT( ActivarCicloHCGM IN MacroParametro  ) OR
                 ( TodoCicloProhibidoCVDH IN DescriptoresHoja )
              THEN BEGIN
                // Medida preventida
                // pues ForzarRecalculoTotalCVDH tiene prioridad
                // ademas los ciclos tiene reglas especiales
                // TodoCicloProjibidoCVDH con
                // prioridad sobre ActivarCicloHCGM
                EvaluarMacroFuncionSimple         := TRUE;
                Exit;
              END;  { IF NOT( ActivarCicloHCGM... }
            END;  { IF NOT( ForzarRecalculoTotalCVDH IN DescriptoresHoja ) }
          END;  { IF NOT( BanderaPeticionCalculo OR ... ) }
        END;  { IF PeticionCalculoObligadoCVDH IN DescriptoresHoja }
        BanderaPeticionCalculo                  := TRUE;
        IF BanderaPeticionNudillar THEN BEGIN
          BanderaPeticionCalculo                := TRUE;
          IF NOT( PeticionNudillarMacroFuncionSimple
                ( Fila, Columna, Msg, Manejador ) )
          THEN BEGIN
            BanderaPeticionNudillar             := TRUE;
            EvaluarMacroFuncionSimple           := FALSE;
            IF ( Msg = '' ) AND
               ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
              Msg                 := 'Error al interpretar';
              CAFE_PosicionInfructuosoSintactico  :=
                                  CAFE_4ErrorVarErrorInterpretar;
              CAFE_MensajeInfructuosoSintactico   := Msg;
              CAFE_IntentoInfructuosoSintactico   := TRUE;
            END;  { IF Msg = '' }
            Exit;
          END;  { IF NOT( PeticionNudillarMacroFuncionSimple... ) }
          BanderaPeticionNudillar               := FALSE;
        END;  { IF BanderaPeticionNudillar }
        Exclude( DescriptoresHoja, AlertaDominioCVDH );
        IF FuncionNudillado.EvaluarMacroFuncion
                ( ResultMacro, Msg, Manejador, TotalParMacro,
                        Param1, Param2, Param3, CicloSintactico ) THEN BEGIN
          TipoReturn                            := ResultMacro;
          MarcaCicloSintactico                  := 0;
          BanderaPeticionCalculo                := FALSE;
          EvaluarMacroFuncionSimple             := TRUE;
          IF AlertaDominioCVDH IN DescriptoresHoja THEN BEGIN
            Include( MacroParametro, AlertaDominioHCGM );
            CAFE_BanderaAlertaDominio           := TRUE;
          END;  { IF AlertaDominioCVDH IN DescriptoresHoja }
        END ELSE BEGIN  { IF ...EvaluarMacroFuncion... ELSE }
          MarcaCicloSintactico                  := 0;
          BanderaPeticionNudillar               := TRUE;
          BanderaPeticionCalculo                := TRUE;
          EvaluarMacroFuncionSimple             := FALSE;
          IF CAFE_PosicionInfructuosoSintactico <> 0
          THEN Exit;
          IF Msg = '' THEN BEGIN
            Msg                 := 'Error al evaluar';
            CAFE_PosicionInfructuosoSintactico  :=
                                CAFE_4ErrorVarErrorEvaluar;
            CAFE_MensajeInfructuosoSintactico   := Msg;
            CAFE_IntentoInfructuosoSintactico   := TRUE;
          END;  { IF Msg = '' }
          Exit;
        END;            { IF ...EvaluarMacroFuncion... ELSE }
      END;  { WITH MyRec as CAFE_DatoNudillado }
    END;            { IF PruebaMyRec ELSE }
  END;  { WITH MyManejador }
END;   { FUNCTION CAFE_HojaCalculoBase.EvaluarMacroFuncionSimple }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

FUNCTION   CAFE_HojaCalculoBase.PeticionNudillarMacroFuncionSimple
  (       Fila, Columna         : LongInt;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico          ) : Boolean;
VAR
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  MyRec                         : CAFE_DatoExtendido;
  MacroLiteral                  : ShortString;
  PivoteArbol                   : CAFE_Nudo2Sintactico;
  PruebaMyRec                   : Boolean;

BEGIN  { FUNCTION CAFE_Nudo2Sintactico.PeticionNudillarMacroFuncionSimple }
  Msg                           := '';
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
  PeticionNudillarMacroFuncionSimple            := FALSE;
  WITH MyManejador DO BEGIN
    MyRec                       := SintacticaHoja[ Fila ][ Columna ];
    PruebaMyRec                 := MyRec = NIL;
    IF NOT( PruebaMyRec )
    THEN PruebaMyRec            := NOT( MyRec is CAFE_DatoNudillado );
    IF PruebaMyRec THEN BEGIN
      PeticionNudillarMacroFuncionSimple        := FALSE;
      Exit;
    END ELSE BEGIN  { IF PruebaMyRec ELSE }
      WITH ( MyRec as CAFE_DatoNudillado ) DO BEGIN
        BanderaPeticionNudillar                 := FALSE;
        BanderaPeticionCalculo                  := TRUE;
        MacroLiteral                            :=
                        VariantHoja[ Fila ][ Columna ];
        IF GramaticaCharByte.GramaticaOperadores( MacroLiteral ) THEN BEGIN
          PivoteArbol                           :=
                GeneradorArbolSintactico.NuevoArbol( GramaticaCharByte );
          IF PivoteArbol <> NIL THEN BEGIN
            // Esta asignacion deberia provocar la destruccion
            // del anterior FuncionNudillado si existe
            FuncionNudillado                      := PivoteArbol;
            IF PivoteArbol.InterpretarMacroFuncion
                 ( Manejador, TipoReturn, Msg,
                 NombreParametroUno, NombreParametroDos, NombreParametroTres )
            THEN BEGIN
              BanderaPeticionNudillar                   := FALSE;
              PeticionNudillarMacroFuncionSimple        := TRUE;
            END ELSE BEGIN  { IF PivoteArbol.InterpretarFuncion( Manejador ) }
              BanderaPeticionNudillar                   := TRUE;
              FreeAndNil( FuncionNudillado );
              IF CAFE_PosicionInfructuosoSintactico = 0 THEN BEGIN
                CAFE_IntentoInfructuosoSintactico    := TRUE;
                CAFE_MensajeInfructuosoSintactico    := 'Error de sintaxis';
                CAFE_PosicionInfructuosoSintactico   :=
                                  CAFE_4ErrorVarErrorInterpretar;
                PeticionNudillarMacroFuncionSimple   := FALSE;
                Exit;
              END;         { IF CAFE_MensajeIntentoInfructuoso }
            END;            { IF PivoteArbol.InterpretarFuncion( Manejador ) }
          END ELSE BEGIN  { IF PivoteArbol <> NIL ELSE }
            IF CAFE_PosicionInfructuosoSintactico = 0 THEN BEGIN
              CAFE_IntentoInfructuosoSintactico    := TRUE;
              CAFE_MensajeInfructuosoSintactico    := 'Error de sintaxis';
              CAFE_PosicionInfructuosoSintactico   :=
                                CAFE_4ErrorNudilladoGeneral;
              PeticionNudillarMacroFuncionSimple   := FALSE;
              Exit;
            END;         { IF CAFE_MensajeIntentoInfructuoso }
          END;            { IF PivoteArbol <> NIL ELSE }
        END ELSE BEGIN { IF GramaticaCharByte.GramaticaOperadores... ELSE }
          PeticionNudillarMacroFuncionSimple       := FALSE;
          IF CAFE_PosicionInfructuosoSintactico = 0 THEN BEGIN
            CAFE_IntentoInfructuosoSintactico      := TRUE;
            CAFE_MensajeInfructuosoSintactico      := 'Error de sintaxis';
            CAFE_PosicionInfructuosoSintactico     :=
                                CAFE_4ErrorGramaticaOperadoresGeneral;
            Exit;
          END;         { IF CAFE_MensajeIntentoInfructuoso = '' }
        END;        { IF GramaticaCharByte.GramaticaOperadores... ELSE }
      END;  { WITH ( MyRec as CAFE_DatoNudillado ) }
    END;            { IF PruebaMyRec ELSE }
  END;  { WITH MyManejador }
END;   { FUNCTION CAFE_Nudo2Sintactico.PeticionNudillarMacroFuncionSimple }

FUNCTION    CAFE_HojaCalculoBase.EscribirBoolean
  (       Fila, Columna         : LongInt;
          ValorBoolean          : Boolean                       ) : Boolean;
BEGIN  { FUNCTION CAFE_HojaCalculoBase.EscribirBoolean }
  IF AnularCasilla( Fila, Columna ) THEN BEGIN
    VariantHoja[ Fila ][ Columna ]              := ValorBoolean;
    EscribirBoolean                             := TRUE;
  END ELSE BEGIN  { IF AnularCasilla( Fila, Columna ) }
    EscribirBoolean                             := FALSE;
  END;            { IF AnularCasilla( Fila, Columna ) }
END;   { FUNCTION CAFE_HojaCalculoBase.EscribirBoolean }

FUNCTION    CAFE_HojaCalculoBase.CopiarCasilla
  (       Fila, Columna                 : LongInt;
          NuevaFila, NuevaColumna       : LongInt;
    OUT   Msg                   : ShortString;
          Manejador             : CAFE_InterfaceBasico;
          BanderaPendiente      : Boolean       = FALSE;
          BanderaForzarCopia    : Boolean       = FALSE;
          FilaProtegida         : LongInt       = 0;
          ColumnaProtegida      : LongInt       = 0;
          DolarIgnorar          : Boolean       = FALSE;
          BanderaSuperposicion  : Boolean       = FALSE         ) : Boolean;
{ virtual; }
VAR
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  MyRec                         : CAFE_DatoExtendido;
  CopiaLiteral,
  MacroLiteral                  : ShortString;
  BanderaMovimiento,
  PruebaMyRec                   : Boolean;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.CopiarCasilla }
  IF ( Fila = NuevaFila ) AND ( Columna = NuevaColumna ) THEN BEGIN
    CopiarCasilla               := TRUE;
    Exit;
  END;  { IF ( Fila = NuevaFila ) AND ... }
  Msg                           := '';
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
  WITH MyManejador DO BEGIN
    BanderaMovimiento           :=
        ( Fila >= FilaProtegida ) AND ( Columna >= ColumnaProtegida );
    IF BanderaMovimiento THEN BEGIN
      IF NOT( InRange( NuevaFila   , 0, Pred( FilasEnHoja    ) ) ) OR
         NOT( InRange( NuevaColumna, 0, Pred( ColumnasEnHoja ) ) )
      THEN BEGIN
        CAFE_PosicionInfructuosoSintactico      :=
                                CAFE_4ErrorCopiaProvocaRangoNoPermitido;
        Msg                       := 'Intento de copia fuera de rango';
        CAFE_MensajeInfructuosoSintactico       := Msg;
        CAFE_IntentoInfructuosoSintactico       := TRUE;
        CopiarCasilla                           := FALSE;
        Exit;
      END;  { IF NOT( InRange... }
    END;  { IF BanderaMovimiento }
    MyRec                       := SintacticaHoja[ Fila ][ Columna ];
    PruebaMyRec                 := MyRec = NIL;
    IF NOT( PruebaMyRec )
    THEN PruebaMyRec            := NOT( MyRec is CAFE_DatoNudillado );
    IF PruebaMyRec THEN BEGIN
      IF BanderaMovimiento THEN BEGIN
        AnularCasilla( NuevaFila, NuevaColumna );
        VariantHoja[ NuevaFila ][ NuevaColumna ]
                                := VariantHoja[ Fila ][ Columna ];
      END;  { IF BanderaMovimiento }
      CopiarCasilla             := TRUE;
    END ELSE BEGIN  { IF PruebaMyRec ELSE }
      WITH ( MyRec as CAFE_DatoNudillado ) DO BEGIN
        IF NOT( BanderaForzarCopia ) THEN BEGIN
          IF BanderaPeticionNudillar THEN BEGIN
            BanderaPeticionCalculo                := TRUE;
            IF NOT( PeticionNudillarMacroFuncionSimple
                  ( Fila, Columna, Msg, Manejador ) ) THEN BEGIN
              BanderaPeticionNudillar             := TRUE;
              CopiarCasilla                       := FALSE;
              IF ( Msg = '' ) AND
                 ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
                Msg                 := 'Error al interpretar';
                CAFE_PosicionInfructuosoSintactico  :=
                                    CAFE_4ErrorVarErrorInterpretar;
                CAFE_MensajeInfructuosoSintactico   := Msg;
                CAFE_IntentoInfructuosoSintactico   := TRUE;
              END;  { IF Msg = '' }
              Exit;
            END;  { IF NOT( PeticionNudillarMacroFuncionSimple... ) }
            BanderaPeticionNudillar               := FALSE;
          END;  { IF BanderaPeticionNudillar }
        END;  { IF NOT( BanderaForzar ) }
        IF BanderaMovimiento
        THEN AnularCasilla( NuevaFila, NuevaColumna );
        MacroLiteral                            :=
                      VariantHoja[ Fila ][ Columna ];
        IF FuncionNudillado <> NIL THEN BEGIN
          IF NOT( FuncionNudillado.ReescribirEnCopiaCasilla
                ( Fila, Columna, NuevaFila, NuevaColumna, Msg, Manejador,
                        MacroLiteral, CopiaLiteral,
                        FilaProtegida, ColumnaProtegida,
                        NOT( DolarIgnorar ), BanderaSuperposicion ) )
          THEN BEGIN
            CopiarCasilla                         := FALSE;
            IF NOT( CAFE_IntentoInfructuosoSintactico ) THEN BEGIN
              CAFE_IntentoInfructuosoSintactico           := TRUE;
              CAFE_MensajeInfructuosoSintactico           :=
                          'Dificultades al cambiar rango de copia';
              CAFE_PosicionInfructuosoSintactico          :=
                        CAFE_4ErrorCopiaNoPermitidaGeneral;
            END;  { IF NOT( CAFE_IntentoInfructuosoSintactico ) }
            Exit;
          END;  { IF NOT( ...ReescribirEnCopiaCasilla... ) }
        END ELSE BEGIN  { IF FuncionNudillado <> NIL ELSE }
          CopiaLiteral                  := MacroLiteral;
        END;            { IF FuncionNudillado <> NIL ELSE }
        IF BanderaMovimiento THEN BEGIN
          IF BanderaMacroFuncional THEN BEGIN
            CAFE_HabilitarUnCiclo                 :=
                                ActivarCicloHCGM IN MacroParametro;
            IF NOT( EscribirMacroSimple( NuevaFila, NuevaColumna,
                  CopiaLiteral, Msg, Manejador,
                  NombreParametroUno, ValorPruebaUno,
                  NombreParametroDos, ValorPruebaDos,
                  NombreParametroTres, ValorPruebaTres,
                  BanderaPendiente ) ) THEN BEGIN
              CAFE_HabilitarUnCiclo               := FALSE;
              CopiarCasilla                       := FALSE;
              IF ( Msg = '' ) AND ( CAFE_PosicionInfructuosoSintactico = 0 )
              THEN BEGIN
                CAFE_PosicionInfructuosoSintactico              :=
                        CAFE_4ErrorNoPudoEvaluarValoresInicialesCopiaMacro;
                Msg                             :=
                  'No pudo evaluar valores iniciales de macro en copia...';
                CAFE_MensajeInfructuosoSintactico               := Msg;
                CAFE_IntentoInfructuosoSintactico               := TRUE;
              END;  { IF ( Msg = '' ) AND ... }
              Exit;
            END;  { IF NOT( EscribirMacroSimple... ) }
            CAFE_HabilitarUnCiclo                 := FALSE;
          END ELSE BEGIN  { IF BanderaMacroFuncional ELSE }
            CAFE_HabilitarUnCiclo                 :=
                                ActivarCicloHCGM IN MacroParametro;
            IF NOT( EscribirFuncionSimple( NuevaFila, NuevaColumna,
                  CopiaLiteral, Msg, Manejador, BanderaPendiente ) )
            THEN BEGIN
              CAFE_HabilitarUnCiclo               := FALSE;
              CopiarCasilla                       := FALSE ;
              IF ( Msg = '' ) AND
                 ( CAFE_PosicionInfructuosoSintactico = 0 )
              THEN BEGIN
                CAFE_PosicionInfructuosoSintactico              :=
                                CAFE_4ErrorVarErrorEvaluar;
                Msg                            :=
                        'Error al evaluar copia casilla...';
                CAFE_MensajeInfructuosoSintactico               := Msg;
                CAFE_IntentoInfructuosoSintactico               := TRUE;
              END;  { IF ( Msg = '' ) AND ... }
              Exit;
            END;  { IF NOT( EvaluarFuncionSimple... ) }
            CAFE_HabilitarUnCiclo                 := FALSE;
          END;            { IF BanderaMacroFuncional ELSE }
          EstablecerMacroParametro
            ( NuevaFila, NuevaColumna, MacroParametro, CicloConteoMaximo );
        END ELSE BEGIN  { IF BanderaMovimiento ELSE }
          VariantHoja[ Fila ][ Columna ]        := CopiaLiteral;
          BanderaPeticionCalculo                := TRUE;
          BanderaPeticionNudillar               := TRUE;
          IF NOT( BanderaPendiente ) THEN BEGIN
            IF NOT( PeticionNudillarMacroFuncionSimple
                  ( Fila, Columna, Msg, Manejador ) ) THEN BEGIN
              BanderaPeticionNudillar             := TRUE;
              CopiarCasilla                       := FALSE;
              IF ( Msg = '' ) AND
                 ( CAFE_PosicionInfructuosoSintactico = 0 ) THEN BEGIN
                Msg                 := 'Error al interpretar';
                CAFE_PosicionInfructuosoSintactico  :=
                                    CAFE_4ErrorVarErrorInterpretar;
                CAFE_MensajeInfructuosoSintactico   := Msg;
                CAFE_IntentoInfructuosoSintactico   := TRUE;
              END;  { IF Msg = '' }
              Exit;
            END;  { IF NOT( PeticionNudillarMacroFuncionSimple... ) }
            BanderaPeticionNudillar               := FALSE;
          END;  { IF NOT( BanderaPendiente ) }
        END;            { IF BanderaMovimiento ELSE }
        CopiarCasilla                           := TRUE;
      END;  { WITH( MyRec as CAFE_DatoNudillado ) }
    END;            { IF PruebaMyRec ELSE }
  END;  { WITH MyManejador DO BEGIN }
END;   { FUNCTION CAFE_HojaCalculoBase.CopiarCasilla }

FUNCTION    CAFE_HojaCalculoBase.LiberarTodaCasilla             : Boolean;
{ virtual; }
VAR
  RecorreFila,
  RecorreColumna                : LongInt;

BEGIN  { FUNCTION CAFE_HojaCalculoBase.LiberarTodaCasilla }
  FOR RecorreFila := Low( VariantHoja ) TO High( VariantHoja ) DO
    FOR RecorreColumna := Low( VariantHoja[ RecorreFila ] ) TO
                          High( VariantHoja[ RecorreFila ] ) DO
      LiberarCasilla( RecorreFila, RecorreColumna );
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  FOR RecorreFila := Low( FormatoFila ) TO High( FormatoFila )
  DO FormatoFila[ RecorreFila ]         := NIL;
  FOR RecorreColumna := Low( FormatoColumna ) TO High( FormatoColumna )
  DO FormatoColumna[ RecorreColumna ]   := NIL;
  FormatosDefinidosCasilla.Clear;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  LiberarTodaCasilla            := TRUE;
END;   { FUNCTION CAFE_HojaCalculoBase.LiberarTodaCasilla }

FUNCTION    CAFE_HojaCalculoBase.LeerCasilla
  ( OUT   MyRec                 : CAFE_DatoExtendido;
          Fila, Columna         : LongInt                       ) : Variant;
BEGIN  { FUNCTION CAFE_HojaCalculoBase.LeerCasilla }
  MyRec                         := SintacticaHoja[ Fila ][ Columna ];
  LeerCasilla                   := VariantHoja[ Fila ][ Columna ];
END;   { FUNCTION CAFE_HojaCalculoBase.LeerCasilla }

FUNCTION    CAFE_HojaCalculoBase.EscribirCasilla
  ( CONST MyVariant             : Variant;
    CONST MyRec                 : CAFE_DatoExtendido;
          Fila, Columna         : LongInt               ) : Boolean;
{ virtual; }
BEGIN  { FUNCTION CAFE_HojaCalculoBase.EscribirCasilla }
  IF LiberarCasilla( Fila, Columna ) THEN BEGIN
    VariantHoja[ Fila ][ Columna ]      := MyVariant;
    SintacticaHoja[ Fila ][ Columna ]   := MyRec;
    EscribirCasilla                     := TRUE;
  END ELSE BEGIN  { IF LiberarCasilla( Fila, Columna ) ELSE }
    EscribirCasilla                     := FALSE;
  END;            { IF LiberarCasilla( Fila, Columna ) ELSE }
END;   { FUNCTION CAFE_HojaCalculoBase.EscribirCasilla }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_HojaCalculoBase.LeerFormato
  (       Fila, Columna         : LongInt                               )
                                        : CAFE_TCollectionItemFormatoCasilla;
BEGIN  { FUNCTION CAFE_HojaCalculoBase.LeerFormato }
  LeerFormato                           := FormatoHoja[ Fila ][ Columna ];
END;   { FUNCTION CAFE_HojaCalculoBase.LeerFormato }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_HojaCalculoBase.EscribirFormato
  ( CONST MyFormato             : CAFE_TCollectionItemFormatoCasilla;
          Fila, Columna         : LongInt               ) : Boolean;
{ virtual; }
BEGIN  { FUNCTION CAFE_HojaCalculoBase.EscribirFormato }
  FormatoHoja[ Fila ][ Columna ]        := MyFormato;
  EscribirFormato               := TRUE;
END;   { FUNCTION CAFE_HojaCalculoBase.EscribirFormato }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }

DESTRUCTOR  CAFE_HojaCalculoBase.Destroy;
{ override; }
VAR
  RecorreFila                   : LongInt;

BEGIN  { DESTRUCTOR CAFE_HojaCalculoBase.Destroy }
  LiberarTodaCasilla;
  FOR RecorreFila := Low( VariantHoja ) TO High( VariantHoja ) DO BEGIN
    SetLength( FormatoHoja[ RecorreFila ], 0 );
    SetLength( VariantHoja[ RecorreFila ], 0 );
    SetLength( SintacticaHoja[ RecorreFila ], 0 );
  END;  { FOR RecorreFila }
  SetLength( FormatoFila, 0 );
  SetLength( FormatoColumna, 0 );
  SetLength( FormatoHoja, 0 );
  SetLength( VariantHoja, 0 );
  SetLength( SintacticaHoja, 0 );
  FreeAndNil( FormatosDefinidosCasilla );
  FilasEnHoja                   := 0;
  ColumnasEnHoja                := 0;
  DescriptoresHoja              := [];
END;   { DESTRUCTOR CAFE_HojaCalculoBase.Destroy }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

CONSTRUCTOR CAFE_TCollectionItemFormatoCasilla.Create
  (       ACollection           : TCollection                           );
{ override; }
BEGIN  { CONSTRUCTOR CAFE_TCollectionItemFormatoCasilla.Create }
  Inherited Create( ACollection );
  NombreFormato                                 := '';
  BanderaProteccionEscrituraItem                := FALSE;
  BanderaVisibleHoja                            := FALSE;
  BanderaVisibleImpresionItem                   := FALSE;
  BanderaFormatoBorrableUso                     := FALSE;
  StringFormato                                 := '';
  ColorLetra                                    := CAFE_RGBNegro;
  ColorFondo                                    := CAFE_RGBNegro;
  ParametroReal1                                := 0.0;
  EnterosDescriptores                           := NIL;
  ConjuntoFormato                               := [];
  MoldeGeneradorItemFormato                     :=
                        CAFE_TCollectionItemFormatoCasilla;
END;   { CONSTRUCTOR CAFE_TCollectionItemFormatoCasilla.Create }

FUNCTION    CAFE_TCollectionItemFormatoCasilla.
            PeticionItemFormatoSimilar  : CAFE_TCollectionItemFormatoCasilla;
{ virtual; }
VAR
  PivoteItem                    : CAFE_TCollectionItemFormatoCasilla;

BEGIN  { FUNCTION ...PeticionItemFoamrtoSimilar }
  PivoteItem                    := MoldeGeneradorItemFormato.Create( NIL );
  PivoteItem.NombreFormato      := NombreFormato;
  PivoteItem.BanderaProteccionEscrituraItem     :=
                                BanderaProteccionEscrituraItem;
  PivoteItem.BanderaVisibleHoja                 := BanderaVisibleHoja;
  PivoteItem.BanderaVisibleImpresionItem        :=
                                BanderaVisibleImpresionItem;
  PivoteItem.BanderaFormatoBorrableUso          := BanderaFormatoBorrableUso;
  PivoteItem.StringFormato                      := StringFormato;
  PivoteItem.ColorLetra                         := ColorLetra;
  PivoteItem.ColorFondo                         := ColorFondo;
  PivoteItem.ParametroReal1                     := ParametroReal1;
  PivoteItem.EnterosDescriptores                :=
        Copy( EnterosDescriptores, 0, Length( EnterosDescriptores ) );
  PivoteItem.ConjuntoFormato                    := ConjuntoFormato;
  PeticionItemFormatoSimilar                    := PivoteItem;
END;   { FUNCTION ...PeticionItemFormatoSimilar }

FUNCTION    CAFE_TCollectionItemFormatoCasilla.
                        ObtenerTFormatSettings  : CAFE_PFormatSettings;
{ virtual; }
BEGIN  { FUNCTION ...ObtenerTFormatSettings }
  ObtenerTFormatSettings                        := NIL;
END;   { FUNCTION ...ObtenerTFormatSettings }

FUNCTION    CAFE_TCollectionItemFormatoCasilla.AplicarFormatFloat
  (       ValorFloat            : Double                ) : ShortString;
VAR
  PivoteResultado               : ShortString;
  PivoteFormat                  : CAFE_PFormatSettings;

BEGIN  { FUNCTION ...AplicarFormatFloat }
  PivoteResultado               := '';
  PivoteFormat                  := ObtenerTFormatSettings;
  TRY
    IF PivoteFormat = NIL THEN BEGIN
      CASE Length( EnterosDescriptores ) OF
        0  : PivoteResultado      := Format( StringFormato, [ ValorFloat ] );
        1  : PivoteResultado      :=
                        Format( StringFormato, [ ValorFloat,
                                        EnterosDescriptores[ 0 ] ] );
        2  : PivoteResultado      :=
                        Format( StringFormato, [ ValorFloat,
                                        EnterosDescriptores[ 0 ],
                                        EnterosDescriptores[ 1 ] ] );
        3  : PivoteResultado      :=
                        Format( StringFormato, [ ValorFloat,
                                        EnterosDescriptores[ 0 ],
                                        EnterosDescriptores[ 1 ],
                                        EnterosDescriptores[ 2 ] ] );
        4  : PivoteResultado      :=
                        Format( StringFormato, [ ValorFloat,
                                        EnterosDescriptores[ 0 ],
                                        EnterosDescriptores[ 1 ],
                                        EnterosDescriptores[ 2 ],
                                        EnterosDescriptores[ 3 ] ] );
        ELSE PivoteResultado      := FloatToStr( ValorFloat );
      END;  { CASE Length( EnterosDescriptores ) }
    END ELSE BEGIN  { IF PivoteFormat = NIL ELSE }
      CASE Length( EnterosDescriptores ) OF
        0  : PivoteResultado      :=
                Format( StringFormato, [ ValorFloat ], PivoteFormat^ );
        1  : PivoteResultado      :=
                        Format( StringFormato, [ ValorFloat,
                                        EnterosDescriptores[ 0 ] ],
                                        PivoteFormat^ );
        2  : PivoteResultado      :=
                        Format( StringFormato, [ ValorFloat,
                                        EnterosDescriptores[ 0 ],
                                        EnterosDescriptores[ 1 ] ],
                                        PivoteFormat^ );
        3  : PivoteResultado      :=
                        Format( StringFormato, [ ValorFloat,
                                        EnterosDescriptores[ 0 ],
                                        EnterosDescriptores[ 1 ],
                                        EnterosDescriptores[ 2 ] ],
                                        PivoteFormat^ );
        4  : PivoteResultado      :=
                        Format( StringFormato, [ ValorFloat,
                                        EnterosDescriptores[ 0 ],
                                        EnterosDescriptores[ 1 ],
                                        EnterosDescriptores[ 2 ],
                                        EnterosDescriptores[ 3 ] ],
                                        PivoteFormat^ );
        ELSE PivoteResultado      := FloatToStr( ValorFloat );
      END;  { CASE Length( EnterosDescriptores ) }
    END;            { IF PivoteFormat = NIL ELSE }
  EXCEPT
    ON EConvertError
    DO PivoteResultado          := FloatToStr( ValorFloat );
  END;  { TRY }
  AplicarFormatFloat            := PivoteResultado;
END;   { FUNCTION ...AplicarFormatFloat }

  {$IFDEF       SILENCIAR       }
  {$HINTS       OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_TCollectionItemFormatoCasilla.CompatibleFormat
  ( CONST ValorVariant          : Variant                       ) : Boolean;
{ virtual; }
BEGIN  { FUNCTION CAFE_TCollectionItemFormatoCasilla.CompatibleFormat }
  CompatibleFormat              := TRUE;
END;   { FUNCTION CAFE_TCollectionItemFormatoCasilla.CompatibleFormat }
  {$IFDEF       SILENCIAR       }
  {$HINTS       ON              }
  {$ENDIF                       }

FUNCTION    CAFE_TCollectionItemFormatoCasilla.
                        Read_ProteccionEscritura                : Boolean;
BEGIN  { FUNCTION ...Read_ProteccionEscritura }
  IF BanderaProteccionEscrituraItem THEN BEGIN
    Read_ProteccionEscritura            := TRUE;
  END ELSE BEGIN  { IF BanderaProteccionEscrituraItem ELSE }
    IF ( Collection as CAFE_TCollectionFormatoCasilla ).
                                Owner is CAFE_HojaCalculoBase THEN BEGIN
      Read_ProteccionEscritura          := BloquearCasillasCVDH IN
        ( ( Collection as CAFE_TCollectionFormatoCasilla ).
                Owner as CAFE_HojaCalculoBase ).DescriptoresHoja;
    END ELSE BEGIN
      Read_ProteccionEscritura          := FALSE;
    END;
  END;            { IF BanderaProteccionEscrituraItem ELSE }
END;   { FUNCTION ...Read_ProteccionEscritura }

PROCEDURE   CAFE_TCollectionItemFormatoCasilla.Write_ProteccionEscritura
  (       NuevoBoolean          : Boolean                               );
BEGIN  { PROCEDURE ...Write_ProteccionEscritura }
  BanderaProteccionEscrituraItem        := NuevoBoolean;
END;   { PROCEDURE ...Write_ProteccionEscritura }

DESTRUCTOR  CAFE_TCollectionItemFormatoCasilla.Destroy;
{ override; }
BEGIN  { DESTRUCTOR CAFE_TCollectionItemFormatoCasilla.Destroy }
  NombreFormato                                 := '';
  BanderaProteccionEscrituraItem                := FALSE;
  BanderaVisibleHoja                            := FALSE;
  BanderaVisibleImpresionItem                   := FALSE;
  BanderaFormatoBorrableUso                     := FALSE;
  ColorLetra                                    := CAFE_RGBNegro;
  ColorFondo                                    := CAFE_RGBNegro;
  StringFormato                                 := '';
  ParametroReal1                                := 0.0;
  SetLength( EnterosDescriptores, 0 );
  ConjuntoFormato                               := [];
  Inherited Destroy;
END;   { DESTRUCTOR CAFE_TCollectionItemFormatoCasilla.Destroy }

CONSTRUCTOR CAFE_TCollectionFormatoCasilla.Create
  (       AOwner                : TPersistent                           );
{ virtual; }
BEGIN  { CONSTRUCTOR CAFE_TCollectionFormatoCasilla.Create }
  Inherited Create( AOwner, CAFE_TipoCollectionFormato );
  MoldeGeneradorFormato         := CAFE_TCollectionFormatoCasilla;
END;   { CONSTRUCTOR CAFE_TCollectionFormatoCasilla.Create }

FUNCTION    CAFE_TCollectionFormatoCasilla.PeticionFormatoSimilar
                                        : CAFE_TCollectionFormatoCasilla;

{ virtual; }
VAR
  PivoteRespuesta               : CAFE_TCollectionFormatoCasilla;
  NuevoItem                     : CAFE_TCollectionItemFormatoCasilla;
  PivoteItem                    : TCollectionItem;

BEGIN  { FUNCTION CAFE_TCollectionFormatoCasilla.PeticionFormatoSimilar }
  PivoteRespuesta               :=
                MoldeGeneradorFormato.Create( NIL );
  FOR PivoteItem IN Self DO BEGIN
    NuevoItem                   :=
        ( PivoteItem as CAFE_TCollectionItemFormatoCasilla ).
        PeticionItemFormatoSimilar;
    NuevoItem.Collection        := PivoteRespuesta;
  END;  { FOR PivoteItem }
  PeticionFormatoSimilar        := PivoteRespuesta;
END;   { FUNCTION CAFE_TCollectionFormatoCasilla.PeticionFormatoSimilar }

FUNCTION    CAFE_TCollectionFormatoCasilla.BuscarNombreFormato
  ( CONST NombreBuscado         : String                                )
                                        : CAFE_TCollectionItemFormatoCasilla;
VAR
  ItemFormato                   : TCollectionItem;

BEGIN  { FUNCTION CAFE_TCollectionFormatoCasilla.Create }
  FOR ItemFormato IN Self DO BEGIN
    IF ( ItemFormato as CAFE_TCollectionItemFormatoCasilla ).
                        NombreFormato = NombreBuscado
    THEN Exit( ItemFormato as CAFE_TCollectionItemFormatoCasilla );
  END;  { FOR ItemFormato }
  BuscarNombreFormato           := NIL;
END;   { FUNCTION CAFE_TCollectionFormatoCasilla.Create }

  { IMPLEMENTATION }
VAR
  ImplementationNumeroNuevoFormato      : LongInt               = 0;
  // El numero no importa simplemente, se quiere identificadores diferentes
  { IMPLEMENTATION }

FUNCTION    CAFE_TCollectionFormatoCasilla.
                        GenerarNuevoNombreFormato               : String;
VAR
  PivoteNombre                          : String;

BEGIN  { FUNCTION CAFE_TCollectionSave.GenerarNuevoNombreFormato }
  REPEAT
    Inc( ImplementationNumeroNuevoFormato );
    PivoteNombre                        :=
                Format( 'F%.d', [ 3 ] );
  UNTIL BuscarNombreFormato( PivoteNombre ) = NIL;
  GenerarNuevoNombreFormato             := PivoteNombre;
END;   { FUNCTION CAFE_TCollectionSave.GenerarNuevoNombreFormato }

DESTRUCTOR  CAFE_TCollectionFormatoCasilla.Destroy;
{ override; }
BEGIN  { DESTRUCTOR CAFE_TCollectionFormatoCasilla.Destroy }
  Inherited Destroy;
END;   { DESTRUCTOR CAFE_TCollectionFormatoCasilla.Destroy }

CONSTRUCTOR CAFE_TCollectionUndo.Create
  (       AOwner        : TPersistent;
          AItemClass    : TCollectionItemClass                          );
{ override; }
BEGIN  { CONSTRUCTOR CAFE_TCollectionUndo.Create }
  Inherited Create( AOwner, AItemClass );
  MaximoNivelUndo       := CAFE_MaximoNivelUndoHojaCalculo;
END;   { CONSTRUCTOR CAFE_TCollectionUndo.Create }

PROCEDURE   CAFE_TCollectionUndo.Escribir_NivelUndo
  (       NuevoNivel    : LongInt                                       );
BEGIN  { CAFE_TCollectionUndo.Escribir_NivelUndo }
  IF InRange( NuevoNivel, 0, CAFE_MaximoNivelUndoAdmisible )
  THEN BEGIN
    MaximoNivelUndo     := NuevoNivel;
    AjustarMaximoNivelUndo;
  END ELSE BEGIN  { IF InRange( NuevoNivel, ... ) ELSE }
    RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_4ErrorDatoFueraRangoAdmisible );
  END;            { IF InRange( NuevoNivel, ... ) ELSE }
END;   { CAFE_TCollectionUndo.Escribir_NivelUndo }

PROCEDURE   CAFE_TCollectionUndo.CopiaActualHojaCalculo;
VAR
  HojaPivote            : CAFE_HojaCalculoBase;

BEGIN  { PROCEDURE CAFE_TCollectionUndo.CopiaActualHojaCalculo }
  IF ( Owner as CAFE_ManejadorBasico ).HojaDefault = NIL
  THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorOrdenRequiereHojaTrabajo );
  IF MaximoNivelUndo <= 0
  THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorMecanismoUndoDesactivadoHojaTrabajo );
  WITH ( Owner as CAFE_ManejadorBasico ).HojaDefault DO BEGIN
    HojaPivote          := PeticionHojaSimilar;
    HojaPivote.Collection               := Self;
    AjustarMaximoNivelUndo;
  END;  { WITH Owner }
END;   { PROCEDURE CAFE_TCollectionUndo.CopiaActualHojaCalculo }

PROCEDURE   CAFE_TCollectionUndo.UndoHojaCalculo
  (       NivelUndo     : LongInt                                       );
VAR
  HojaPivote            : TCollectionItem;

BEGIN  { PROCEDURE CAFE_TCollectionUndo.UndoHojaCalculo }
  IF ( Owner as CAFE_ManejadorBasico ).HojaDefault = NIL
  THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorOrdenRequiereHojaTrabajo );
  IF MaximoNivelUndo <= 0
  THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_4ErrorMecanismoUndoDesactivadoHojaTrabajo );
  IF Count > 0 THEN BEGIN
    WITH Owner as CAFE_ManejadorBasico DO BEGIN
      HojaPivote        := Self.Items[ NivelUndo MOD Count ];
      IF NOT( HojaPivote is CAFE_HojaCalculoBase )
      THEN CAFE_PipeException.Create
          ( ErrorREPO, CAFE_4ErrorPosibleIncompatibilidadVersion );
      FreeAndNIL( HojaDefaultI );
      HojaDefaultI      :=
          ( HojaPivote as CAFE_HojaCalculoBase ).PeticionHojaSimilar;
    END;  { WITH Owner as CAFE_ManejadorBasico }
  END;  { IF Count > 0 }
END;   { PROCEDURE CAFE_TCollectionUndo.UndoHojaCalculo }

PROCEDURE   CAFE_TCollectionUndo.AjustarMaximoNivelUndo;
VAR
  HojaPivote            : TCollectionItem;

BEGIN  { PROCEDURE CAFE_TCollectionUndo.AjustarMaximoNivelUndo }
  WHILE MaximoNivelUndo < Count DO BEGIN
    HojaPivote          := Self.Items[ 0 ];
    HojaPivote.Collection               := NIL;
    FreeAndNil( HojaPivote );
  END;  { WHILE MaximoNivelUndo < Count }
END;   { PROCEDURE CAFE_TCollectionUndo.AjustarMaximoNivelUndo }

PROCEDURE   CAFE_TCollectionUndo.ClearUndo;
{ virtual; }
VAR
  HojaPivote            : TCollectionItem;

BEGIN  { PROCEDURE Cafe_TCollectionUndo.ClearUndo }
  WHILE Count > 0 DO BEGIN
    HojaPivote          := Self.Items[ 0 ];
    HojaPivote.Collection               := NIL;
    FreeAndNil( HojaPivote );
  END;  { WHILE MaximoNivelUndo < Count }
END;   { PROCEDURE Cafe_TCollectionUndo.ClearUndo }


DESTRUCTOR  CAFE_TCollectionUndo.Destroy;
{ override; }
BEGIN  { CONSTRUCTOR CAFE_TCollectionUndo.Destroy }
  Inherited Destroy;
END;   { CONSTRUCTOR CAFE_TCollectionUndo.Destroy }

VAR
  RecorreArreglo                : LongInt;

INITIALIZATION
  CAFE_MoldeManejadorCharByte   := CAFE_CharByte3Sintactico;
  CAFE_MoldeManejadorArbol      := CAFE_Nudo2Sintactico;
  CAFE_MoldeManejadorDatoCasilla                := CAFE_DatoNudillado;
  CAFE_MoldeManejadorPaquete                    := CAFE_Interprete2Sintactico;
  CAFE_TipoCollectionPrincipal  := CAFE_TCollectionManejador0;
  CAFE_TipoManejadorAsignado    := CAFE_ManejadorBasico;
  CAFE_TipoCollectionFormato    := CAFE_TCollectionItemFormatoCasilla;
  ImplementationSintactico      :=
        CAFE_CharByte3Sintactico.Create( CAFE_DefaultTamanoInicialCharByte );
  ImplementationFactorial[ 0 ]  := 1.0;
  FOR RecorreArreglo := 1 TO MaximoImplementationFactorial
  DO ImplementationFactorial[ RecorreArreglo ]          :=
                RecorreArreglo*ImplementationFactorial[ RecorreArreglo-1 ];
  CAFE_HabilitarUnCiclo         := FALSE;
  CAFE_ItemListaRectangular     := CAFE_TCollectionRectangular.Create;
  ImplementationCicloRectangularSintactico              := 0;
  CAFE_BanderaAlertaDominio     := FALSE;
  DateSeparator                 := CAFE_DateSeparator;
  ShortMonthNames               := CAFE_ShortMonthNames;
  LongMonthNames                := CAFE_LongMonthNames;
  ShortDayNames                 := CAFE_ShortDayNames;
  LongDayNames                  := CAFE_LongDayNames;
  CAFE_DefaultListaString                       := CAFE_TStringList.Create;
  CAFE_DefaultListaString.Sorted                := FALSE;
  CAFE_DefaultListaString.CaseSensitive         := FALSE;
FINALIZATION
  FreeAndNil( ImplementationSintactico );
  FreeAndNil( CAFE_ItemListaRectangular );
  FreeAndNil( CAFE_DefaultListaString );
END.
