miércoles, 6 de junio de 2012

Cómputo en paralelo - Uso de hilos de ejecución.


En sistemas operativos, un hilo de ejecución, hebra o subproceso es la unidad de procesamiento más pequeña que puede ser planificada por un sistema operativo.
La creación de un nuevo hilo es una característica que permite a una aplicación realizar varias tareas a la vez (concurrentemente). Los distintos hilos de ejecución comparten una serie de recursos tales como el espacio de memoria, los archivos abiertos, situación de autenticación, etc. Esta técnica permite simplificar el diseño de una aplicación que debe llevar a cabo distintas funciones simultáneamente.
Un hilo es básicamente una tarea que puede ser ejecutada en paralelo con otra tarea. Los hilos de ejecución que comparten los mismos recursos, sumados a estos recursos, son en conjunto conocidos como un proceso.
El proceso sigue en ejecución mientras al menos uno de sus hilos de ejecución siga activo. Cuando el proceso finaliza, todos sus hilos de ejecución también han terminado. Asimismo en el momento en el que todos los hilos de ejecución finalizan, el proceso no existe más y todos sus recursos son liberados.
Un ejemplo de la utilización de hilos es tener un hilo atento a la interfaz gráfica (iconos, botones, ventanas), mientras otro hilo hace una larga operación internamente. De esta manera el programa responde de manera más ágil a la interacción con el usuario. También pueden ser utilizados por una aplicación servidora para dar servicio a múltiples clientes.

http://mundogeek.net/archivos/2008/04/18/threads-en-python/

Tarea- Implementación del cómputo paralelo en método de ordenamiento por mezcla.





martes, 22 de mayo de 2012

Octave


GNU Octave es un lenguaje de alto nivel destinado para el cálculo numérico. Como indica su nombre es parte de proyecto GNU. MATLAB es considerado su equivalente comercial. Provee una interfaz sencilla, orientada a la línea de comandos (consola), que permite la resolución de problemas numéricos, lineales y no lineales, además permite la ejecución de scripts y puede ser usado como lenguaje orientado al procesamiento por lotes.

Octave nació alrededor del año 1988, y fue concebido originalmente para ser usado en un curso de diseño de reactores químicos para los alumnos de Ingeniería Química de la Universidad de Texas y la Universidad de Wisconsin-Madison. Posteriormente en el año 1992, se decide extenderlo y comienza su desarrollo a cargo de John W. Eaton.1 La primera versión alpha fue lanzada el 4 de enero de 1993. Un año más tarde, el 17 de febrero de 1994 aparece la versión 1.0.

Octave posee una gran cantidad de herramientas que permiten resolver problemas de algebra lineal, cálculo de raíces de ecuaciones no lineales, integración de funciones ordinarias, manipulación de polinomios, integración de ecuaciones diferenciales ordinarias y ecuaciones diferenciales algebraicas. Sus funciones también se pueden extender mediante funciones definidas por el usuario escritas en el lenguaje propio de Octave o usando módulos dinámicamente cargados escritos en lenguajes como C, C++ y Fortran entre otros


Referencias

Autómatas celulares con Octave

Un Autómata celular es un sistema dinámico discreto adecuado para modelar sistemas reales que pueden describirse como una colección de objetos que interactúan localmente unos con otros. Se compone de una lattice cuyos elementos son conocidos como células (por lo que el espacio en un AC es discreto), un conjunto de estados para los valores que las células pueden tomar, conjuntos de vecindades entre cada célula de la lattice y células en su cercanía y una función local para asignarle un estado a cada célula conforme avanza el tiempo de manera discreta.

Célula. Elemento básico de un AC. La lattice que conforma al AC está compuesto por elementos conocidos como ‘células’.

Condición de frontera. Situación particular que se implementa en lattices finitas para considerar el comportamiento de las células cuyos elementos se encuentren en las fronteras de las mismas.

Configuración de un AC. Dadas las células de un AC en un tiempo t, la configuración es el conjunto de valores de dichas células en ese tiempo.

Conjunto de estados. Conjunto de elementos que dan valor a las células de una lattice.

Función global. Función que toma una configuración del AC en el tiempo t y, aplicando la función local, devuelve la configuración del AC en el tiempo t + 1.

Función local o Función de transición. Función que, por cada célula de un AC, toma los valores de los elementos en la vecindad de dicha célula para el tiempo t y devuelve el valor de esa célula en el tiempo t + 1. 




Referencias en Autómatas Celulares:


Autómata celular para un tejdo excitable en célula Purkinje con dominio toroidal

