C++ Math Evaluator

Siguiendo con mis experimentos en teoría de lenguajes, hice una librería en C++ que permite evaluar y reconocer una expresión matemática entre otras cosas.

Estas son las características:

Operadores

&& ||
== != < > <= >=

  • + –
  • * / %
  • ^
  • !
  • Scientific notation

Funciones

  • factorial
  • log
  • acot
  • acosh
  • sign
  • acos
  • asech
  • atan
  • asinh
  • atanh
  • acoth
  • asin
  • acsc
  • acsch
  • asec
  • cot
  • coth
  • csc
  • csch
  • log10
  • log2
  • sec
  • sech
  • sqrt
  • tan
  • rand_0_to_1
  • sin
  • cos

Constantes numéricas:

pi
e
g (gravity)
random (random number)

User defined variables:

char expression[] = "sin(pi + x)";        
p.get_vars().add("x", 1.0);
p.parse(expression);
double result = p.get_numeric_answer();

Reconocimiento (saber si la expresión está bien escrita):

try {
    char expression[] = "pi^2.0 - sin(cos(tan(3.2e0)";
    p.evaluate_expression_with_exception(expression);
    cout << "Ok ... " << endl;
} catch(ParsingException ex) {
    cout << "Error: " << ex.get_msg() << endl;
}

Evaluation:

try {
    char expression[] = "pi^2.0 - sin(cos(tan(3.2e0)))";
    p.evaluate_expression_with_exception(expression);
    p.parse(expression);
    double r = p.get_numeric_answer();
    cout << "Ok ... " << r << endl;
} catch(ParsingException ex) {
    cout << "Error: " << ex.get_msg() << endl;
}

Arrays:

Parser p;
p.get_arrays().create_array("a");

for(int i = 1; i <= 10; i++) {
    p.get_arrays().add_element_to_array("a", (double)i);
}

try {
    char expression[] = "a[sin(pi) + 2]^3";
    p.parse(expression);
    double r = p.get_numeric_answer();
    cout << "Ok ... " << r << endl;
} catch(ParsingException ex) {
    cout << "Error: " << ex.get_msg() << endl;
}

Tokenization:

try {
    char expression[] = "a[sin(pi) + 2]^3";
    Parser p;
    p.extract_tokens(expression);

    vector<Lexema> tokens = p.get_lexemas_positions();

    for(size_t i = 0; i < tokens.size(); i++) {
        cout << tokens[i] << endl;
    }

} catch(ParsingException ex) {
    cout << "Error: " << ex.get_msg() << endl;
}

Salida:

{a, init(0), tipo(OPERADOR)}
{[, init(1), tipo(DELIMITADOR)}
{sin, init(2), tipo(FUNCION)}
{(, init(5), tipo(DELIMITADOR)}
{pi, init(6), tipo(VARIABLE)}
{), init(8), tipo(DELIMITADOR)}
{+, init(10), tipo(DELIMITADOR)}
{2, init(12), tipo(NUMERO)}
{], init(13), tipo(DELIMITADOR)}
{^, init(14), tipo(DELIMITADOR)}
{3, init(15), tipo(NUMERO)}

Function domain checking (trigonometric functions):

try {
    Parser p;
    char expression[] = "1 + asin(1.2)";
    p.evaluate_expression_with_exception(expression);
    p.parse(expression);
} catch(ParsingException ex) {
    cout << "Error: " << ex.get_msg() << endl;
}

Output:

Error: out of domain for function '1.200000'

La librería la pueden descargar de github:

https://github.com/leogtzr/math_evaluator_cpp

 

Saludos.

 

Publicado en Uncategorized | Etiquetado , , , | 1 Comentario

Yarelang, mi lenguaje de programación

Hace un tiempo he estado desarrollando (en mis ratos libres) un lenguaje de programación, he hecho otro avance, he agregado soporte para todas las funciones trigonométricas:

  • abs
  • acos
  • acosh
  • acot
  • acoth
  • acsc
  • acsch
  • asec
  • asech
  • asin
  • asinh
  • atan
  • atan2
  • atanh
  • cos
  • cosh
  • cot
  • coth
  • csc
  • csch
  • exp
  • log
  • log10
  • log2
  • max
  • min
  • mod
  • real
  • sec
  • sech
  • sign
  • sin
  • sinh
  • sqrt
  • tan
  • tanh

Además le he dado una arreglada al código, he quitado cosas innecesarias.

Les dejo la referencia del lenguaje y algunos ejemplos de uso por si alguien gusta probarlo.

Cualquier sugerencia es bien recibida.

https://leonardogtzr.wordpress.com/2013/03/09/yare-un-lenguaje-de-programacin-propio/

El código fuente lo pueden consultar en mi cuenta de github:

https://github.com/leogtzr/yarelang-c–Imagen

Publicado en Programación | Etiquetado , , , , , | 1 Comentario

MathExpressions v1.11 librería matemática

He añadido algunas mejoras a la librería y corregido algunos bugs.

Imagen de uso:

1

Pueden descargarla y ver el código fuente desde el repositorio en GitHub.

Ver código fuente: https://github.com/leogtzr/java-mathexpressions

https://github.com/leogtzr/java-mathexpressions/archive/master.zip

Publicado en Programación | Deja un comentario

MathExpressions v1.1 librería matemática

He realizado una mejora a la librería de expresiones matemáticas: MathExpressions v1.0 librería matemática)

En esta nueva versión puedes saber si una expresión está bien escrita o mal escrita, es decir, en esta versión se hace una separación de el reconocimiento (saber si está bien o mal la expresión) con la evaluación (obtener el valor numérico que representa la expresión).

