שירים ישראלים להורדה בחינם
לקנות ויאגרה
תעריף תרגום מעברית לאנגלית
брокеры бинарных опционов
קמגרה למכירה
как получить купон на алиэкспресс

Tag Archives: gfortran

Matrix revolutions

Si cuando era un puber con excesivo brillo en el rostro alguien me decía que laburar con matrices iba a estar relacionado con informática, hubiese levantado sutilmente mis hombros con mi mejor cara de “oliendo excremento”.

El tema es que las matrices andan por todos lados. En primer año de la carrera uno las agarraba, las manoseaba (gauss-jordan), las daba vuelta (inversión), las tumbaba (transposición) y un sin fin más de operaciones (casi todo lo que indica el libro hindú) sin tener real dimensión de cuán involucradas estaban en el mundo.

No solo fotos o imágenes satelitales, cualquier problema que involucre varias incógnitas y ecuaciones termina idefectiblemente en una matriz a resolver (Ax=b).

El mundo gnulinuxero nos ha bien-acostumbrado a buscar, renegar, probar, indagar una y otra vez en un ciclo casi infinito (casi infinito = infinito) hasta alcanzar la solución a nuestros problemas. Así es que uno presupone que al transitar un nuevo camino se topará con decenas de obstáculos hasta alcanzar lo buscado.

Ah Si?

NO!
No fue así, en el primer intento ya estaba resolviendo un simple sistema matricial utilizando rutinas REcontraREmilREprobadas y que por años luz serán más eficientes de las que pueda llegar a programar yo en mis mejores sueños. Asi es como puse a buscar las librerías BLAS y LAPACK para que hagan el laburo por mi o mis compañeros.

Lo primero que vamos a hacer es instalarlas, luego algún lenguaje para usarlas (por ahora solo en fortran) y finalmente un ejemplo para probar que la cosa ande.

Instalación BLAS+LACPACK

#aptitude install libblas3gf libblas-doc libblas-dev liblapack3gf liblapack-doc liblapack-dev

Instalación gfortran

#aptitude install gfortran

Ejemplito a resolver

  <pre>\begin{bmatrix}  3.1 & 1.3 & -5.7 \\  1.0 & -6.9 & 5.8 \\  3.4 & 7.2 & -8.8  \end{bmatrix}  \begin{bmatrix}  x_1 \\  x_2 \\  x_3  \end{bmatrix}  =  \begin{bmatrix}  -1.3\\  -0.1\\  1.8  \end{bmatrix}</pre>

Programita a compilar (test1.f)

c solving the matrix equation A*x=b using LAPACK
	Implicit none
c declarations, notice single precision
	Real*4 A(3,3), b(3)
	integer i, j, pivot(3), ok
c define matrix A
	A(1,1)=3.1
	A(1,2)=1.3
	A(1,3)=-5.7
	A(2,1)=1.0
	A(2,2)=-6.9
	A(2,3)=5.8
	A(3,1)=3.4
	A(3,2)=7.2
	A(3,3)=-8.8
c define vector b, make b a matrix and you can solve multiple
c equations with the same A but different b
	b(1)=-1.3
	b(2)=-0.1
        b(3)=1.8
c find the solution using the LAPACK routine SGESV
	call SGESV(3, 1, A, 3, pivot, b, 3, ok)
c
c parameters in the order as they appear in the function call
c    order of matrix A, number of right hand sides (b), matrix A,
c    leading dimension of A, array that records pivoting,
c    result vector b on entry, x on exit, leading dimension of b
c    return value
c
c print the vector x
	do i=1, 3
	   write(*,*) b(i)
	end do
	end

Compilación

$gfortran -lblas -llapack test1.f -o test1.bin

Ejecución y resultado

$./test1.bin
1.0000001
1.0000004
1.0000004

Para mayor información: busque más información!!

C’est fini

 

Pedime arreglo

Ayer estaba tratando de programar el algoritmo bit-reverse order que se usa en la fft y primeramente lo había hecho a pata, bien “a lo bruto”, después me puse a mirar acá y vi que si lo hacía de manera implícita era una boludez.
Lo hice con una función recursiva, así sirve para cualquier arreglo de longitud potencia de 2, en fin, la parte del algoritmo que pone en la primer mitad los elementos de índice par y en la segunda los de índice impar, se puede hacer en dos lineas, y así economizar código. Si c es nuestro arreglo auxiliar y x el arreglo de entrada, y ambos van de 0 a N-1,