Conceptos:

Las células de Purkinje (o neuronas de Purkinje) son un tipo de neurona localizada en la corteza cerebelosa. Su nombre proviene de su descubridor, el de Purkinje, una capa de la corteza en el cerebelo situada entre la capa molecular y la capa granulosa. Las células de Purkinje envían proyecciones inhibidoras hacia el núcleo cerebelar profundo, y constituyen la única salida de toda la coordinación motriz en la corteza cerebelar. la celula de purkinje es una neurona de gran tamaño


En geometría el toroide es la superficie de revolución generada por una curva plana cerrada que gira alrededor de una recta exterior coplanaria (el eje de rotación situado en su mismo plano) con la que no se interseca. Su forma se corresponde con la superficie de los objetos que en el habla cotidiana se denominan donuts,argollas, anillos, aros o roscas. Cuando la curva cerrada es una circunferencia, la superficie se denomina toro.




% =========================================================================
% TEJIDO EXCITABLE EN DOMINIO TOROIDAL, CON CAPACIDAD DE PROPAGACION 
% ANISOTROPICA. 
% =========================================================================

clear all; close all;
% --------------------------------------------------DIMENSIONES DE LA TRAMA
N=40;  %-----------------------------------------------numero de renglones
M=40;  %------------------------------------------------numero de columnas 


iteraciones = 10000; %-------------------numero de ciclos para la simulacion

% ----------------------------------------------COORDENADAS DE ESTIMULACION
% en el centro
%      xESTIMULO=round(N/2);
%      yESTIMULO=round(M/2);
% al azar
        xESTIMULO=ceil(rand()*N); 
        yESTIMULO=ceil(rand()*M);


% -------------------------------------------------------------------------
%                       INICIALIZACIONES
% -------------------------------------------------------------------------

Enuevo = zeros(N,M)-90; %---------------todas las celulas en reposo (-90 V)
Eactual=zeros(N,M)-90;
RF = zeros(N,M);        % ----------arreglo de caracteristicas refractarias
CT = zeros(N,M);        % -------------arreglo con estimulaciones tempranas
CC = zeros(N,M);        % ---arreglo con influencia de celulas vecinas (VN)
g = 1;                %---------valor de referencia para la conductividad (Velocidad de propagación)

gSN = g*ones(N,M);       %--------------------------------conductividad S-N
gOE = g*ones(N,M);       %--------------------------------conductividad O-E
gNS = g*ones(N,M);       %--------------------------------conductividad N-S
gEO = g*ones(N,M);       %--------------------------------conductividad E-O

% =========================================================================
% INICIALIZACION DE LOS ESTADOS:
% =========================================================================

fase = 4*ones(N,M);     %---------todas las celulas inicializadas en reposo

% Para inicializacion desfasada: descomentar el siguiente bloque

%for i=1:N
% for j=1:M
%    num = floor(4*rand);
%    switch num
%      case 0, fase(i,j)=0; Eactual(i,j)=floor(rand*120-90);
%      case 1, fase(i,j)=1; Eactual(i,j)=floor(rand*20+10);
%      case 2, fase(i,j)=2; Eactual(i,j)=floor(rand*80-70);
%      case 3, fase(i,j)=4; Eactual(i,j)=floor(rand*20-90);
%    end
% end
%end     

% =========================================================================
% DESCOMENTAR PARA PROPAGACION ANISOTROPICA Y BLOQUEO
% -------------------------------------------------------------------------
%   xESTIMULO=round(N/4);
%   yESTIMULO=round(M/10);
%   gSN(1:round(N/2),round(M/3)) = zeros(round(N/2),1);
%   gOE(6:round(N/2)+5,round(M/3)) = zeros(round(N/2),1);
  
%   gNS(1:round(N/2),round(M/3)) = 5*g*ones(round(N/2),1);
%   gEO(1:round(N/2),round(M/3)) = 5*g*ones(round(N/2),1);
% -------------------------------------------------------------------------


% =========================================================================
% A PARTIR DE AQUI NO TOCAR!!!!!!!!!!!
% -------------------------------------------------------Excitacion inicial
estimulo = zeros(N,M);
estimulo(xESTIMULO,yESTIMULO) = 100;

figure 



% -------------------------------------------------------------------------
%                       CICLO PRINCIPAL
% -------------------------------------------------------------------------

for t = 1:iteraciones,

