jueves, 13 de mayo de 2010

Ciclos y Gráficos usando Matlab

En este artículo saldremos un poco de la estructura del blog para referirnos a una herramienta muy utilizada para el procesamiento de imágenes y el cálculo y manipulación de datos matriciales.  Lo interesante es que permite comunicarse con otros lenguajes (como C#, Java, etc) a través de funciones de librería específicas que facilitan el trabajo

El tipo de datos fundamental en Matlab (y en Octave) es la matriz y existen muchísimas funciones que manipulan este tipo de dato. Pero hoy nos vamos a ocupar de algo menos común y más algorítmico: como realizar ciclos en Matlab/Octave y como aprovecharlos para realizar gráficos de diferentes funciones.

Algunos conceptos previos:
Operador ‘:’
Se trata de una de las formas de definir vectores y matrices más usada y más fácil de utilizar, dada la rápida visualización de la salida sin necesidad de ver el resultado:

octave> x=1:1:10;
octave> x

x =
1 2 3 4 5 6 7 8 9 10

De alguna manera, el : representa un rango, en este caso desde 1 hasta 10 y en el centro se coloca el paso (o sea con que incremento se llega desde 1 hasta 10). Por defecto el paso es 1 pero puede ser cualquier número entero o real, positivo o negativo:


octave> x=10:-1:1
x =
10 9 8 7 6 5 4 3 2 1


Gráficos
plot() crea un gráfico a partir de vectores y/o columnas de matrices, con escalas lineales sobre ambos ejes.
Por ejemplo, vamos a hacer un gráfico de la función 0.1 * |x| * sin(x)
Graficaremos usando valores para x entre -2pi y 2pi

  • Generamos el vector x entre -2p y 2pi

octave> x = -2*pi:0.1:2*pi;

  • Dibujamos:

octave> plot(x, abs(0.1*x) .* sin(x));


.* Recordar que * es el producto de matrices. No funcionará con vectores, mientras que .* es el producto miembro a miembro de los elementos de cada vector

fig1

Generalicemos nuestra función: a * |x| * sin(x) y graficamos dando 3 diferentes valores a la variable a. Por ejemplo:


octave> plot(x, abs(0.1*x) .* sin(x));
octave> plot(x, abs(0.2*x) .* sin(x));
octave> plot(x, abs(0.3*x) .* sin(x));

¿Cómo hacemos si queremos ver los tres gráficos en una misma pantalla?


octave> hold on;

hold es una función que permite agregar gráficos a una figura ya existente, respetando su contenido

Otras funciones útiles:

  • grid: Muestra una cuadrícula en la pantalla del gráfico. Usando grid  on se activa y con off se desactiva
  • title(‘titulo’): Coloca un título al gráfico
  • xlabel(‘leyeda x’): Coloca una leyenda al eje x
  • ylabel(‘leyeda y’): Coloca una leyenda al eje y


Por defecto, el color de las líneas del gráfico es rojo, pero eso se puede cambiar, así como también el estilo de las líneas. En las siguientes tablas se muestran las posibilidades de colores y estilos de líneas:

Símbolo

Color

y

Amarillo

m

Magenta

c

Celeste

r

Rojo

g

Verde

b

Azul

w

Blanco

k

Negro (por defecto)

Símbolo

Tipo de línea

.

Puntos

o

Con círculos

x

Marcas en x

+

Marcas en +

*

Marcas en *

s

Marcas cuadradas

d

Marcas en diamante

^

Triangulo apuntando arriba

Dibujemos, finalmente las 3 funciones en la misma hoja gráfica:

octave> hold on;

octave> plot(x, abs(0.1*x) .* sin(x));
octave> plot(x, abs(0.2*x) .* sin(x),’r+’);
octave> plot(x, abs(0.3*x) .* sin(x),’mo’);

 

fig2

En la siguiente entrega, nos ocuparemos de los ciclos y tendremos más ejemplos.

jueves, 29 de abril de 2010

Novedades en C# 4.0

El lenguaje de programación C# sigue evolucionando junto con el framework .Net. A la par del lanzamiento de la nueva versión de .NET  del VisualStudio 2010 surge la nueva versión de C# la 4.0.

El lenguaje sigue evolucionando con nuevas características, en este artículo mencionaremos algunas de ellas.

Se introduce una nueva palabra clave dynamic, utilizada para definir tipos dinámicos. Los tipos dinámicos son utilizados cuando, por ejemplo, se quiere acceder a código creado con un lenguaje dinámico como Iron-Python . Esta palabra clave le dice al compilador que el tipo de  los objetos se definirá en tiempo de ejecución y puede de esa manera responder a invocaciones dinámicas de métodos.

El siguiente código nos muestra un ejemplo:

dynamic miObjeto = ObtenerObjetoDePython();
miObjeto.Propiedad = “dato”
miObjeto.MetodoDinamico();

En tiempo de ejecución se definirá el tipo de “miObjeto” y el ambiente de run-time descubre las propiedades y genera el enlace dinámico al código correspondiente. El peligro, como con todo lenguaje sin tipificación fuerte, es que el método invocado no este definido en cuyo caso se produce una excepción en tiempo de ejecución. El uso que debería descartarse por completo para este tipo de declaración es usar una misma variable para diferentes tipos de objetos. Eso si que es feo.

Otra de las novedades son los parametros con nombre y variables en métodos. Es posible darle nombre a los parámetros y hacerlos opcionales. Por ejemplo:

public void unMetodo(int par1, String par2="valordefecto", decimal par2=99.85){

//Hacer algo

}

En la declaración precedente hay dos parámetros con nombre y además con valores pode defecto. Esto permite transformarlos en opcionales.

Si tenemos un objeto digamos objetoA que sea de la misma clase que unMetodo, podemos realizar las invocaciones de la siguiente forma

 

objetoA.unMetodo(4,”unvalor”,19.98);

objetoA.unMetodo(4,”unvalor”);

objetoA.unMetodo(4,par2:19.98);

En el último caso se nombra explícitamente el parámetro ya que en esa posición el método tiene declarado un parámetro de tipo string. Es decir los parámetros con valores por defecto son opcionales en la invocación pero si hay diferencia de orden o se saltea alguno deben nombrarse explícitamente para evitar errores de compilación.

Otra novedad es la covarianza de estructuras genéricas pero eso daría para un artículo entero.

lunes, 19 de abril de 2010

Object-Test y tipos asignados: Void.Safety en Eiffel

En un artículo anterior describimos el mecanismo de CAP utilizado para conseguir sistemas void-safety en Eiffel. Ahora describiremos las otras herramientas tipos asignados y la instrucción object test
Object test provee un mecanismo de identificación de tipos en tiempo de ejecución (reemplaza también a la construcción anterior de Eiffel llamada intento de asignación). Básicamente verifica que una referencia tenga asignado un objeto de un tipo determinado.  La sintaxis es la siguiente:

if  attached {T} exp as l then
 -- Operaciones sobre l
end

La expression attached {T} exp as l   es una expression logica (booleana) que es verdadera cuando exp es una referencia que tiene asignado un objeto conformante con el tipo T.   La nueva variable l con alcance en el if pasa a tener asignado el objeto denotado por exp.          
Entonces es seguro la siguiente secuencia:

if attached x as l then
   l.f (a)
end

Dado que f(a) se invoca sobre l y sólo cuando este tiene un asignado un objeto (el mismo que referencia x en el momento del test). En el ejemplo último, el tipo T es implícitamente el tipo estático de x. El uso de l es obligatorio para void-safety porque evita problemas en caso de que en un ambiente multihilo sea modificado el valor de exp.

El otro mecanismo que queda por ver el de tipos asignados. Este mecanismo es una extensión del sistema de tipo de Eiffel. Previamente cualquier variable de un tipo de referencia podía tener asignado void. Así todas las variables eran consideradas desasignables (detachables). Ahora el standard de Eiffel soporta tipos asignados (attached) o desasignables (detachables). Si una variable es declarada como attached entonces el compilador previene que dicha variable puede asignársele Void o asignarse alguna cosa que pueda ser void.

Ejemplos:
x: attached STRING

y: detachable STRING

En el primer caso la x siempre tendrá un objeto asignado y nunca podrá darse un error de null reference, mientras en el segundo caso a la y se le puede asignar Void y la garantía de void-safety debe proporcionarse por los otros medios mencionados.
Para garantizar este mecanismo hay reglas que el compilador debe asegurar. Por ejemplo es posible asignar x a y pero no y a x.
Es necesario utilizar un mecanismo de inicialización que prevenga que una variable de un tipo attached no sea asignada. Para casos como enteros o valores lógicos Eiffel ya proveía un mecanismo de inicialización (por ejemplo los enteros son inicializados en cero) Los tipos de referencia (detachables) son asignados con Void, pero esto no sirve para los tipos de referencia attached. Para resolver el problema se utiliza el concepto de variable propiamente iniciada (properly set) que significa que a la variable le fue dado un valor distinto de Void . Se usa la siguiente regla:

Regla de inicialización de tipos asignados:
Si un programa usa una variable en cierta posición una de las siguientes propiedades debe cumplirse:

  •  La variable es propiamente asignada en esa posición. Esto se aplica a ambos tipos de variables: atributos y variables locales de una rutina.
  • La variable es un atributo y es propiamente inicializada al final de todo procedimiento de creación de la clase.

De esta manera completamos una visión general de los mecanismos de Eiffel para lograr evitar el problema de la null-reference. Cabe indicar que el compilador o el entorno de desarrollo traen facilidades para ir incorporando estos mecanismos. Por ejemplo es posible configurar que todos los tipos sean attached o detachable por defecto.

martes, 13 de abril de 2010

Nuevo sitio de Inteligencia Artificial


La Inteligencia Artificial es una rama de las ciencias de la computación que tiene objetivos científicos e ingenieriles. Por un lado comprender el funcionamiento del cerebro humano y la inteligencia, estudiar mecanismos de comportamiento inteligente y por otro construir software que pueda exhibir comportamiento inteligente. Las aplicaciones de la Inteligencia Artificial y sus subcampos van desde robótica, reconocimiento de imagenes hasta control inteligente de dispositivos.
Un nuevo sitio dedicado al tema y en donde es posible consultar un libro en línea (e-book) fue desarrollado por Uppersoft para que los interesados en el tema puedan introducirse.
Pueden acceder a el en el siguiente enlace http://www.smartcomputing.com.ar Ya están los primeros capítulos del libro Fundamentos de Inteligencia Computacional (escrito por Gerardo Rossel) en línea.