Lo siguiente es una prueba de uso:

Imagen

Y este es el resultado:

Imagen

Este es el enlace a la librería:

https://dl.dropboxusercontent.com/u/58795303/mathexpressionsv1.1.jar

Y de aquí pueden descargar la documentación:

https://dl.dropboxusercontent.com/u/58795303/javadocv1.1.rar

Cualquier comentario o sugerencia es bien recibida.

Saludos.

Publicado en Programación | Etiquetado , , | Deja un comentario

MathExpressions v1.0 librería matemática

He escrito una librería en Java para evaluar expresiones matemáticas de cualquier índole, por ejemplo:

1+2*sin(pi) – 4 * cos(pi) – g^2

Esta librería incluye las siguientes funciones trigonométricas y no trigonométricas:

Seno, factorial, logaritmo natural, cotangente inverso, coseno hiperbólico inverso, coseno inverso, secante hiperbólico inverso, tangente inverso, seno hiperbólico inverso, tangente hiperbólico inverso, cotangente hiperbólico inverso, seno inverso, cosecante inverso, cosecante hiperbólico inverso, secante inverso, cotangente, cotangente hiperbólico, cosecante, cosecante hiperbólico, logaritmo 10, logaritmo 2, secante, secante hiperbólico, sqrt, tangente, aleatorios entre 0 y 1 y aleatorios con rango.

Pueden ver el API y darse una idea de lo que trae la librería.

La librería hace comprobaciones de dominio para las funciones antes citadas (solo para las que aplique un dominio).

Ejemplo sencillo de uso:

1

Su uso es muy sencillo, hay que crear una instancia de Parser, luego invocamos al método parse(String) pasándole un String y este se encarga de evaluarla dejando el resultado listo para ser consultado con el método getRespuestaNumerica().

2

La librería tiene licencia GPL v3.

Instalación.

Uso en NetBeans

Crear un proyecto Java, dar clic derecho en el proyecto, elegir Propiedades (al final de todas las opciones), elegir Libraries y dar clic en el botón “Add JAR/Folder”:

4

Buscar o explorar el archivo MathExpressions.jar y dar en Abrir, eso es todo.

Uso fuera de NetBeans

3

Si prefieren no usar el .jar y usar los archivos .java igual está bien, solo hay que descomprimir el archivo .jar, son 3 clases las que contiene esta librería.

El JavaDoc para la librería lo pueden descargar de aquí:
https://dl.dropboxusercontent.com/u/58795303/MathExpressions%20Javadoc.rar

La librería la descargan de aquí:
https://dl.dropboxusercontent.com/u/58795303/mathexpressions.jar

Si encuentrar errores o si tienen alguna sugerencia, todo es bienvenido.

La librería es facilmente implementable en C#, quizás la haga en un rato más.

PD: He convertido la librería a C#, aquí está:

https://dl.dropboxusercontent.com/u/58795303/MathExpressionsCSharp.rar

¡Saludos!

Publicado en Programación | Etiquetado , , , , , , , , , , | 8 comentarios

Java – Enumeraciones avanzadas

Como en otros lenguajes de programación, una enum o un tipo enum en Java es una variable que puede tener un conjunto de constantes predefinidas.

¿Y para qué me sirve eso?

Pongamos el siguiente ejemplo,  nosotros necesitamos representar el valor de los días de la semana, podríamos lograrlo utilizando constantes y variables int de la siguiente manera:

Imagen

¿Hasta aquí todo bien, pero qué pasaría si alguien hiciera esto?

Imagen

¿Cuál debe ser el valor de sumar DOMINGO + SABADO?

Simplemente no tiene lógica ni significado, nosotros necesitamos de una variable que almacene un solo valor y ¡SOLO ESE VALOR!

Para eso nos viene perfecta una enumeración, esta es la sintaxis en Java:

Imagen

enum + Identificador + CONSTANTES

Y la asignación la podemos hacer así:

Imagen

Y solamente así, debido a  que los constructores en los enums son privados, por lo tanto es un error de compilación usar new para intentar hacer una instancia de una enum primitiva.

Los enums pueden tener métodos

Las enums pueden tener métodos, no solo nos sirven para representar un tipo o un número ordinal, podemos tener algo así:

Imagen

Y podemos invocar ese método así:

Imagen

Ó así:

Imagen

Los enums pueden tener constructores y variables de instancia, ejemplo:

Imagen

Cuando haces:

Imagen

Internamente el enum asocia esa constante a su constructor:

Imagen

Es decir, pasa ese 1 que está en la constante dentro del enum a su constructor.

Podemos pasar lo que necesitemos, un ejemplo (sin utilidad) es el siguiente:

Imagen

En este ejemplo hemos utilizado ya una referencia y no una variable primitiva.

Comportamiento específico para cada constante

En ocasiones podemos necesitar que cuando se invoque a una constante se invoque a un método específico para esa constante, es por esto que las enumeraciones brindan la posibilidad de incluír métodos abstractos para que dentro de cada constante tengas que sobreescribir ese método y dar un comportamiento específico, veamos un ejemplo:

Imagen

Como se puede observar hemos declarado un método abstracto llamado getRGB que regresa un array de ints, al hacer esto estamos obligados a dar una implementación en el bloque de cada constante.

Podemos utilizarlo así:

Imagen