% -------------------------------------------------------------------------
%               CALCULO DE LAS INFLUENCIAS LOCALES (DOMINIO TOROIDAL)
% -------------------------------------------------------------------------
    for i=1:N,   
        for j=1:M,
           % -------------------------------------Esquinas de la rep. plana
           if (i==1) & (j==1),
              CC(i,j)=gSN(N,j)*(Eactual(N,j)-Eactual(i,j))+...
                               gOE(i,M)*(Eactual(i,M)-Eactual(i,j))+...
                               gNS(i+1,j)*(Eactual(i+1,j)-Eactual(i,j))+...
                               gEO(i,j+1)*(Eactual(i,j+1)-Eactual(i,j));
           elseif (i==1) & (j==M),
              CC(i,j)=gSN(N,j)*(Eactual(N,j)-Eactual(i,j))+...
                               gOE(i,j-1)*(Eactual(i,j-1)-Eactual(i,j))+...
                               gNS(i+1,j)*(Eactual(i+1,j)-Eactual(i,j))+...
                               gEO(i,1)*(Eactual(i,1)-Eactual(i,j));
           elseif (i==N) & (j==1),
              CC(i,j)=gSN(i-1,j)*(Eactual(i-1,j)-Eactual(i,j))+...
                               gOE(i,M)*(Eactual(i,M)-Eactual(i,j))+...
                               gNS(1,j)*(Eactual(1,j)-Eactual(i,j))+...
                               gEO(i,j+1)*(Eactual(i,j+1)-Eactual(i,j));
           elseif (i==N) & (j==M),
              CC(i,j)=gSN(i-1,j)*(Eactual(i-1,j)-Eactual(i,j))+...
                               gOE(i,j-1)*(Eactual(i,j-1)-Eactual(i,j))+...
                               gNS(1,j)*(Eactual(1,j)-Eactual(i,j))+...
                               gEO(i,1)*(Eactual(i,1)-Eactual(i,j));
           elseif (i==1)|(j==1)|(i==N)|(j==M),
               
           % ---------------------------------------Bordes de la rep. plana
              if i==1,
                 CC(i,j)=gSN(N,j)*(Eactual(N,j)-Eactual(i,j))+...
                               gOE(i,j-1)*(Eactual(i,j-1)-Eactual(i,j))+...
                               gNS(i+1,j)*(Eactual(i+1,j)-Eactual(i,j))+...
                               gEO(i,j+1)*(Eactual(i,j+1)-Eactual(i,j));
              end,   
              if j==1,
                 CC(i,j)=gSN(i-1,j)*(Eactual(i-1,j)-Eactual(i,j))+...
                               gOE(i,M)*(Eactual(i,M)-Eactual(i,j))+...
                               gNS(i+1,j)*(Eactual(i+1,j)-Eactual(i,j))+...
                               gEO(i,j+1)*(Eactual(i,j+1)-Eactual(i,j));
              end,   
              if i==N,
                 CC(i,j)=gSN(i-1,j)*(Eactual(i-1,j)-Eactual(i,j))+...
                               gOE(i,j-1)*(Eactual(i,j-1)-Eactual(i,j))+...
                               gNS(1,j)*(Eactual(1,j)-Eactual(i,j))+...
                               gEO(i,j+1)*(Eactual(i,j+1)-Eactual(i,j));
              end,   
              if j==M,
                 CC(i,j)=gSN(i-1,j)*(Eactual(i-1,j)-Eactual(i,j))+...
                               gOE(i,j-1)*(Eactual(i,j-1)-Eactual(i,j))+...
                               gNS(i+1,j)*(Eactual(i+1,j)-Eactual(i,j))+...
                               gEO(i,M)*(Eactual(i,M)-Eactual(i,j));
             end,   
           else
               
           % ----------------------------Puntos interiores de la rep. plana
             CC(i,j)=gSN(i-1,j)*(Eactual(i-1,j)-Eactual(i,j))+...
                              gOE(i,j-1)*(Eactual(i,j-1)-Eactual(i,j))+...
                              gNS(i+1,j)*(Eactual(i+1,j)-Eactual(i,j))+...
                              gEO(i,j+1)*(Eactual(i,j+1)-Eactual(i,j));
           end;
           
           % -----------------------------------Repeticion de la Excitacion
           if rem(t,5),
              CC(i,j) = CC(i,j) + estimulo(i,j);
           end;

        end;
    end;

% -------------------------------------------------------------------------
%               ACTUALIZACION DE POTENCIALES
% -------------------------------------------------------------------------
    for i=1:N,   
        for j=1:M,
           [fase(i,j),Enuevo(i,j),RF(i,j),CT(i,j)] = ...
         AC_celulaPURKINJE(fase(i,j),Eactual(i,j),RF(i,j),CT(i,j),CC(i,j));
           Eactual(i,j) = Enuevo(i,j);
        end;
    end;
    
    % ------------------------------------------Actualizacion de la grafica
    pcolor(Enuevo),colormap jet,shading flat;    
    axis square;
    drawnow;
    
