JME (Java Math Expression) es un evaluador freeware de expresiones matemáticas y lógicas a partir de una cadena para entornos Java.

Se distribuye mediante una biblioteca en jar ejecutable (que lanza un REPL de JME).

La biblioteca incluye el lenguaje JMEScript, un potente lenguaje estructurado de script en español que utiliza JME para la evaluación de expresiones aritmético-lógicas.

JME realiza cálculos numéricos, no es una biblioteca de cálculo simbólico (CAS), por lo que no simplificará expresiones o resolverá ecuaciones algebraicamente (si algunas numéricas). En lugar de eso devolverá como resultado los tipos de datos del lenguaje.

JME/JMEScript es case insensitive, por lo que todas las variables, constantes, funciones y caracteres en general no diferencian mayúsculas-minúsculas (excepto para el tipo Texto y ciertos operadores). Los tokens del lenguaje están formados por distintas clases de números, operadores, funciones, identificadores, paréntesis, booleanos, vectores y cadenas. JME no es thread-safe, por lo que el programador debe encargarse de la programación multihilo.

La clase jme.Expresion es la clase principal de la biblioteca JME, encargada de crear, almacenar y evaluar las expresiones.

 , JMEScript

Para la escritura y ejecución de scripts puede utilizarse el IDE JMEScriptGUI.

• 8 tipos de datos, que actúan de envolventes (wrappers) de tipos Java:
  • RealDoble (double)
  • Complejo (holder double,double)
  • EnteroGrande (BigInteger)
  • RealGrande (BigDecimal)
  • Booleano (boolean)
  • Texto (String)
  • Vector (List<Terminal>)
  • Diccionario (Map<Terminal,Terminal>)
• 3 pseudotipos:
  • matrices (Vector)
  • conjuntos (Vector)
  • grafos (Diccionario)
• Álgebra vectorial y matricial
• Álgebra compleja
• Álgebra booleana
• Álgebra de conjuntos
• Operaciones sobre cadenas de texto
• Más de 60 operadores y más de 450 funciones
• Establecimiento de variables y constantes
• Establecimiento de operadores y funciones definidas por el usuario
• REPL en jar ejecutable
• Exportación/Importación de datos vectoriales y matriciales a CSV y exportación a HTML table, además de JSON y XML
• Lenguaje de script JMEScript, que consta principalmente de
  • estructuras de selección; si / si no, si / si no / seleccionar
  • cuatro tipos de bucles;  mientras / para / para cada / repetir hasta que
  • procedimientos locales y globales con parámetros de entrada y de entrada/salida
  • variables dinámicas que contienen tipos JME
    
  • posibilidad de llamar a acciones de la propia aplicación implementante para crear scripts sobre ella
  • captura de excepciones

Entrada y salida de expresiones JME:

Salida en REPL:

>>> set grafo=gr_nuevo([[0,1,1,0],[0,0,0,1],[0,0,0,1],[1,0,0,0]],true)||
>>> gr_fuerteconexo(grafo)

         ==> Booleano: verdadero

        (parse: 120µs(10%) / eval: 1,1ms(90%) / total: 1,2ms)

>>> gr_subyacente(grafo)

         ==> Diccionario:

                {     'etiquetas': ['v0','v1','v2','v3']
                            'ady': [[0,1,1,1],[1,0,0,1],[1,0,0,1],[1,1,1,0]]
                     'esDirigido': falso
                    'esPonderado': falso
                  'esPseudografo': falso
                   'esMultigrafo': falso
                       'nodoData': '__null__'
                     'aristaData': '__null__' }

        (parse: 171µs(15%) / eval: 948µs(85%) / total: 1,1ms)

>>> gr_conexo(ans)

         ==> Booleano: verdadero

        (parse: 124µs(12%) / eval: 876µs(88%) / total: 1ms)

>>> enumerar(grafo><'ady',grafo><'etiquetas')

         ==> VectorEvaluado:

                | 'v0'  [0,1,1,0] |
                | 'v1'  [0,0,0,1] |
                | 'v2'  [0,0,0,1] |
                | 'v3'  [1,0,0,0] |


        (parse: 262µs(20%) / eval: 1,1ms(80%) / total: 1,3ms)

Script que ejecuta acciones sobre JMEScriptGUI:

JGE (Java Graphical Expression) es una aplicación freeware para gráficas y fractales usando expresiones JME. Entre sus principales características:

• Representación de funciones reales
• Representación de fractales iterativos mediante algoritmo de escape
• Representación de funciones complejas en el plano
• Representación de campo vectoriales en el plano