A continuación alguna de las reglas que tienen las enumeraciones:

  • No se pueden hacer operaciones aritméticas entre enumeraciones, a menor que sea entre los métodos internos de la enumeración, ejemplo:Imagen
  • Todas las enumeraciones extienden de la clase Enum, pueden consultar el API para ver otros métodos interesantes aparte del ordinal().
  • Dentro de cada bloque de las constantes podemos tener n cantidad de métodos, pero solo los que estén sobrescribiendo los métodos abstractos tendrán visibilidad fuera de la enumeración.
  • Las enumeración son otro tipo de variable que puede utilizarse en un switch.
  • Las enumeraciones al igual que las clases pueden estar en archivos separados y aplican las mismas reglas de modificadores de acceso que para las clases.
  • Los constructores de una enumeración siempre son privados, SIEMPRE, es un error intentar hacer esto:
  • Imagen
  • Las enumeraciones ya implementan el método toString().
  • Las enumeraciones pueden tener variables de instancia tal como las clases.
  • Pueden utilizar el método values() para obtener las constantes de la enumeración.

Eso es todo, espero les sea de utilidad, cualquier comentario es bien recibido.

¡Saludos!

Publicado en Programación | Etiquetado , , , , , , | 2 comentarios

Java – Método toString()

Hay ocasiones en las que creamos una instancia y nos interesa conocer el estado de este objeto, con estado me refiero a cómo está conformado el objeto o cuáles son los valores de sus propiedades (variables de instancia). Por ejemplo, suponiendo que tuviéramos una clase así:

Imagen

Y suponiendo que quisiéramos imprimir el objeto de la siguiente manera:

Imagen

Esto nos devolvería:

Imagen

Lo cual no representa en absoluto el “estado” del objeto, es decir su contenido. Lo que nosotros buscamos es obtener una representación textual de nuestro objeto, y para eso debemos de sobreescribir en nuestra clase el método toString() el cuál es heredado desde la clase Object.

Podríamos hacer algo así:

Imagen

Con lo cual obtenemos algo así:

Imagen

Cabe destacar que por defecto el método System.out.println() invoca al método toString() de nuestro objeto, pero podríamos usar el método toString() de manera explícita de la siguiente manera:

Imagen

Al igual que los demás métodos de nuestra clase el método toString() debe ser mantenido, por ejemplo, si una nueva variable de instancia es añadida a la clase esta debe ser tratada por el método toString().

Conclusión, sobreescribir el método toString() es una buena práctica y sobre todo tiene buenos beneficios a la hora de depurar.

¡Saludos!

Publicado en Programación | Etiquetado , , , | 1 Comentario

Palabras raras, vocabulario

Estos últimos meses que he estado leyendo con bastante frecuencia, he ido recopilando una serie de palabras que me han parecido raras o quizás fuera de lo común, no me juzguen, hay unas que para algunos les parecerán del todo normal, pero para mí no, o por lo menos las leo o uso no muy a menudo.

En fín, estas son las palabras, se darán cuenta que son bastantes, creo que algunas están repetidas, espero les sirva a todos para aumentar su vocabulario.