end,
function [fase,Enuevo,RF,CT] = celulaPURKINJE(fase,Eactual,RF,CT,CC);
INH = 0.001;

switch fase,
    case 0,
        Enuevo = Eactual + 40;
        if Enuevo >= 30,
            fase = 1;
        end
    case 1,
        Enuevo = 0.7*Eactual;
        if Enuevo <= 10,
            fase = 2;
        end
    case 2,
        Enuevo = 1.1*Eactual + 4*CT - 6;
        if Enuevo <= -70,
            fase = 4;
            CT = 0;
            RF = 0;
        end
    case 4,
        Enuevo = Eactual + CC*RF;
        if Enuevo >= -60,
            fase = 0;
        else
            RF = min(RF + INH,1);
            CT = min(CT + INH,1);
        end
end

martes, 24 de abril de 2012

Lenguaje R

R es un lenguaje y entorno de programación para análisis estadístico y gráfico.
Se trata de un proyecto de software libre, resultado de la implementación GNU del premiado lenguaje S. R y S-Plus -versión comercial de S- son, probablemente, los dos lenguajes más utilizados en investigación por la comunidad estadística, siendo además muy populares en el campo de la investigación biomédica, la bioinformática y las matemáticas financieras. A esto contribuye la posibilidad de cargar diferentes bibliotecas o paquetes con finalidades específicas de cálculo o gráfico.
R se distribuye bajo la licencia GNU GPL y está disponible para los sistemas operativos Windows, Macintosh, Unix y GNU/Linux.
 
#!/usr/bin/bash
experimento <- read.table("observaciones.txt",col.names=c("prototipo","resultado"))

print(experimento)
aov.experimento <- aov(resultado~prototipo,experimento)

print(aov.experimento)
summary<-summary(aov.experimento)

print(summary)
#aplicar medias y desviaciones estandar por condición
means<-tapply(experimento$resultado,experimento$prototipo,mean)

print(means)
stddev<-tapply(experimento$resultado,experimento$prototipo,sd)

print(stddev)
#observar los datos en cada grupo
#boxplot(resultado~prototipo)
eTukey <- TukeyHSD(aov.experimento,"prototipo")

print(eTukey)
plot(eTukey)
 
 
 
 
 

martes, 17 de abril de 2012

Python


Python es un lenguaje de programación creado por Guido van Rossum a finales de los ochentas cuyo nombre está inspirado en el grupo de cómicos ingleses “Monty Python”. Se trata de un lenguaje interpretado o de script, con tipado dinámico (no es necesario declarar el tipo de dato que va a contener una determinada variable), fuertemente tipado (no permite tratar a una variable como si fuera de un tipo distinto al que tiene), multiplataforma (UNIX, Solaris, Linux, DOS, Windows, OS/2, Mac OS, etc.). Se trata además de un lenguaje de programación multiparadigma ya que soporta orientación a objetos, programación imperativa y, en menor medida, programación funcional.

Su sintaxis simple, clara y sencilla; el tipado dinámico, el gestor de memoria, la gran cantidad de librerías disponibles y la potencia del lenguaje, entre otros, hacen que desarrollar una aplicación en Python sea sencillo y rápido.

Algunos casos de éxito en el uso de Python son Google, Yahoo, la NASA, Industrias Light & Magic, y todas las distribuciones Linux, en las que Python cada vez representa un tanto por ciento mayor de los
programas disponibles.

Ligas de interés acerca de Python:
 
 A continuación se presentan algunos ejercicios de programación en Python:


#!/usr/bin/python

print "\n******* Entrada desde teclado *********\n"

#lee la linea desde teclado y la regresa como cadena de caracteres
str1 = raw_input("Entrada 1: ");
print "Entrada recibida : ", str1

#lee la linea desde teclado y la recibe como una expresion valida de Python
str2 = input("Entrada 2: ");
print "Entrada recibida : ", str2

print "\n********Acceso a subcadenas de una cadena*******\n"

str3='Monica Guadalupe Elizondo Amaya'
print "str3: ", str3
print "str3[0], str3[7], str3[17], str3[26]: ", str3[0], str3[7], str3[17], str3[26] 
print "str3[0:5]", str3[0:5]

print "\n********Algunos ejemplos de manejo de listas*******\n"