c(0:N/2 -1)=x(0:N-1:2) !– pares
c(N/2:N-1)=x(1:N-1:2) !– impares

Como decía arriba, si a esto lo pongo en una función a la que llamo recursivamente pasandole la primera mitad del vector c y luego la segunda mitad, el bit-reverse order sale por un tubo.

Arreglos implícitos

No se si el título realmente identifica lo que quiero mostrar, pero no importa…
El tema es así, para generar un vector -llamemoslo X- que vaya desde un valor determinado -límite inferior (li)- hasta otro -límite superior- con un incremento dx solíamos hacer -antes de ver la luz- un ciclo do de la siguiente manera:

do i=0,K
x(i)= li + real(i)*dx
end do

Esto me resultaba bastante incómodo, porque por cada inicialización de una variable independiente debíamos reccorrer todo un cliclo y hacer tres lineas de código, cuando en lenguajes interpretados esto se hace en una sola.

Bien, acá el tema es que fortran (ya empiezo a sentir cosas por él) es un lenguaje ecléctico entre aquelos interpretados y compilados, caracterísctica que a mi modo de ver lo destaca.

Para evitar las tediosas tres lineas anteriores, basta con definir el vector X de la siguiente manera:

X=(/(i*dx, i=li,ls)/)

Por ejemplo, si quisieramos tener valores entre -0.5 y 0.5 con un dx=0.1:

X= (/(i*0.1,i=-5,5)/)

Esto nos daría,

-0.5000000
-0.4000000
-0.3000000
-0.2000000
-0.1000000
0.000000
0.1000000
0.2000000
0.3000000
0.4000000
0.5000000

Muy útil para tener programas más limpios…
Hasta la próxima

Fortran no ha muerto

Sinceramente pensaba que fortran era de esos lenguajes viejísimos, muertos, que nunca en mi perra vida iba a ver. Una vez más me equivoqué feo.
Estoy encontrando funcionalidades en fortran que a mi modo de ver lo destacan de otros lenguajes, obviamente que depende mucho del objetivo de la aplicación que estamos programando.
En fin, yendo a los bifes les menciono algunos detalles modernos destacables relacionados con el manejo de arreglos,

  • Permite índices desde cualquier rango
    real :: x(-10:10)
    real :: y(0:10)

  • Trabajar con vectores de modo vectorizado
    write(*,*) x(0:10)
    y=x(-10:0)

  • Extraer algunos elementos del vector

    x((/1,8,5,6/)) -> esto nos devuelve una sección del arreglo con elementos x(1), x(8), x(5), x(6)

Ya volveré con algunos detalles más sobre este lenguaje que cada vez me gusta más.

Fortran en GNU/Linux

Para programar en fortran sin recurrir a compiladores propietarios encontré la alternativa ideal, por supuesto, del lado del software libre: gfortran.

Acá, algunos tips para compilar un programita con módulos:

Tengo dos fuentes, uno es el principal (main.f95) y otro es un módulo (my_mod.f95).

1) Creo el código objeto de cada uno:

$f95 -g -c -o my_mod.o my_mod.f95
$f95 -g -c -o main.o main.f95

Esto me genera los archivos objeto cuyo nombre se especificó en la opción -o y además me genera para el módulo un archivo extensión .mod (my_mod.mod)

2) Ahora lo compilo (enzalandolos y generando el ejecutable a partir de los objetos anteriores):

$f95 -o main.exe main.o my_mod.o

Ahora, uno con varios modulos:

1) Un modulo:

f95 -g -c -o my_random_module.o my_random_module.f95

2) Otro modulo:

f95 -g -c -o tri_modules.o tri_modules.f95

3) El que usa los modulos:

f95 -g -c -o ej_tres.o ej_tres.f95

4) Enlazo todo:

f95 -o ej_tres ej_tres.o my_random_module.o tri_modules.o

Social Widgets powered by AB-WebLog.com.

Social Widgets powered by AB-WebLog.com.

Social Widgets powered by AB-WebLog.com.