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