x=2
y='hola'
z=1.4

lista1 = ['Monica', 2013, 0.5, x,y,z];
lista2 = [3,5,8,9,5,7,5];
lista3 = lista1+lista2

print "lista1: ", lista1
print "lista2: ", lista2
print "lista3:", lista3
print "lista2[1:4]: ", lista2[1:4]
del lista1[2];                 #borra el elemento en la posicion 2 de lista1
lista1.remove(1.4)             #borra un elemento especifico de lista1, aqui tomo el valor de z 
lista1.append('tu')            #inserta la cadena al final de la lista
lista1.insert(0,z)             #inserta el elemento en la posicion 0 de lista1, aqui inserto z
print "lista1 modificada: ", lista1
print "x en lista1: ", x in lista1
print "2 en lista1: ", 2 in lista1
print "'Monica' en lista1: ", 'Monica' in lista1
print "'on' en lista1: ", 'on' in lista1
print "'4' en lista1: ", 4 in lista1
print "Numero de repeticiones del 5 en lista 2: ", lista2.count(5)
print "Indice de primera aparicion del 5 en lista 2: ", lista2.index(5)

print "\n********Diccionarios*******\n"

dict = {'Nombre': 'Miguel', 'Edad': 27, 'Ciudad': 'Monterrey', 'Turno': 'Matutino', 'Salon': 401};

print dict;
print "dict['Nombre']: ", dict['Nombre'];
print "dict['Edad']: ", dict['Edad'];
print "dict.keys(): ", dict.keys();
print "dict.values(): ", dict.values();
items=dict.items();
print "items=dict.items(): ", items;
item=items[1];
print "item=items[1]: ", item;
print "item[0]: ", item[0], "  item[1]: ", item[1];
print "usando sorted: ", sorted(dict.keys());

print "\n\n"

A continuación se muestra la salida:

El siguiente programa imprime las palabras de un archivo de texto su el número de repeticiones. Se escoge entre imprimir todas en orden alfabético o imprimir las 10 palabras más repetidas.

#!/usr/bin/python 

#el modulo sys contiene informacion sobre el sistema
import sys

# Regresa un diccionario que mapea cada palabra del archivo con su contador  
def word_count_dict(filename):

  word_count = {}  
  input_file = open(filename, 'r')
  for line in input_file:
    words = line.split()    #regresa el numero de palabras en la linea
    for word in words:
      word = word.lower()   #Convierte todas las letras mayusculas a minusculas

      if not word in word_count:
        word_count[word] = 1
      else:
        word_count[word] = word_count[word] + 1
  input_file.close()  
  return word_count

#imprime en cada linea cada palabra del archivo y su contador en orden alfabetico
def print_words(filename):

  word_count = word_count_dict(filename)
  words = sorted(word_count.keys())
  for word in words:
    print word, word_count[word]

# regresa el contador de la dupla palabra:contador 
def get_count(word_tuple):
  return word_tuple[1]

#imprime el la lista top 10  del archivo de texto
def print_top(filename):

  word_count = word_count_dict(filename)

  # items es el conjunto de duplas
  # Ordena las palabras en del diccionario en orden no creciente respecto a sus apariciones
  # key es una funcion que transforma cada elemento a ser comparado, en este caso se utiliza para extraer el contador de la dupla palabra/contador
  items = sorted(word_count.items(), key=get_count, reverse=True)

  for item in items[:10]:
    print item[0], item[1] 

def main():
  if len(sys.argv) != 3:
    print 'argumentos: ./contador.py {count | topcount} filename'
    sys.exit(1)

  option = sys.argv[1]
  filename = sys.argv[2]
  if option == 'count':
    print_words(filename)
  elif option == 'topcount':
    print_top(filename)
  else:
    print 'opcion desconocida: ' + option
    sys.exit(1)

if __name__ == '__main__':    #es de utilidad para cuando este modulo es re-utilizado en otro modulo
  main()                      #para identificar que el main se realize solo cuando se ejecuta este modulo.

Salidas del programa imprimiendo todas las palabras del texto en orden alfabético y las 10 mas repetidas.


martes, 13 de marzo de 2012

Tarea 4: gnuplot


A continuación se proporcionan ejemplos de script para graficar a partir de un archivo de datos .txt

Gráfica 1: histograma

