The most useful function in this code that I would like to mention is poly2mask. It is just an amazing function. What poly2mask would do is return you a binary image based on your region of interest and that region of interest is a polygon defined by set of points (vectors). In my case my polygon was a set of points connecting to form an Ellipse but if you understand the code then you can make any kind of rotating polygon using Matlab. Read the comments in the code and I guess you should be able to understand it. Here is the prototype of the function call. The code generates a sequence of bmp files which were later converted to an mpeg video using imagemagick.

function [x,y] = generateEllipse(h, k, a, b,imageSize)

where h,k,a,b are standard notation for an Ellipse and imageSize is the size of an nxn output frame in which the Ellipse is going to rotate. Make sure to choose a big enough size which can accommodate an Ellipse white rotating

To watch the outcome from the code, see these videos:

Note the point of rotation in both videos.

Point of rotation is the centre:

Point of rotation is the left corner:

Using this code you can choose any point as "Point of Rotation" but make sure the point you choose lies inside the Ellipse. The code takes "Point of Rotation" output through the mouse using the Matlab function ginput and here is the code:

function [x,y] = generateEllipse(h, k, a, b,imageSize) 

steps = 36;

%angle at which the Ellipse is initially located
atAngle = 0;

beta = atAngle / 180 * pi;
sinbeta = sin(beta);
cosbeta = cos(beta);

%we need to make a turn of 360 degrees to make a well formed Ellipse
i=1:360/steps:360;
alpha = i / 180 * pi;
sinalpha = sin(alpha);
cosalpha = cos(alpha);

%round function is important so as to store the points in the matrix
%the formula used is the parametric equation for Ellipse
x = round(h + (a * cosalpha * cosbeta - b * sinalpha * sinbeta)); 
y = round(k + (b * sinalpha * cosbeta + a * cosalpha * sinbeta));

%to connect with the line initial point so to make a connected Ellipse
x = [x,x(1)];
y = [y,y(1)];

bw = poly2mask(x,y,imageSize,imageSize);
imshow(bw);

 
%the user selects the point of rotation using the mouse

[rotationPointX rotationPointY] = ginput(1);
close

%translating the rotations points to origin

x1 = x-rotationPointX;
y1 = y-rotationPointY;

%the Ellipse will rotate ahead by 10 degree in each successive frame
rotationAngle = 10;

for index=0:299 %to generate 300 frames
    angle = mod(rotationAngle*index,360);
    %the equation for rotation

    newX = x1* cosd(angle) - y1*sind(angle); 
    newY = x1* sind(angle) + y1*cosd(angle);

    
    % return a binary image by masking the Ellipse region
    bw = poly2mask(newX+rotationPointX,newY+rotationPointY,imageSize,imageSize);
    figure
    imshow(bw);
    close

    fileName = sprintf('Ellipse1_frame_%s%04i.bmp', '', index)
    imwrite(bw,fileName);
end

The code was written in Matlab7.

Menemukan posisi matriks (vektor) dengan nilai tak nol

Ada vektor dengan nilai komponen seperti berikut,

>> X = [1 0 4 -3 0 0 0 8 6]

X =

1     0     4    -3     0     0     0     8     6
Nilai indeks ke 3 7 dan 1 ditentukan dengan perintah,

>> X([3 7 1])

ans =

4     0     1
variabel indices menunjukkan posisi (indeks) matriks X yang mempunyai nilai tak nol

>> indices = find(X)

indices =

1     3     4     8     9

posisi (indeks) matriks X dengan nilai lebih besar dari 2

>> find(X > 2)

ans =

3     8     9
posisi (indeks) matriks X dengan nilai sama dengan 0

>> find(X == 0)

ans =

2     5     6     7

Menampilkan nilai matriks X dengan nilai lebih besar dari 2

>> X(find(X > 2))

ans =

4     8     6

La fonction de Bessel utilisée est une fonction du premier type $latex J_n(x)$ avec n valant 1. Cette fonction présente deux points particuliers, elles s'annule en 0 et en 3.8317. Un paramètre alpha est rajouté pour modifier le profil de vitesse du fluide dans le cylindre. La vitesse azimutale peut donc s'écrire:

$latex v_{s} = C ~ J_1(\alpha\frac{r}{R})/\alpha$

où $latex C$ est une constante à définir, $latex r$ est le rayon où l'on souhaite connaître la vitesse et $latex R$ est le rayon maximal.