¡Saludos!

  • Pagoda 
  • Corintia
  • Impelido
  • Etérea
  • Afin urbanas
  • Vides
  • Apoteosis
  • Desternillar
  • Mimético
  • Vahído
  • Cuáquero
  • Cauda
  • Áulico
  • Beldad 
  • Intersticio
  • Pacuache
  • Jaiboles
  • Beldad
  • Mequetrefe
  • Esponsales
  • Becado
  • Guernica de Picasso
  • Dispendioso
  • Rictus
  • Carnell suicidios
  • Inocula
  • Rutilante
  • Ajuar
  • Probe
  • Concomitante
  • Somera
  • Émulo
  • Asceta
  • Laya
  • Late
  • Circunspecto
  • Fútiles
  • Prosapia
  • Santoyo
  • Plétora
  • Volitivo
  • Vesubio
  • Deleznable
  • AZogue
  • Repelon
  • Hirsuta
  • Displicencia
  • Abluciones
  • Barahúnda 
  • Plúmbeo
  • Pulsion
  • Inmola
  • Efluvio
  • Habon 
  • Detritos
  • Nana
  • Machacona
  • Berrea
  • Vaharadas
  • Briznas
  • Cánula 
  • Ajados
  • Arabescos
  • Yergue
  • Guirigay
  • Laudes
  • Desbarrar
  • Miasmas
  • Curia
  • Volutas
  • Excrecencia 
  • Muesca
  • Prelado
  • Dardabasies
  • Tañer
  • Catafalco
  • Alabardas
  • Apostatas
  • Prevaricadores
  • Genuflexión
  • Vaharadas
  • Briznas
  • Cánula 
  • Ajados
  • Arabescos
  • Yergue
  • Guirigay
  • Laudes
  • Desbarrar
  • Miasmas
  • Curia
  • Volutas
  • Excrecencia 
  • Muesca
  • Prelado
  • Dardabasies
  • Tañer
  • Catafalco
  • blasón
  • dogo
  • derogación
  • lisonjas
  • Vaharadas
  • Briznas
  • Cánula 
  • Ajados
  • Arabescos
  • Yergue
  • Guirigay
  • Laudes
  • Desbarrar
  • Miasmas
  • Curia
  • Volutas
  • Excrecencia 
  • Muesca
  • Prelado
  • Dardabasies
  • Tañer
  • Catafalco
  • blasón
  • dogo
  • derogación
  • lisonjas
  • muías
  • desapacible
  • barahunda
  • comistrajo
  • fusta
  • meandros
  • tizon
  • Periplo
  • Sibilante
  • Riada
  • Sevicias
  • Detritos
  • Zarzas
  • Distendir, distender
  • Tonsurada
  • Conciliábulo
  • Carcamal
  • Esbirros
  • Nunciaturas
  • Exequias
  • Impertérrito
  • Curia
  • Retama
  • Salitre
  • Inextricable 
  • Estoicamente
  • Morros
  • Embelesada
  • Taciturno
  • Vaharadas
  • Briznas
  • Cánula 
  • Ajados
  • Arabescos
  • Yergue
  • Guirigay
  • Laudes
  • Desbarrar
  • Miasmas
  • Curia
  • Volutas
  • Excrecencia 
  • Muesca
  • Prelado
  • Dardabasies
  • Tañer
  • Catafalco
  • blasón
  • dogo
  • derogación
  • lisonjas
  • muías
  • desapacible
  • barahunda
  • comistrajo
  • fusta
  • meandros
  • tizon
  • Periplo
  • Sibilante
  • Riada
  • Sevicias
  • Detritos
  • Zarzas
  • Distendir, distender
  • Tonsurada
  • Conciliábulo
  • Carcamal
  • Esbirros
  • Nunciaturas
  • Exequias
  • Impertérrito
  • Curia
  • cogorza
  • diatriba
  • parterre
  • azaleas
  • flora
  • sorna
  • apabullada
  • fustigador
  • timorata
  • Reticente
  • Epíteto
  • Tácito
  • Escocer
  • Conato
  • Pueril
  • Comedido
  • Diáfano
  • Barrunto
  • Lascivo
  • Ostracismo
  • Remilgos
  • Subrepticia
  • Vaharadas
  • Briznas
  • Cánula 
  • Ajados
  • Arabescos
  • Yergue
  • Guirigay
  • Laudes
  • Desbarrar
  • Miasmas
  • Curia
  • Volutas
  • Excrecencia 
  • Muesca
  • Prelado
  • Dardabasies
  • Tañer
  • Catafalco
  • blasón
  • dogo
  • derogación
  • lisonjas
  • muías
  • desapacible
  • barahunda
  • comistrajo
  • fusta
  • meandros
  • tizon
  • Periplo
  • Sibilante
  • Riada
  • Sevicias
  • Detritos
  • Zarzas
  • Distendir, distender
  • Tonsurada
  • Conciliábulo
  • Carcamal
  • Esbirros
  • Nunciaturas
  • Exequias
  • Impertérrito
  • Curia
  • cogorza
  • diatriba
  • parterre
  • azaleas
  • flora
  • sorna
  • apabullada
  • fustigador
  • timorata
  • escuece
  • escozor
  • lascivo
  • casto
  • fortuito
  • sendos
  • solícito
  • Hirsuta
  • vehemencia
  • lascivo
  • espurreo
  • espurrer
  • jocoso
  • ávida
  • Abocan
  • Reticente
  • Frugalidad
  • Prerrafaelita
  • Amilano
  • Grogui
  • Fárrago so
  • Gandulear
  • lapa
  • Vaharadas
  • Briznas
  • Cánula 
  • Ajados
  • Arabescos
  • Yergue
  • Guirigay
  • Laudes
  • Desbarrar
  • Miasmas
  • Curia
  • Volutas
  • Excrecencia 
  • Muesca
  • Prelado
  • Dardabasies
  • Tañer
  • Catafalco
  • blasón
  • dogo
  • derogación
  • lisonjas
  • muías
  • desapacible
  • barahunda
  • comistrajo
  • fusta
  • meandros
  • tizon
  • Periplo
  • Sibilante
  • Riada
  • Sevicias
  • Detritos
  • Zarzas
  • Distendir, distender
  • Tonsurada
  • Conciliábulo
  • Carcamal
  • Esbirros
  • Nunciaturas
  • Exequias
  • Impertérrito
  • Curia
  • cogorza
  • diatriba
  • parterre
  • azaleas
  • flora
  • sorna
  • apabullada
  • fustigador
  • timorata
  • escuece
  • escozor
  • lascivo
  • casto
  • fortuito
  • sendos
  • solícito
  • Hirsuta
  • vehemencia
  • lascivo
  • espurreo
  • espurrer
  • jocoso
  • ávida
  • Abocan
  • Reticente
  • Frugalidad
  • Prerrafaelita
  • Amilano
  • Grogui
  • Fárrago so
  • Gandulear
  • Rezuma
  • Concupiscente
  • anfetamina
  • Floritura
  • Turgente
  • Sinergía
  • Farfullar
  • Enfurruñar
  • Céfiro
  • Inefable
  • lascivia
  • aciago
  • Pilosidad
  • Astroso
  • Sibilante
  • Osmosis
  • Pánfila 
  • Comba
  • Agazapada
  • Zarzas
  • Salmodia
  • Flirtear
  • tumefactos
  • anquilosa
  • reptar
  • seto
  • atrio
  • cúmulo
  • levita
  • frufrú
  • chirría
  • goznes
  • magma
  • ribete
  • dicasterios
  • maromas
  • desbarrar
  • curia
  • tumefacciones
  • escorbuto
  • Mejunje
  • Magra
  • Feculento 
  • Sórdido 
  • Aluvión
  • Zureaban
  • Estorninos
  • Piragua
  • Periplo
  • Zarzal
  • Sopor
  • Buril
  • Ciénagas
  • Carlinga 
  • Macilento
  • Yermas
  • Exequias
  • Deshilvanado
  • Febril
  • Estrave
  • Vaharadas
  • Briznas
  • Cánula 
  • Ajados
  • Arabescos
  • Yergue
  • Guirigay
  • Laudes
  • Desbarrar
  • Miasmas
  • Curia
  • Volutas
  • Excrecencia 
  • Muesca
  • Prelado
  • Dardabasies
  • Tañer
  • Catafalco
  • blasón
  • dogo
  • derogación
  • lisonjas
  • muías
  • desapacible
  • barahunda
  • comistrajo
  • fusta
  • meandros
  • tizon
  • Periplo
  • Sibilante
  • Riada
  • Sevicias
  • Detritos
  • Zarzas
  • Distendir, distender
  • Tonsurada
  • Conciliábulo
  • Carcamal
  • Esbirros
  • Nunciaturas
  • Exequias
  • Impertérrito
  • Curia
  • cogorza
  • diatriba
  • parterre
  • azaleas
  • flora
  • sorna
  • apabullada
  • fustigador
  • timorata
  • escuece
  • escozor
  • lascivo
  • casto
  • fortuito
  • sendos
  • solícito
  • Hirsuta
  • vehemencia
  • lascivo
  • espurreo
  • espurrer
  • jocoso
  • ávida
  • Abocan
  • Reticente
  • Frugalidad
  • Prerrafaelita
  • Amilano
  • Grogui
  • Fárrago so
  • Gandulear
  • Rezuma
  • Concupiscente
  • anfetamina
  • Floritura
  • Turgente
  • Sinergía
  • Farfullar
  • Enfurruñar
  • Céfiro
  • Inefable
  • Shadow
  • Irascible
  • Soliviantó
  • Pergeñar
  • Elucubración
  • Eulogio
  • Reverberar
  • Enjuto
  • Soliloquio
  • Bobalicón
  •  Vorágine

