Fractal de Mandelbrot amb Octave i GNUPlot

Indico, en aquest apunt, com dibuixar el fractal de Mandelbrot emprant programari lliure (concretament, Octave per a l’elaboració dels càlculs i GNUPlot per a dibuixar gràfiques).

Aquest conjunt consisteix simplement en examinar, punt per punt en un pla complex, si la iteració de la funció z^2 + C (on C és el punt del pla complex sota anàlisi) “s’escapa” ( tendeix a infinit ) o no ( en aquest cas, mirem si el valor queda per sota 10). Iterar significa, simplement, aplicar la mateixa funció a cada resultat obtingut (la base del sistemes dinàmics).

Aquest és el codi amb Octave:

function y=f(z, real,img)
 y=(z^2) + real + img*i ;
 endfunction

M=100;

%Iterations
 for l=-2:0.01:2
 for m=-2:0.01:2
 c=1;
 x = 0;
 while ((c<M) && ( abs(x) < 10 ))
 x = f(x, l , m);
 c=c+1;
 endwhile
 if (( abs(x) <= 10) && (c==M))
 printf("%f %f\n", l, m);
 endif

endfor
 endfor

L’execució d’aquest programa mostrarà per pantalla els punts que no s’escapen cap a infinit. Podem redirigir la seva execució cap a un fitxer octave ex2.m > mandelbrot.dat i pintar-los amb gnuplot:

plot 'mandelbrot.dat'

 

mandelbrot

Rotació d’imatges a través de la transposada d’una matriu

Una imatge no és solament més que una matriu de N (píxels d’amplada ) x N (píxels d’alçada) x 3 (canals de colors). Per tant, moltes de les operacions que es realitzen sobre imatges són, en realitat, sobre matrius.

Imaginem disposem de la imatge següent:

 

steampunk

 

la podem girar efectuant la transposada de la matriu de cada color.

Codi amb Octave:

I=imread("steampunk.jpg");
/* Transposem la matriu color vermell */
J(:,:,1)=transpose(I(:,:,1));
/* Transposem la matriu color verd */
J(:,:,2)=transpose(I(:,:,2));
/* Transposem la matriu color blau */
J(:,:,3)=transpose(I(:,:,3));
imshow(J) imwrite(J,"t.jpg",jpg)

 

t

Interpolació de Lagrange amb Octave

Tenim els punts següents: f(-1)=2, f(0)=0, f(3)=4, f(7)=7. Volem estimar el valor de f(4) fent servir la interpolació de Lagrange.

Utilitzem aquesta funció d’Octave (extreta del llibre “Applied numerial methods using Matlab”).

gerard@Zeus:~> more lagranp.m
function [l,L] = lagranp(x,y)
%Input : x = [x0 x1 .... xN], y = [y0 y1 ... yN]
%Output : l = Lagrange polynomial coefficients of degree N
%       L = Lagrange coefficient polynomial
N = length(x)-1;
l = 0;
for m = 1:N + 1
        P = 1;
        for k = 1:N + 1
                if k ~= m, P = conv(P,[1 -x(k)])/(x(m)-x(k)); end
        end
        L(m,:) = P;
        l = l + y(m)*P;
end

Ara, executem Octave:

octave:1> x = [ -1 0 3 7];
octave:2> y = [ 2 0 4 7 ];
octave:3> lagranp(x,y)
ans =

  -0.11458   1.06250  -0.82292   0.00000

Per tant, f(4)=-0.11458*4^3 +  1.06250*4^2  -0.82292* 4 +  0.00000 = 6.3752

Solución computacional al problema “Números bonitos, números feos”

Código en C++ que resuelve el desafío “Números bonitos, números feos” de El País de ayer. Sí, ya sé que utilizar una solución computacional no será válida 🙁 , pero es que no he podido evitar hacer trampa.

#include <iostream>
using namespace std;
//Esta función calcula el sumatorio de k
 int sumaDigitos ( int k ) {
 int suma=0;
 int numero = k;
 int nuevon, udigito;
do {
 nuevon= numero / 10;
 udigito=numero % 10;
 numero=nuevon;
 suma=suma+udigito;
} while (nuevon != 0);
return suma;
}
int main() {
//Número a analizar
 int n = 0;
//Total de números bonitos
 int nbonitos = 0;
//n solo será bonito si bonito = 1
 int bonito = 0;
while ( n < 100000 ) {
if ( n % 5 == 0 ) {
 cout << n << " (cumple a)" << endl;
 bonito++;
 }
if ( n % 7 == 2 ) {
 cout << n << " (cumple b)" << endl;
 bonito++;
 }
if ( sumaDigitos(n) % 9 == 0 ) {
 cout << n << " (cumple  c)  -- " << sumaDigitos(n) << endl;
 bonito++;
 }
if ( bonito == 1 ) {
 cout << n << " --> Bonito" << endl;
 nbonitos++;
 }
bonito = 0;
 n++;
}
cout << endl << endl << "Total bonitos --> " << nbonitos << endl;
 return 0;
 }