Dans les publications, on retrouve l'expression d'un "swirl ratio" qui correspond au rapport de la vitesse angulaire d'une roue représentant le fluide et de la vitesse angulaire du moteur.

$latex R_s = \frac{\omega_s}{2\pi ~ rpm/60}$

où $latex R_s$ est le ratio et $latex w_s$ est la vitesse angulaire de la "roue" représentant le fluide.

Il faut donc normalisé la fonction de Bessel en fonction de cette vitesse de rotation en posant que le moment angulaire est identique [1].

Le moment angulaire étant défini par

$latex L = \sum_i r_i v_i m_i$

où $latex m_i$ est la masse du volume élémentaire considéré. Dans le cas du cylindre, pour un élément d'angle et de hauteur (T et p uniforme lors de l'initialisation) cette masse élémentaire est proportionnelle au rayon et donc à une constante commune prêt:

 $latex L \propto \sum_i v_i r_i^2$

On peut donc normaliser la vitesse azimutale en divisant celle-ci par la valeur de cette somme sur une valeur finie d'élément (typiquement 1000) sur le rayon. Le code matlab pour le calcul de la norme peut, par exemple, être

norm = besselj(1,alpha*(0:0.001:1)) * ((0:0.001:1)'.^2) /alpha

Des valeurs particulières du paramètre $latex \alpha$ sont représentées à la figure suivante (la valeur en ordonnée est normalisée par la valeur maximale de la vitesse de la "roue"):

Il ne reste plus qu'à lier la valeur du swirl ratio avec la valeur réelle de la vitesse. Pour cela, il suffit de multiplier par $latex \omega_s ~ R$ et on obtient la valeur de la vitesse en fonction du rayon normalisé.

Références:

[1] A. A. Amsden, P. J. O’Rourke, T. D. Butler, "KIVA-II: A Computer Program for Chemically Reactive Flows with Sprays", Los Alamos National Laboratory, 1989.

[2] S. Wahiduzzaman and C. R. Ferguson, “Convective Heat Transfer from a Decaying Swirling Flow within a Cylinder,” 8th International Heat Transfer Conference, paper #86-IHTC-253 (August 1986).

In the movie, John Leguzomo's character, a math teacher, is distracting his fellow panicking passenger in the Jeep with a mathematical question. The question he asks her is if he gave her a penny on Day 1 of the month, two pennies on Day 2 of the month, four pennies on Day 3 of the month, and so on, how much would money would she have after a month. She shouts $300 or some odd number like that. But, do you know that the amount is actually more than a 10 million dollars (Thanks to a student who mentioned that it was a penny that John offered on the first day, not a dollar - sometimes I do feel generous).

This question is based on a story from India and it goes as follows.

King Shriham of India wanted to reward his grand minister Ben for inventing the game of chess. When asked what reward he wanted, Ben asked for 1 grain of rice on the first square of the board, 2 on the second square of the board, 4 on the third square of the board, 8 on the fourth square of the board, and so on till all the 64 squares were covered. That is, he was doubling the number of grains on each successive square of the board. Although Ben’s request looked less than modest, King Shriham quickly found that the amount of rice that Ben was asking for was humongous.

QUESTIONS:

Write a MATLAB (you can use any other programming language) program for the following using the for or while loop.

1. Find out how many grains of rice Ben was asking for.
2. If the mass of a grain of rice is 2 mg, and the world production of rice in recent years has been approximately 600,000,000 tons (1 ton=1000 kg), how many times the modern world production was Ben's request?
3. Do the inverse problem - find out how many squares are covered if the the number of grains on the chess board are given to you. For example, how many squares will be covered if the number of grains on the chess board are 16?

This post is brought to you by Holistic Numerical Methods: Numerical Methods for the STEM undergraduate at http://numericalmethods.eng.usf.edu

Subscribe to the feed to stay updated and let the information follow you.

Its fun unlike learning C,php,sql etc. which I am afraid of. My first experiment started with the function magic() long ago long long ago when i was i first year. It was nice to identify the pattern of numbers for odd square matrices while had to break the head for the even dimensional matrices. Then the greed made me to go through the help to understand the code that they wrote (nice algo :P). It was then I found 3d plots very interesting and one day i sat to write a matrix (i forgot the dimentions of the matrix) to show A in the graph. Then I started playing with a lot of functions and started forgetting the older ones :(. You keep forgetting unless you dont use them in preactice. And today probably was the first time i used the functions for a proper use. And here is my first proper matlab file :).

Here is the code (any suggestions of improvement is welcome I'll learn frm them)

function generation=game(m)
%my first MATLAB problem statement is "GAME OF LIFE"
temp=0;
generation=0;
X=round(rand(m,m));
[i,j] = find(X);
figure(gcf);
plothandle = plot(i,j,'.', 'Color','blue');....this is nice way to write comment
axis([0 m+1 0 m+1]);
n = [m 1:m-1];
e = [2:m 1];
w = [m 1:m-1];
s = [2:m 1];
Z=0;
while 1
if((temp==0))
Y=X;
temp=1;
elseif(temp==2)
Z=X;
temp=0;
elseif(temp)
temp=temp+1;
end
if(Z==Y)
break
end
N = X(n,: ) + X(s,: ) + X(:,e) + X(:,w) + X(n,e) + X(n,w) + X(s,e) + X(s,w);
X= (X & (N == 2)) | (N == 3);
[i,j] = find(X);
set(plothandle,'xdata',i,'ydata',j)
drawnow
generation=generation+1;
end

%the number of generation i.e the answer returned is sometimes far less
%than the actaul number of generations it takes to stabilize a population

%Also here the universe is circular which could be made flat by modifying
%the values of news.

EOF

Rules of Game Of Life

In the "Game of Life" the domain is a 2-dimensional array of cells, and each cell can have one of two possible states, usually referred to as "alive" or "dead." The array is usually intialized using random numbers and the system then evolves in time. At each time step, each cell may or may not change its state, based on the number of adjacent alive cells, including diagonals. There are three rules:

1. If a cell has three neighbors that are alive, the cell will be alive. If it was already alive, it will remain so, and if it was dead, it will become alive.
2. If a cell has two neighbors that are alive, there is no change to the cell. If it was dead, it will remain dead, and if it was alive, it will remain alive.
3. In all other cases — the cell will be dead. If it was alive it becomes dead and if it was dead it remains dead.

You can have a look at those images here if you have matlab

If you don't have matlab click here.

The paper builds on Ned's work at Mathworks developing collaborative programming competitions for the MATLAB community. Adopting "the perspective of the code" it analyzes what happens when you set a horde of geeks loose on a fun, challenging programming problem in a networked collaborative environment.

To sum up my reactions really briefly, I thought the paper was an exciting step in the process of looking under the hood of collaborative knowledge production. Gulley and Lakhani argue that as programmers improved the performance of code relative to a discreet problem, they did so through "tweaks" and "leaps."

"Tweaks" represent small refinements that improve the performance of existing code; "Leaps" represent more sudden and large-scale advances in performance (usually driven by introducing a more substantive or extensive change in the code).

Tweakers and Leapers benefit from each other's work, but the biggest beneficiary of their combined interactions was the code itself. Within one week of the competitions, thousands of eyeballs had produced startling solutions to complex algorithmic problems.

There's a lot more to be learned from this kind of work - especially from the sort of experimental data created in the setting of these sort of large-scale collaborative games. In particular, I'm interested in thinking about how programmers (whether as individuals or communities) adapted to the challenges over time. It seems like it might be possible to design a game that could test whether efficient collaborative problem solving techniques "evolved" over the course of the game(s). In addition, it would be fascinating to test the results of this kind of collaboration against those produced by more hierarchical or individuated models of innovative work.

Look for links to the soon-to-be-published version of the paper on the "publications" section of Karim's HBS faculty page.

In the meantime, I'm told that video and audio of today's presentation should be available on the Berkman Center's "interactive section" by tomorrow afternoon at the latest.

I have written some code in MATLAB that can find optimal solutions for the rectangular knapsack problem where you have to maximise the area used when fitting smaller rectangles into the larger tile. For example, in the diagram below, how do you fit the 2x3 and 3x4 rectangles into the 5x5 tile such that you use the most area in the 5x5 tile? Rectangular knapsack needs to be solved very often in many industries including the glass cutting industry where you want to complete your orders but don’t want to waste glass (in other words, maximise area used).

I used straightforward dynamic programming in the solution which means that I try to find the optimal solutions of the subproblems and then, combine the subproblems to find the optimal solution of the main problem. So, using the set of given rectangles, I optimise area used in 1x1 tile and then using those results, I optimise a 1x2 tile and so on, until I find the optimal solution for the 5x5 tile. Using such a method, we can solve pretty large problem instances in a reasonable amount of time.

Based on a lot of research, there are many interesting ways in which we can make the code even faster. One of the optimizations that I am using is discretization points [1] which preserves the optimality of the solution. These points are the only points where you can cut the tile and so, obviously, you need to only consider these points. With respect to the earlier example, we actually don't need to consider the 1x1 tile sub-problem because it is never possible to have any rectangles in such a small tile. So, using this optimisation, we only need to consider a tiles with dimensions like 2x3 or 2x4.

Besides the rectangular knapsack (found in rk.m), I also consider the same problem allowing for rotation and allowing for staged cutting. All the code can be found here and the instructions to use the functions can be found in readme.rtf.

[1] Based on ideas in Algorithms for two-dimensional cutting stock and strip packing problems using dynamic programming and column generation by G.F. Cintra, F.K. Miyazawa, Y. Wakabayashi, E.C. Xavier

S=$latex \int_a^b \sqrt{(1+(dy/dx)^2} dx $

Now how do we find the length of a curve in MATLAB.

Let us do this via an example. Assume one asked you to find the length of $latex x^2*sin(x) $ from Π to 2Π. In the book, How People Learn, the authors mention that learning a concept in multiple contexts prolongs retention. Although it may not be the context that the authors of the book are talking about, let us find the length of the curve multiple ways within MATLAB. Try the program for functions and limits of your own choice to evaluate the difference.

METHOD 1: Use the formula S=$latex \int_a^b \sqrt{(1+(dy/dx)^2} dx $ by using the diff and int function of MATLAB

METHOD 2: Generate several points between a and b, and join straight lines between consecutive data points. Add the length of these straight lines to find the length of the curve.

METHOD 3. Find the derivative dy/dx numerically using forward divided difference scheme, and then use trapezoidal rule (trapz command in MATLAB) for discrete data with unequal segments to find the length of the curve.

QUESTIONS TO BE ANSWERED:

1. Why does METHOD 3 giving inaccurate results? Can you make them better by using better approximations of derivative like central divided difference scheme?
2. Redo the problem with f(x)=$latex x^{\frac{3}{2}} $ with a=1 and b=4 as the exact length can be found for such a function.

% Simulation : Find length of a given Curve
% Language : Matlab 2007a
% Authors : Autar Kaw
% Last Revised : June 14 2008
% Abstract: We are finding the length of the curve by three different ways
% 1. Using the formula from calculus
% 2. Breaking the curve into bunch of small straight lines
% 3. Finding dy/dx of the formula numerically to use discrete function
% integration
clc
clear all

disp('We are finding the length of the curve by three different ways')
disp('1. Using the formula from calculus')
disp('2. Breaking the curve into bunch of small straight lines')
disp('3. Finding dy/dx of the formula numerically to use discrete function integration')

%INPUTS - this is where you will change input data if you are doing
% a different problem
syms x;
% Define the function
curve=x^2*sin(x)
% lower limit
a=pi
% b=upper limit
b=2*pi
% n = number of straight lines used to approximate f(x) for METHOD 2
n=100
%p = number of discrete data points where dy/dx is calculated for METHOD 3
p=100

% OUTPUTS
% METHOD 1. Using the calculus formula
% S=int(sqrt(1+dy/dx^2),a,b)
% finding dy/dx
poly_dif=diff(curve,x,1);
% applying the formula
integrand=sqrt(1+poly_dif^2);
leng_exact=double(int(integrand,x,a,b));
fprintf ('\nExact length =%g',leng_exact)
%***********************************************************************

% METHOD 2. Breaking the curve as if it is made of small length
% straight lines
% Generating n x-points from a to b

xi= a:(b-a)/n:b;
% generating the y-values of the function
yi=subs(curve,x,xi);
% assuming that between consecutive data points, the
% curve can be approximated by linear splines.
leng_straight=0;
m=length(xi);
% there are m-1 splines for m points
for i=1:1:m-1
dx=xi(i+1)-xi(i);
dy= yi(i+1)-yi(i);
leneach=sqrt(dx^2+dy^2);
leng_straight=leng_straight+leneach;
end
fprintf ('\n\nBreaking the line into short lengths =%g',leng_straight)

% METHOD 3. Same as METHOD1, but calculating dy/dx
% numerically and integrating using trapz
xi=a:(b-a)/p:b;
% generating the dy/dx-values
m=length(xi);
for i=1:1:m-1
numer=yi(i+1)-yi(i);
den=xi(i+1)-xi(i);
dydxv(i)=numer/den;
end
% derivative at last point using Backward divided difference formula
% is same as Forward divided difference formula
dydxv(m)=dydxv(m-1);
integrandi=sqrt(1+dydxv.*dydxv);
length_fdd=trapz(xi,integrandi);
disp(' ')
disp(' ')
disp ('Using numerical value of dy/dx coupled')
disp ('with discrete integration')
fprintf (' =%g',length_fdd)

This post is brought to you by Holistic Numerical Methods: Numerical Methods for the STEM undergraduate at http://numericalmethods.eng.usf.edu

Anyway, the current plan is as follows:

Find the 2D smooth surface
Find the 3D smooth surface

Compare the results to see how much is the difference in voids matter for the calculation of porosity

Available sources: gridfit in Matlab, Surface generation packages in LIDAR GRASS. FastRBF is no longer in development and is not open source. However, is downloadable and provides promising results.

Fitting Smooth Surfaces to Dense Polygon Meshes.pdf

Fitting Manifold Surfaces To 3D Point Clouds.pdf: "In general, parametric curve and surface fitting to irregular data can be formulated as a non-linear least squares problem..."

spline surfaces and curves, where Bézier splines are required to interpolate certain control points, while B-splines are not.

In this post I am showing you a MATLAB program that will allow you to experiment by changing the number of data points you choose, that is, the value of n (see the input highlighted in red in the code - this is the only line you want to change) and see for yourself why high order interpolation is a bad idea. Just, cut and paste the code below (or download it from http://www.eng.usf.edu/~kaw/download/runge.m) in the MATLAB editor and run it.

% Simulation : Higher Order Interpolation is a Bad Idea

% Language : Matlab r12
% Authors : Autar Kaw
% Last Revised : June 10 2008
% Abstract: In 1901, Carl Runge published his work on dangers of high order
% interpolation. He took a simple looking function f(x)=1/(1+25x^2) on
% the interval [-1,1]. He took points equidistantly spaced in [-1,1]
% and interpolated the points with polynomials. He found that as he
% took more points, the polynomials and the original curve differed
% even more considerably. Try n=5 and n=25
clc
clear all
clf

disp('In 1901, Carl Runge published his work on dangers of high order')
disp('interpolation. He took a simple looking function f(x)=1/(1+25x^2) on')
disp('the interval [-1,1]. He took points equidistantly spaced in [-1,1]')
disp('and interpolated the points with a polynomial. He found that as he')
disp('took more points, the polynomials and the original curve differed')
disp('even more considerably. Try n=5 and n=15')

%
% INPUT:
% Enter the following
% n= number of equidisant x points from -1 to +1
n=15;

% SOLUTION
disp(' ')
disp('SOLUTION')
disp('Check out the plots to appreciate: High order interpolation is a bad idea')
fprintf('\nNumber of data points used =%g',n)
% h = equidisant spacing between points
h=2.0/(n-1);
syms xx
% generating n data points equally spaced along the x-axis
% First data point
x(1)=-1;
y(1)=subs(1/(1+25*xx^2),xx,-1);
% Other data points
for i=2:1:n
x(i)=x(i-1)+h;
y(i)=subs(1/(1+25*xx^2),xx,x(i));
end

% Generating the (n-1)th order polynomial from the n data points
p=polyfit(x,y,n-1);

% Generating the points on the polynomial for plotting
xpoly=-1:0.01:1;
ypoly=polyval(p,xpoly);

% Generating the points on the function itself for plotting
xfun=-1:0.01:1;
yfun=subs(1/(1+25*xx^2),xx,xfun);

% The classic plot
% Plotting the points
plot(x,y,'o','MarkerSize',10)
hold on
% Plotting the polynomial curve
plot(xpoly,ypoly,'LineWidth',3,'Color','Blue')
hold on
% Plotting the origianl function
plot(xfun,yfun,'LineWidth',3,'Color','Red')
hold off
xlabel('x')
ylabel('y')
title('Runges Phenomena Revisited')
legend('Data points','Polynomial Interpolant','Original Function')
%***********************************************************************
disp(' ')
disp(' ')
disp('What you will find is that the polynomials diverge for')
disp('0.726<|x|<1. If you started to choose same number of points ')
disp('but more of them close to -1 and +1, you would avoid such divergence. ')
disp(' ')
disp('However, there is no general rule to pick points for a general ')
disp('function so that this divergence is avoided; but some rules do exist for ')
disp('certian types of functions.')

This post is brought to you by Holistic Numerical Methods: Numerical Methods for the STEM undergraduate at http://numericalmethods.eng.usf.edu

Install normally following the documentation, even if it doesn't ask for symbolic links. Then go to the installation directory (/usr/local/matlab in my case):

./install_matlab -glnx

Answer 'y' to all questions and keep the suggestions (this takes care of the license stuff). In the same directory as the matlab file (e.g. /usr/local/matlab/bin/) create a file (I called it matlab2 -- you can call it matlab2.sh). In this file write

export AWT_TOOLKIT=3DMToolkit
/usr/local/matlab/bin/matlab

Now in the terminal type (still within /usr/local/matlab/bin/)

chmod 755 matlab2

Finally, start Matlab by doing

./matlab2

Iterative Methods for Optimization: Matlab Codes

จดไว้ใช้ยามยาก

ทางเลือกหนึ่งคือใช้ฟังก์ชัน fndir ซึ่งมากับ Spline Toolbox อันนี้ไม่ค่อยอยากใช้นักเพราะว่า
เครื่องที่บ้านไม่มี Toolbox อันนี้ (เวอร์ชันนักเรียน) ต้องไปใช้ที่ห้องทำงาน อีกทางเลือกหนึ่ง
ดูเป็นเรื่องทั่วไปกว่า โดยการใช้ Automatic Numerical Differentiation ของคุณ John
 D'Errico ซึ่งยังไม่รู้ว่าดีแค่ไหน

ตัวผมเองไม่ได้สนใจศึกษาเรื่อง Numerical Computing เลย จนหลัง ๆ อ่านมากชักจะชอบ
ไปเจอบทเรียน Numerical Methods in Mechanics ของ Lund University ก็ขอจดไว้
หน่อย รหัสต้นข้างล่างนี้ลอกมาแปะไว้เลย ตัวฟังก์ชันชื่อ jacobian ก็ควรจะเปลี่ยนนะครับเพราะ
ไปซ้ำกับ jacobian แบบ symbolic ของ MATLAB เค้า

function [J]=jacobian(func,x)
% computes the Jacobian of a function
n=length(x);
fx=feval(func,x);                                         %บรรทัดนี้คือการคำนวณค่าฟังก์ชันที่ x
eps=1.e-8; % could be made better
xperturb=x;
for i=1:n
   xperturb(i)=xperturb(i)+eps;
   J(:,i)=(feval(func,xperturb)-fx)/eps;     %อันนี้คือการหาค่าอนุพันธ์
   xperturb(i)=x(i);
end;

 

น่าสนุกดีเหมือนกัน

[sourcecode language='cpp']

function [Vx,Vy] = OpticalFlow(images,alpha,iterations)
%// Calculating optical flow of a sequence of images.
%// images : 3D array that contains a sequence of images. size of images is (imageHeight, imageWidth, frame number)
%// alpha
%// iterations.
[height,width,frames]=size(images);

%//initialzation of u and v
Vx = zeros(height,width);
Vy = zeros(height,width);

for k = 1:frames-1

% //initialization of Ex Ey and Et
Ex = zeros(height-1,width-1,frames-1);
Ey = zeros(height-1,width-1,frames-1);
Et = zeros(height-1,width-1,frames-1);

%//calculating Ex Ey and Et in frame k.
for x = 2:width-1
for y = 2:height-1
Ex(y,x,k) = (images(y+1,x+1,k)-images(y+1,x,k)+images(y,x+1,k)...
-images(y,x,k)+images(y+1,x+1,k+1)-images(y+1,x,k+1)...
+images(y,x+1,k+1)-images(y,x,k+1))/4;

Ey(y,x,k) = (images(y,x,k)-images(y+1,x,k)+images(y,x+1,k)...
-images(y+1,x+1,k)+images(y,x,k+1)-images(y+1,x,k+1)...
+images(y,x+1,k+1)-images(y+1,x+1,k+1))/4;

Et(y,x,k) = (images(y+1,x,k+1)-images(y+1,x,k)+images(y,x,k+1)...
-images(y,x,k)+images(y+1,x+1,k+1)-images(y+1,x+1,k)...
+images(y,x+1,k+1)-images(y,x+1,k))/4;
end
end

for nn = 1:iterations
for x = 2:width-1
for y = 2:height-1

Vxbar = (Vx(y-1,x)+Vx(y,x+1)+Vx(y+1,x)+Vx(y,x-1))/6+...
(Vx(y-1,x-1)+Vx(y-1,x+1)+Vx(y+1,x+1)+Vx(y+1,x-1))/12;

Vybar = (Vy(y-1,x)+Vy(y,x+1)+Vy(y+1,x)+Vy(y,x-1))/6+...
(Vy(y-1,x-1)+Vy(y-1,x+1)+Vy(y+1,x+1)+Vy(y+1,x-1))/12;

%// chapter 12 of Horn's paper
temp = (Ex(y,x,k)*Vxbar+Ey(y,x,k)*Vybar+Et(y,x,k))/(alpha^2 + Ex(y,x,k)^2 + Ey(y,x,k)^2);
%// update u and v
Vx(y,x) = Vxbar-Ex(y,x,k)*temp;
Vy(y,x) = Vybar-Ey(y,x,k)*temp;
end
end
end

end

[/sourcecode]

patch(x,y,c)

d'autres options peuvent être ajoutées (voir doc).

fileName est le fichier vers lequel on veut exporter les champs scalarToExport (ex: temperature)

Ensuite sous Matlab, on va construire les vecteurs qui permettront la visualisation:

file = fopen('fileName');
fgetl(file); %passer la première ligne qui reprend les intitulés
readed = fscanf(file,'%g',[nbScalars+3 inf]); %stocke les scalaires ainsi que les                                                  %infos de maillages
x = readed(2,:);
y = readed(3,:);
scalars = readed(4:end,:);

print('-dpng','-r100',filename); %export la figure en png résolution 100
clf reset; %annule la figure


set (0, 'defaulttextfontname', 'Terminus,16');

%% Maclaurin's trisectrix
figure(1)

phi = -3*pi/2 : .2 : 3*pi/2;
alpha = pi;
r = alpha ./ cos(phi/3);


subplot(1,2,1)
plot(phi,r,'-r')
title('rectangular coordinates')
axis([-2*pi 2*pi 0 10*pi])
xlabel('\phi')
ylabel('r')
grid on

subplot(1,2,2)
polar(phi,r,'-b')
title('polar coordinates')
axis([-5*pi 5*pi -5*pi 5*pi])
xlabel('\phi')
ylabel('r')
grid on

%% nonlinear equations

figure(2)

% 3x^5 - 8x^3 - 18x^2 + 2 = 0
subplot(3,1,1)
x = -3:0.1:3;
y = 3*x.^5 - 8*x.^3 - 18*x.^2 + 2;
plot(x,y,"-r;3x^5 - 8x^3 - 18x^2 + 2 = 0;")
axis([-3 3 -3 3])

Y = [3 0 -8 -18 0 2]
roots(Y)

hold on
plot(roots(Y), '*b')
hold off

grid on

% 5^x = 2 + e^{-2x}
subplot(3,1,2)
x = -8:0.01:10;
y = 5.^x - 2 - exp(-2*x);
plot(x,y,"-b;5^x = 2 + e^{-2x};")
axis([-4 5 -10 10])
grid on

% x^3+y^3=8 y=1+x^{3/2}
subplot(3,1,3)
x = -5:0.001:5;
y1 = (8-x.^3).^(1/3);
y2 = 1+x.^(3/2);
plot(x,y1,"-b;x^3+y^3=8;", x, y2, "-r;y=1+x^{3/2};")
axis([-2 5 0 10])
grid on

%% elliptic paraboloid

% \frac{y^2}p + \frac{z^2}q = 2x
figure

a=4;
b=20;
u = (0:0.05:5)';
v = [0:0.05*pi:2*pi];
X = a*sqrt(u)*cos(v);
Y = b*sqrt(u)*sin(v);
Z = u*ones(size(v));
surf(X,Y,Z);

shading interp
colormap pink