¡Saludos!

Publicado en Lectura | Etiquetado , , , | 2 comentarios

Toccata No.4 J.S Bach + Random Shit

Toccata No.4 J.S Bach + Random Shit

Tocando la guitarra 🙂

Publicado en Música | Deja un comentario

Yare, un lenguaje de programación propio

Yare es un pequeño lenguaje de programación en crecimiento que tiene algunas características peculiares que pudieran ser utilizadas para implementar un pequeño algoritmo de cálculo numérico o de otra índole.

Yare tiene como característica que puedes programar en inglés o en español, por ejemplo, realizar un ciclo, es lo mismo que utilices la palabra reservada while o mientras.

Yare está programado en C++ (aunque contiene elementos de C) utilizando Bison y Flex.

El proyecto Yare, tiene licencia GPL v3.

Estoy buscando colaboradores para mejorar el código y sobre todo los pendientes al final de la entrada.

Los errores que encuentres al ejecutar Yare agradecería enormemente que me los hicieras saber con una pequeña descripción a mi e-mail leorocko13@hotmail.com o leogutierrezramirez@gmail.com.

Características

Estructura

La estructura general de un script en Yare es la siguiente:

[procedimientos]*[sentencias]*.

El caracter . al final del programa es obligatorio.

Variables

En Yare por defecto hay 26 variables globales listas para utilizarse en cualquier momento, estas tienen de identificador las letras del abecedario, desde A hasta Z.

Los identificadores para estas variables no son sensibles a mayúsculas y minúsculas.

Ejemplo de uso:

a = 1 + 2 * 3;

z = a + 1;

.

El tema de asignación de variables lo veremos más adelante.

Variables definidas por el usuario

El usuario puede crear variables, pero estas deben estar delimitadas por el caracter ‘:’, dentro de estos caracteres puede estar cualquier combinación entre estos símbolos:

· “

· ‘

· Cualquier dígito (0-9)

· Espacio

· _

· #

· @

· Cualquier letra (excepto la ‘ñ’)

· Tabulador

· +

· –

· ^

· |

· (

· )

· \

· /

· !

Los identificadores pueden tener una longitud de hasta 99 caracteres.

Ejemplo de uso:

: hola ! : = -1;: esta es mi variable !!!! : = 2;: : = 345345;: : = 1 + 2 * 3;:resultados simulacion : = -2.00023;.

Literales de asignación

Los valores que pueden ser asignados a las variables son los siguientes:

· Enteros o decimales, 123762, 3.141516.

· Números hexadecimales, 0x0, 0x12a, 0xa, 0xb524, empezando por un cero, seguido de una ‘x’ mayúscula o minúscula, seguido de cualquier combinación de digitos y de letras entre a y f.

· Números octales, 123o, 423o, 76O, 624o, empezando por cualquier dígito entre 0 y 7, seguido de la letra ‘o’.

· Números binarios, 0101001b, 0001b, 0b, 1b, cualquier combinación entre 1 y 0’s seguido de una letra ‘b’.

Ejemplos de uso:

a = ((0x2 ^ 100b) – 3.141516) + 5o;

printn(a);

.

Constantes numéricas

Yare cuenta actualmente con 9 constantes numéricas, son las siguientes:

· pi – número pi

· e – valor de e

· log2e – valor de log2e

· log10e – valor de log10e

· ln2 – valor de loge2

· ln10 – valor de loge10

· sqrt2 – valor de pi entre 2.

· sqrt3 – valor de pi entre 3.

· sqrt5 – valor de pi entre 5.

Ejemplo de uso:

printn(const.pi); .
printn(const.pi + 2 * 11b); .

Otras constantes pueden ser fácilmente añadidas.

Asignación de variables

La asignación de valores a las variables es bastante flexible.

Puede realizarse de las siguientes maneras:

Utilizando el operador =:

a = 1 + 2;

.

Utilizando el operador to:

a = 1; a to a + 1; printn(a); .

Utilizando la sentencia move y to:

move 1 + 2 * 3 to a; printn(a); .

Utilizando la sintaxis tipo assembly:

mov a, 1 + 2 * 3; printn(a); .

Utilizando la sintaxís <-:

a <- 1 + 2 * 3; printn(a); .

Utilizando asignaciones tipo pascal:

a := 1 + 2 * 3; printn(a); .

Utilizando let o set con =:

set x = 1 + 2 * 3; printn(x); .
let x = 1 + 2 * 3; printn(x); .

Utilizando let o set con to:

set x to 1 + 2 * 3; printn(x); .
let x to 1 + 2 * 3; printn(x); .

Esta sintaxis aplica también a variables definidas por el usuario.

Asignación aleatoria

Se puede dar un valor aleatorio a una variable de la siguiente manera:

x = ?; printn(x); .

Asignación con smileys

Se puede asignar/inicializar una variable a 1, 0 o -1 de la siguiente manera:

Ejemplo de uso:

a = :); z = :(; y = :|; printn(a); printn(z); printn(y);

.

Intercambio de valores de variables

Se puede intercambiar los valores de las variables por medio del operador <->:

Ejemplo de uso:

x = 2; :ok: = 3; x<->:ok:; printn(x); printn(:ok:); .

Imprimir en pantalla

Se puede utilizar la sentencia print o printn.

La sentencia print imprime el valor de la expresión pasado como argumento sin añadir un fin de línea.

La sentencia printn añade un fin de línea al argumento.

Ejemplo de uso:

print(const.pi + 2); .
printn(const.pi + 2); .

Se pueden imprimir también en pantalla cadenas de texto con la sentencia puts y putsn.

La sentencia puts imprime el texto en pantalla pero sin añadir un fín de línea.

La sentencia putsn añade un fín de línea al final del texto.

Ejemplos de uso:

puts(“Hola mundo en Yare!”); .
putsn(“Hola mundo en Yare!”); .

Caracteres de escape

Se pueden incluir cualquiera de estos caracteres en el texto a imprimir:

· \n – Nueva línea

· \t – Tab horizontal

· \s – Espacio

· \b – Backspace (retroceso)

· \r – Retorno de carro

· \f – Alimentación de página (sólo para impresora)

· \q – Añade un caracter de comillas dobles ‘

· \\ – Añade el caracter ‘\

· \u – Imprime el siguiente caracter en mayúscula

· \l – Imprime el siguiente caracter en minúscula.

· \[0-9] – Imprime la cantidad de fin de líneas especificado en el dígito.

Ejemplos de uso:

putsn(“\tHola\smundo\5”); .

Sentencia system

La sentencia system se puede utilizar para mandar un comando a el sistema operativo.

Ejemplo de uso:

system(“touch file_created_by_yare.txt”); .

Sentencia exit

La sentencia exit se puede utilizar para salir inmediatamente del programa pasando una expresión a la sentencia. Esto significa que ese valor de expresión será envíado al sistema operativo.

Ejemplo de uso:

x = 11b; exit(x); .

clip_image002

Sentencias de control

Sentencia IF

Toma una decisión referente a una acción, se ejecuta un bloque si es verdadero (1).

Se puede escribir if(expresión) o si(expresion).

Ejemplo de uso:

if(const.pi * 2 <= 10) { putsn(“Ok”); } .

Usando else.

if(const.pi * 2 <= 10) { putsn(“Ok”); } else {putsn(“Nel … “);}.

Usando else-if:

x = 2; if(x == 0) { putsn(“cero…”); } else if(x == 1) { putsn(“uno …”); } else if(x == 2) {

putsn(“dos … “);

} else {

putsn(“otro … “);

}

.

Operadores lógicos y relacionales

|| – OR

&& – AND

>= – Mayor igual

<= – Menor igual

== – Igual

!= – Distinto

“or” – OR

“and” – AND

-eq – Igual

-neq – Distinto/Diferente a

-lt – Menor que

-gt – Mayor que

“menor” – Menor que

“menorigual” – Menor igual

“mayor” – Mayor que

“mayorigual” – Mayor o igual

“igual” – Igual

|, or a nivel de bits

&, and a nivel de bits

Ejemplos de uso:

x = 2; if(x igual 2) { putsn(“ok”); } .
x = 2; y = x -eq 2; printn(y); .
x = 2; if((x -eq 1) or (x == 2)) { putsn(“Ok … “); } else { putsn(“Nel … “); }

.

x = 6; if(x menor 10) { putsn(“bien … “); } .

Operador ternario

Yare cuenta con el clásico operador ternario utilizado para expresiones de la siguiente manera:

expresión-lógica ? valor-si-verdadero : valor-si-falso

Ejemplos de uso:

x = 2; x = (x mod 2 == 0) ? 0 : 1; printn(x); .

Se asigna el valor de 1 a x.

Operadores aritméticos

+
“mas” Operador de suma con palabra
“menos” Operador de resta con palabra
*
“por” Operador de multiplicación con palabra
/
“entre” Operador de división con palabra
%
mod Operador módulo con palabra
! Operador unario “not”
~ Operador unario “not”
not Operador unario “not”
no Operador unario “not”
^ Exponenciación
xorop Operador XOR
<< Desplazamiento de bits a la izquierda
>> Desplazamiento de bits a la derecha

Ciclos

while

Ejemplo de uso:

while(x menor 10) { printn(x); x to x + 1; } .
while(x@+ menor 10) printn(x); .

Las llaves de bloques se utilizan cuando queremos agrupar las sentencias al ciclo, pero si solo es una sentencia dentro del ciclo se pueden omitir las llaves de bloque.

do-while

Ejemplo de uso:

do { printn(x); set x to x + 1; } while(x menor 10); .

for de rango

La sintaxis del ciclo for de rango es la siguiente:

for(expresion …[.+] expresion, variable global de control) { bloque de código}

Ejemplo de uso:

foreach(1 …… 20, x) { printn(x); } .
foreach(1 …. rand(), x) { printn(x); } .

La variable global, en este caso x almacenará el valor de la iteración dentro del ciclo.

Se pueden utilizar la cantidad de puntos que se desee, siempre y cuando sean más de 3.

Sentencia break

Al igual que otros lenguajes de programación, yare tiene una sentencia break que ayudará a detener el ciclo.

Ejemplo de uso:

foreach(1 … rand(), x) { if(x igual 5) {     break; } else { printn(x); }

}

.

Pueden tenerse ciclos anidados. El siguiente programa genera un triangulo hecho con asteriscos utilizado un ciclo anidado.

foreach(1 … 10, x) { foreach(1 … x, y) { puts(“*”); } puts(“\n”); }

.

El resultado es el siguiente:

clip_image004

Comentarios

Hay diversas maneras de utilizar comentarios dentro de un programa yare, son los siguientes:

# Comentario tipo shell

La sintaxis del comentario anterior sirve para comentarios de una sola línea.

Ejemplo de uso:

x = 1 + 2; # Comentario …. .
// Comentario tipo C++

La sintaxis del comentario anterior sirve para comentarios de una sola línea.

Ejemplo de uso:

x = 1 + 2; // Comentario …. .
rem Comentario tipo Basic

La sintaxis del comentario anterior sirve para comentarios de una sola línea.

Ejemplo de uso:

x = 1 + 2; rem Comentario …. rem … Otro comentario ….
:: Comentario tipo Batch Scripts

La sintaxis del comentario anterior sirve para comentarios de una sola línea.

Ejemplo de uso:

x = 1 + 2; :: Mi comentario … ::: Hola! .
— Comentario tipo SQL

La sintaxis del comentario anterior sirve para comentarios de una sola línea.

Ejemplo de uso:

x = 1 + 2; — Hola mundo!!!! — Hola mundo 🙂 .
/* Comentario tipo C */

La sintaxis del comentario anterior sirve para comentarios de varias líneas (multilínea).

Ejemplo de uso:

x = 1 /* Hola */ + 2; /* Comentario de varias lineas */

printn(x);

.

Sentencias tipo assembly

mov

Se utiliza para asignar un valor a una variable global o variable definida por el usuario.

Ejemplo de uso:

while(x -lt 10) { mov x, x + 1; printn(x); } .

Se asigna el valor que esté del lado derecho de la coma a la variable que esté del lado izquierdo.

add

Se utiliza para sumar un valor a una variable o variable definida por el usuario.

Ejemplo de uso:

while(x -lt 10) { add x, 1; printn(x); } .

En este ejemplo, se le suma 1 al valor que ya tiene la variable.

sub

Se utiliza para restar un valor a una variable o variable definida por el usuario.

Ejemplo de uso:

x to 10; while(x -gt 0) { sub x, 1; printn(x); } .

En este ejemplo, se le resta 1 al valor que ya tiene la variable.

mul

Se utiliza para multiplicar el valor de una variable por la expresión dada y almacenar el resultado en la variable.

Ejemplo de uso:

:factorial: = 5; r = 1; foreach(1 …. :factorial:, i) { mul r, i; } puts(“Resultado: “);

printn(r);

.

El ejemplo anterior calcula el factorial de 5 (contenido de la variable :factorial:).

La pila virtual de Yare

Yare cuenta con una pila virtual la cual puede ser utilizada para almacenar valores y recuperarlos después.

Existen las sentencias push y pop, para almacenar y recuperar valores respectivamente y stacksize para consultar la cantidad de elementos en la pila.

La cantidad de valores en la pila es indefinida, se puede usar de manera libre.

Ejemplos de uso:

:factorial: = 5; r = 1; foreach(1 …. :factorial:, i) { mul r, i; push r; }

puts(“Resultado: “);

printn(r);

puts(“Se siguió este camino para obtener el factorial de 5: \n”);

while(stacksize -gt 1) {

printn(pop);

}

.

Se almacenan los valores de la variable r en la pila para luego consultar uno por uno con pop.

Funciones del lenguaje

rand

Devuelve un valor aleatorio entre 0 y 100 (incluyéndolos).

Ejemplos de uso:

:factorial: = 5; printn(rand()); .

Range random

Esta expresión devuelve un número aleatorio entre el rango indicado.

Ejemplos de uso:

printn(1 …? 10); .
foreach(1 … 5 ….? 10, x) { printn(x); } .

Funciones matemáticas

Las siguientes funciones relacionadas con cálculos matemáticos están disponibles.

abs(expresion)
sqrt(expresion)
acos(expresion)
asin(expresion)
atan(expresion)
ceil(expresion)
cos(expresion)
cosh( expresion)
exp(expresion)
floor(expresion)
ln(expresion)
sin(expresion)
sinh(expresion)
tan(expresion)
tanh(expresion)
sumatoria(expresion, expresion) Reliza la sumatoria desde el primer argumento hasta el segundo argumento.
factorial(expresion) Regresa el factorial del argumento.

Opvar (Operador Variable)

El opvar es una variable especial en la cual se puede almacenar un operador aritmético, se puede almacenar dentro del opvar un +, , *, /, ^.

Ejemplos de uso:

_@_ = +;x = 1 _@_ 2 * 3;if(8 igual (x _@_ 1)) {putsn(“Ok … “);} else {putsn(“Falso … “);

}

En este caso almacenamos en el opvar el operador +, para luego ser utilizado.

Arrays Lists

Yare cuenta con arrays que pueden utilizarse como listas, es decir, los arrays no tienen longitud.

La manera de declarar un array es la siguiente:

array(@ARRAY_ID);

Los identificadores para los arrays empiezan por el caracter @ seguido de cualquier combinación de estos símbolos:

·Una letra minúscula o mayúscula.

·Un dígito

·“

·’

·Tabulador

·Espacio

·#

Los identificadores de arrays pueden tener una longitud de hasta 99 caracteres.

Operaciones con arrays

Agregar un elemento (put)

array(@my_array);@my_array.put(1 + 2 * 3);printn(@my_array[0]);.

Se agrega un elemento al array y se obtiene el contenido del array en la posición 0 utilizando los corchetes para indexar el array.

Se puede consultar la cantidad de elementos del array con la sentencia size de la siguiente manera:

array(@my_array);@my_array.put(1 + 2 * 3);@my_array.put(2);@my_array.put(3);puts(“Elementos del array: “);printn(@my_array.size());

.

Puedes modificar un elemento en una determinada posición de la siguiente manera:

array(@my_array);@my_array.put(1 + 2 * 3);@my_array.put(2);@my_array.put(3);@my_array[0] = 3.141518;printn(@my_array[0]);

.

De nuevo utilizamos los corchetes para acceder al elemento en la posición indicada.

Al utilizar la sentencia put para añadir un elemento al array, el elemento se agrega al final de todos los elementos, si se desea agregar al inicio se puede utilizar la función putfront:

array(@my_array);@my_array.putfront(1);@my_array.putfront(2);@my_array.putfront(3);printn(@my_array[0]);.

Ordenación del arreglo

Se pueden ordenar los elementos del array utilizando la función sort, sort necesita de un argumento, si este argumento es 0 se ordenan los elementos de menor a mayor, si este es distinto a 0 entonces se ordenan de mayor a menor.

array(@my_array);@my_array.put(5);@my_array.put(8);@my_array.put(3);@my_array.put(10);@my_array.put(7);

set x to 0;

@my_array.sort(no 0);

while(x menor @my_array.size()) {

printn(@my_array[x]);

x += 1;

}

.

Eliminación de elementos del array por índice

Se puede eliminar un elemento del array basado en su índice utilizando la función del:

array(@my_array);@my_array.put(1);@my_array.put(2);@my_array.put(3);@my_array.put(4);@my_array.put(5);

printn(@my_array[2]);

@my_array.del(2);

printn(@my_array[2]);

.

Llenar el array con números aleatorios entre 0 y 1 utilizando la función fill

La función fill necesita de un argumento, que significa la cantidad de elementos entre 0 y 1 que se añadirán al array.

Ejemplo de uso:

array(@my_array);@my_array.fill(2);printn(@my_array[0]);printn(@my_array[1]);.

Eliminar todos los elementos del array

La función clear nos permite eliminar todos los elementos del array.

array(@my_array);@my_array.fill(2);@my_array.clear();.

Invertir los elementos de un array

Con la función reverse podemos invertir el orden de los elementos.

Ejemplo de uso:

array(@my_array);@my_array.fill(3);while(x menor @my_array.size()) printn(@my_array[x@+]);@my_array.reverse();x to 0;puts(“\1Orden invertido: \2”);

while(x menor @my_array.size()) printn(@my_array[x@+]);

.

Salida:

clip_image006

Incrementar y decrementar valores de variables

En Yare solo existen el preincremento y predecremento realizado por las funciones inc y dec.

Ambas funciones necesitan de una variable global o de una variable definida por el usuario.

Ejemplo de uso:

printn(inc(x));printn(x);.
printn(dec(x));printn(x);.

El mismo resultado se consigue utilizando el operador @+ o @-.

Ejemplo de uso:

x to 0;while(x@+ menor 10) {printn(x);}.
x to 10;while(x@- mayor 0) {printn(x);}.

Procedimientos

Se pueden crear procedimientos, estos pueden ser llamados en cualquier momento por la sentencia call.

Para definir un procedimiento basta con utilizar la palabra reservada proc, seguido del identificador para el procedimiento.

proc $CUALQUIER SIMBOLO$ {CUERPO DEL PROCEDIMIENTO}

Ejemplo de uso:

proc $parX$ {if(x % 2 == 0) {y = 1;} else {y = 0;}

}

El procedimiento anterior comprueba si el valor en ‘x’ es par o impar, si es par entonces modifica el valor de la variable global y a 1, sino deja el valor de la variable y a 0.

Para invocar el procedimiento se utiliza la sentencia call de la siguiente manera:

call $NOMBRE PROCEDIMIENTO$;

Ejemplo de uso:

x = 2;call $parX$;printn(y);

No pueden haber procedimientos dentro de otros procedimientos.

Yare soporta recursión, el siguiente ejemplo ilustra el algoritmo para calcular un factorial de manera recursiva:

# El resultado del factorial es almacenado en la variable global rproc $factorial$ {if(a mayor 1) {r *= a;a@-;call $factorial$;

}

}

r = 1;

a = 5;

call $factorial$;

puts(“Factorial de 5!: “);

printn(r);

.

Pendientes

· Planeo implementar la característica de números gigantes (algo como los BigInteger de Java) utilizando la librería GMP de GNU.

  • · Trabajo con archivos.
  • · Trabajo con cadenas y caracteres.
  • · Crear una página man page mejor documentación.
  • · Documentación para desarrolladores.
  • · Orden del código.
  • · Reducción de código innecesario.
  • Mejora en los avisos de error.

Saludos

Publicado en Programación | 3 comentarios