set term postscript eps enhanced 24 'Times-Roman'
set output "histo.eps"
set encoding iso_8859_1 #acentos
set term postscript color
unset key
set tmargin 5
set yrange [0:2000]
set border
set ylabel "Average times (sec)" font "Times-Roman, 26" 
set style histogram cluster gap 1
set style fill solid border -1
set xtics rotate by -20 ("Barrier" 0.0000, "Sifting" 1.0000, "Dual Simplex" 2.00, "Network Simplex" 3.00, "Primal Simplex" 4.00) font "Times-Roman,26" 
set grid ytics lt 3 lc rgb "gray10"
set boxwidth 1
plot "histo2.txt" using 2 lt rgb "gray40" with histograms

Gráfica 2: Gráfica de líneas

set term postscript color
set key spacing 1
set xtics  1,1,20     
set xrange [0:21]     
set yrange [0:200]
set key right center box  
set border
set grid lt 2 lc rgb "gray10"
#set grid lt 3 lc rgb "gray"
set xlabel "{/=26 Instances}" 
set ylabel "Values" font "Times-Roman, 26" 
set style line 1 linetype 3 lw 3 lc rgb "black" pointtype 7 
set style line 2 linetype 1 lw 2 lc rgb "black" pointtype 7
set style line 3 lc rgb 'black' lt 4 lw 4 pt 7 ps 1.5 
set style line 4 lc rgb 'black' lt 1 lw 4 pt 4        
set style line 5 lc rgb 'black' lt 2 lw 4 pt 6 #lt 3
set style line 6 lc rgb '#dd181f' lt 1 lw 3 pt 4 ps 1.5   # red
set style line 7 lc rgb 'blue' lt 3 lw 3 pt 7 ps 1.5   # --- blue
set style line 8 lc rgb '#dd181f' lt 1 lw 3 pt 6 ps 1.5   # --- red
set pointsize 1.5
set size 1.6, 3.1
set multiplot
set bmargin 5.0
set origin 0,1.5
set size 1.6, 1.4
set title  "{/Italic n}=60, {/Italic p}=4" font "Times-Roman,26"
plot "opt60.txt" using 1:2 w linespoints ls 3 title "DBS-P bound",\
     "opt60.txt" using 1:3 w linespoints ls 4 title "LR bound",\
     "opt60.txt" using 1:4 w linespoints ls 5 title "Optimal solution"
set origin 0,0
set size 1.6, 1.4
set yrange [0:180]
set title  "{/Italic n}=100, {/Italic p}=6" font "Times-Roman,26"
plot "opt100.txt" using 1:2 w linespoints ls 3 title "DBS-P bound",\
     "opt100.txt" using 1:3 w linespoints ls 4 title "LR bound",\
     "opt100.txt" using 1:4 w linespoints ls 5 title "Optimal Solution"

Gnuplot


Gnuplot es un programa muy flexible para generar gráficas de funciones y datos. Es un programa en línea de comandos que permite dibujar gráficas de funciones en 2 y 3 dimensiones a través de las fórmulas que las definen.
El origen de gnuplot data de 1986. El software tiene copyright pero se distribuye libremente y está disponible para UNIX, Linux, IBM OS/2, MS Windows, MSDOS, Macintosh, VMS, Atari y muchas otras plataformas.
Originalmente estaba destinado a científicos y estudiantes para permitirles visualizar gráficamente funciones matemáticas o tablas de datos. Es utilizado por otras herramientas, entre las que se encuentran Maxima y GNU Octave., para dibujar gráficas evitandoles tener que desarrollar su propio motor de dibujo..
Además de dibujar la gráfica en pantalla puede guardarla en multitud de formatos entre los que se encuentran los usuales, como PNG, EPS, SVG, JPEG; y otros, menos usuales, pero muy interesantes para los usuarios LaTeX como metafont, eps, pstricks, picture, etc. Se puede usar interactivamente o en modo por lotes (batch), usando scripts.

Documentacion oficial de gnuplot:


Tutorial gnuplot 4.4 en PDF:


Demo scripts para gnuplot:

martes, 28 de febrero de 2012

Sed

 Sed es un editor de emisiones (stream editor) utilizado para el procesamiento  de texto en archivos. Utiliza un lenguaje de programación para realizar transformaciones en una emisión de datos leyendo línea por línea de estos. Fue desarrollado entre 1973 y 1974 por Lee E. McMahon de Bell Labs. Está incluido en las instalaciones básicas de prácticamente todas las distribuciones de GNU/Linux.

 Algunas referencias:

http://sed.sourceforge.net/sedfaq.html
http://www.gentoo.org/doc/es/articles/l-sed1.xml

Ejemplos de usos de Sed:
#!/bin/bash

for M in "60" "80"
do 
    
#Borrar hasta antes de la ocurrencia "Tiempo"
    sed '/^Tiempo/,$!d' salida_$M.out
    
#Borrar el bloque de lineas entre ocurrencias 
    sed '/^Tried/,/^Total/d' salida_$M.out
    
#Borrar desde la 5ta linea hasta la ocurrencia "Total"
    sed -i '5,/^Total/d' salida_$M.out 
    
#Uso de -i para modificar archivo original y respaldarlo
    sed -i".dat" -e '/^Tried/,/^Total/d' salida_$M.out
    
#borrar lineas en blanco
    sed '/^$/d' salida_$M.out
    
#Hacer que solamente exista una línea en blanco después de cada frase
    sed '/^$/d;G' salida_$M.out 
    
#Añadir una línea en blanco después de cada frase
    sed G salida_$M.out
    
#Insertar una línea en blanco antes de cada línea que cumpla con una ocurrencia
    sed -i '/fallo/{x;p;x}' salida_$M.out
    sed -i '/se/{x;p;x}' salida_$M.out
    
#Insertar una línea en blanco antes y después de cada línea que cumpla con una ocurrencia
    sed '/Inicio/G' salida_$M.out
    
# leer y remplazar
    echo "texto a rempl"; read remplazar
    echo "por "; read por
    sed "s_"$remplazar"_"$por"_g" < salida_$M.out
    
#Cambiar minsuculas por maysculas la primera letra de una linea
    sed -i 's/^./\u&/' salida_$M.out
    
#Insertar linea de texto antes(i), despues(a) y en la linea(c) 
    sed -i "10a\seg" salida_$M.out 
    
done

martes, 14 de febrero de 2012

Tarea 2: AWK

Para acceder a los códigos fuente de esta tarea dar click aquí
Tarea2
View more presentations from melizondo_amaya.

#!/usr/bin/awk -f 
BEGIN {
    nodos=0;
    coordx=201.348998;
    coordy=63.024305;
    nodoi=17;
    nodoj=42;
    radio=100;
    minD=1000000;
    maxD=0;
    minimoD="";
    maximoD="";
    for(k=0; k<3 ;k++){
    suma[k]=0;
    min[k]=1000000;
    max[k]=0;
    minimo[k]="";
    maximo[k]=""
    }
    cIN=0;
    for(k=0; k<60; k++){
    grado[k]=0;
    }
    adyacentes=0;
}

{
    if(NR==1){
    nodos=$0
    }
   
    if(NR>1 && NR<=(nodos+1)){
   
#Array de nodos cuya distancia al pundo tado es menor al
#radio de cobertura
   
    D=sqrt(((coordx-$2)^2+(coordy-$3)^2))
    if(D<=radio){
        nodosIN[cIN]=$1
        cIN++
    }

#Suma de actividades nodales y obtencion de minimos y maximos

    for(k=0; k<3; k++){       
        suma[k]=$(k+4)
       
        if (min[k]>=$(k+4)){
        min[k]=$(k+4)
        minimo[k]=$1
        }
        else if (max[k]<=$(k+4)){
        max[k]=$(k+4)
        maximo[k]=$1
        }
    }
    }
    for(k=0; k<3; k++){       
    promedio[k]=suma[k]/nodos;
    }

#busca adyacencias

    if (NR==(nodos+2))
    adyacencias=$0

    if (NR>(nodos+2) && NR<(nodos+2+adyacencias)){
    grado[$1]++
    grado[$2]++   
    if(($1==nodoi && $2==nodoj) || ($1==nodoj && $2==nodoi))
        adyacentes=1;
    }
   
}
END{   
    print "\n Cantidad de nodos= " nodos "\n"
    print " Nodos dentro de un radio de cobertura r= " radio
    print " para el punto (" coordx "," coordy ") :"
    for (k=0;k<cIN;k++){
    print nodosIN[k]
    } 
    print "\n Minimos y maximos para actividades nodales: \n"
    for (k=0;k<3;k++){
    print "\n Actividad " k+1 " : \n El promedio es: " promedio[k] "
    print " El minimo es el nodo " minimo[k] " con " min[k]
    print " El maximo es el nodo " maximo[k] " con " max[k]   
    }
    print "\n En total hay " adyacencias " adyacencias"
    print " El grado de cada nodo es el siguiente: \n"
    for(k=0; k<nodos;k++){
    print "Nodo " k+1 ": grado " grado[k]
    }
    if(adyacentes==0)
    print "Los nodos proporcionados " nodoi " y " nodoj " NO son adyacentes"
    else
    print "Los nodos proporcionados " nodoi " y " nodoj " SI son adyacentes"
}

miércoles, 8 de febrero de 2012

AWK

AWK es un lenguaje de programación de propósito general diseñado para procesar archivos de texto y flujos de datos. El nombre AWK deriva de los apellidos de los autores: Alfred V. Aho, Peter J. Weinberger y Brian W. Kernighan. La sintaxis es muy semejante a la del lenguaje C, con la particularidad de que, al ser awk un intérprete, no es necesario pasar por procesos de compilación y linkedición. Con AWK se pueden generar reportes, validar datos, producir índices, extraer fragmentos de datos para procesamiento, ordenar datos, etc. La implementación de awk para GNU se conoce como gawk

Un archivo se compone de registros, que por defecto son las líneas del archivo. Una línea se convierte en un registro. AWK opera en un registro a la vez. Un registro se compone de los campos, que por defecto están separados por cualquier número de espacios o tabuladores. 

La función básica de AWK se centra entonces en la selección de registros de un archivo en función de uno o varios patrones. Cuando un registro concuerda con uno de los patrones, AWK aplica las acciones especificadas a esa línea. Si solamente resultara relevante una parte del registro seleccionado, también sería posible separarla e ignorar el resto.

Para mayor información sobre AWK, dejo aquí algunas referencias:

Tarjetas de referencia de interés:
AWK







martes, 31 de enero de 2012

Tarea 1- Bash

A continuación se presenta un ejemplo del uso de Bash en la automatización de la repetición de ejecuciones de un programa codificado en C.

BASH


Bash, escrito por Brian Fox en 1987, es el shell o intérprete de lenguaje de comandos, para el sistema operativo GNU. Su nombre es un acrónimo de "Bourne-Again Shell", haciendo un juego de palabras (born-again significa renacimiento) sobre el shell Bourne (sh), que fue uno de los primeros shells importantes de Unix, originalmente escrito por Stephen Bourne en 1978.

Bash es el shell por defecto en la mayoría de sistemas GNU/Linux, además de Mac OS X Tiger, y puede ejecutarse en la mayoría de los sistemas operativos tipo UNIX. También se ha portado a Microsoft Windows por el proyecto Cygwin.

Shell

Una Shell de Unix o también shell, es el término usado en informática para referirse a un intérprete de comandos, el cual consiste en la interfaz de usuario tradicional de los sistemas operativos basados en Unix y similares como GNU/Linux. El usuario dialoga con el intérprete de comandos, y éste transfiere las órdenes al sistema operativo, que las ejecuta sobre la máquina.

Shell que significa en Castellano “concha”, sirve fundamentalmente para tres cosas: administrar el sistema operativo, lanzar aplicaciones (e interactuar con ellas) y como entorno de programación. Los programas de Shell no necesitan compilarse. La Shell los interpreta linea a linea. Se les suele conocer como Shells Scripts y pueden ser desde sencillas ordenes hasta complejas series de instrucciones para el arranque del propio sistema operativo.

Script

En informática un guion, archivo de órdenes o archivo de procesamiento por lotes, es lo que se conoce como script, un archivo de texto, que contiene una serie de comandos para shell, que el sistema ejecuta ordenadamente, de arriba abajo. Para editarlos, tan solo hace falta un editor de textos, como Emacs, o Vi. Se guardan con extensión: .sh y se ejecutan desde la Shell mediante el comando: sh nombre de script.sh. Los archivos script suelen ser también identificados por el sistema a través de uno de los siguientes encabezamientos en el contenido del archivo: #!/bin/bash ; #!/bin/ksh ; #!/bin/csh 

El uso habitual de los guiones es realizar diversas tareas como combinar componentes, interactuar con el sistema operativo o con el usuario. Por este uso es frecuente que los shells sean a la vez intérpretes de este tipo de programas.
La programación en shell de unix surgió como respuesta a las tareas que se realizaban secuencialmente y prácticamente en el mismo orden para conseguir hacer algo con el sistema. Los scripts de Shell son extremadamente útiles. Evita hacer tareas repetitivas al escribir aquellas necesidades que tengamos y luego editar scripts que realicen este trabajo por nosotros.

Fuentes y accesos de interés:


Tarjetas de referencia :


Herramientas Programables de Cómputo Científico


Clase impartida por la doctora Elisa Schaeffer en el Programa de Posgrado en Ingeniería de Sistemas de la UANL. Este blog fue creado para fines que convengan a la dinámica de trabajo de la clase, principalmente la difusión del aprendizaje generado y prácticas desarrolladas durante el curso.