Cours Web

Licence de Mathématiques.
Mathématiques du Web.

c
Pascal Azerad
28 mars 2014
2
Table des matières
1 Le réseau : un graphe gigantesque. 7

1.1 Google : la légende. . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Le graphe du web . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3 Exploration du web . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.1 un programme MATLAB. . . . . . . . . . . . . . . . . 10
1.4 TP1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2 Modélisation de grands ensembles de documents pour la re-

cherche d’information 21
2.1 Indexation du web ou d’une base de donnée. . . . . . . . . . . 21
2.2 Modélisation par espace vectoriel. . . . . . . . . . . . . . . . . 23
2.3 La décomposition de valeur singulière : un outil puissant pour
l’indexation sémantique latente. . . . . . . . . . . . . . . . . . 25
2.4 Un peu d’algèbre linéaire. . . . . . . . . . . . . . . . . . . . . 25
2.5 TD autour de la décomposition de valeurs singulières. . . . . . 32
2.6 TP 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3 Le moteur de recherche Google et le page ranking. 37

3.1 L’équation du PageRank . . . . . . . . . . . . . . . . . . . . . 37
3.1.1 Traduction matricielle. . . . . . . . . . . . . . . . . . . 38
3.2 L’algorithme page rank. . . . . . . . . . . . . . . . . . . . . . 39
3.2.1 modification de la matrice H . . . . . . . . . . . . . . . 39
3.2.2 Le choix de α . . . . . . . . . . . . . . . . . . . . . . . 44
3.2.3 TD 4 : sensibilité du page rank vis à vis du paramètre α. 44
3.2.4 Point de vue spectral : puissance de matrice et valeurs
propres. . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.2.5 Résolution directe du système linéaire . . . . . . . . . . 51
3.3 TD. Introduction aux chaînes de Markov. . . . . . . . . . . . . 52
3.4 TP4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.5 TP4 (variante) . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.5.1 Promenade aléatoire sur le Web. . . . . . . . . . . . . . 55
3
4 TABLE DES MATIÈRES
3.6 un programme MATLAB. . . . . . . . . . . . . . . . . . . . . 55
4 Résumé MATLAB. 57
TABLE DES MATIÈRES 5
Préambule
Ce fascicule volontairement succinct poursuit les buts suivants :

– être assimilable par un étudiant de licence en sept séances.
– montrer une application récente et enthousiasmante des mathématiques.
Ce document est une première version, l’auteur est très reconnaissant pour
toute erreur, coquille ou commentaire qu’on voudra bien lui adresser à
azerad@math.univ-montp2.fr
6 TABLE DES MATIÈRES
Chapitre 1
Le réseau : un graphe
gigantesque.
1.1 Google : la légende.

Ce qui suit est extrait de de Wikipedia :
Google began in March 1996 as a research project by Larry Page and Sergey
Brin, Ph.D. students at Stanford working on the Stanford Digital Library
Project (SDLP). The SDLP’s goal was « to develop the enabling technologies
for a single, integrated and universal digital library. » and was funded through
the National Science Foundation among other federal agencies. In search
for a dissertation theme, Page considered, among other things, exploring
the mathematical properties of the World Wide Web, understanding its link
structure as a huge graph. His supervisor Terry Winograd encouraged him
to pick this idea (which Page later recalled as « the best advice I ever got »)
and Page focused on the problem of finding out which web pages link to
a given page, considering the number and nature of such backlinks to be
valuable information about that page (with the role of citations in academic
publishing in mind). In his research project,nicknamed « BackRub » he was
soon joined by Sergey Brin, a fellow Stanford Ph.D. student supported by a
National Science Foundation Graduate Fellowship. Brin was already a close
friend, whom Page had first met in the summer of 1995 in a group of potential
new students which Brin had volunteered to show around the campus. Page’s
web crawler began exploring the web in March 1996, setting out from Page’s
own Stanford home page as its only starting point. To convert the backlink
data that it gathered into a measure of importance for a given web page,
Brin and Page developed the PageRank algorithm. Analyzing BackRub’s
output, which, for a given URL, consisted of a list of backlinks ranked by
7
8 CHAPITRE 1. LE RÉSEAU : UN GRAPHE GIGANTESQUE.
importance, it occurred to them that a search engine based on PageRank

would produce better results than existing techniques (existing search engines
at the time essentially ranked results according to how many times the search
term appeared on a page). . .
Convinced that the pages with the most links to them from other highly
relevant Web pages must be the most relevant pages associated with the
search, Page and Brin tested their thesis as part of their studies, and laid the
foundation for their search engine. By early 1997, the backrub page described
the state as follows :
Some Rough Statistics (from August 29th, 1996) Total indexable HTML
urls : 75.2306 Million Total content downloaded : 207.022 gigabytes
BackRub is written in Java and Python and runs on several Sun Ultras and
Intel Pentiums running Linux. The primary database is kept on an Sun Ultra
II with 28GB of disk. Scott Hassan and Alan Steremberg have provided a
great deal of very talented implementation help. Sergey Brin has also been
very involved and deserves many thanks.
Larry Page page@cs.stanford.edu
Originally the search engine used the Stanford website with the domain
google.stanford.edu. The domain google.com was registered on September
15, 1997. They formally incorporated their company, Google Inc., on Sep-
tember 4, 1998 at a friend’s garage in Menlo Park, California.
The name « Google » originated from a misspelling of « googol, » which refers
to the number represented by a 1 followed by one-hundred zeros (although
Enid Blyton used the phrase « Google Bun » in The Magic Faraway Tree
(published 1941). Having found its way increasingly into everyday language,
the verb, « google » was added to the Merriam Webster Collegiate Dictionary
and the Oxford English Dictionary in 2006, meaning, « to use the Google
search engine to obtain information on the Internet. » Google Home Page
September 1998
By the end of 1998, Google had an index of about 60 million pages. The home
page was still marked « BETA », but an article in Salon.com already argued
that Google’s search results were better than those of competitors like Hot-
bot or Excite.com, and praised it for being more technologically innovative
than the overloaded portal sites (like Yahoo !, Excite.com, Lycos, Netscape’s
Netcenter, AOL.com, Go.com and MSN.com) which at that time, during the
growing dot-com bubble, were seen as « the future of the Web », especially
by stock market investors.
In March 1999, the company moved into offices at 165 University Avenue in
Palo Alto, home to several other noted Silicon Valley technology startups.
After quickly outgrowing two other sites, the company leased a complex of
buildings in Mountain View at 1600 Amphitheatre Parkway from Silicon
1.2. LE GRAPHE DU WEB 9
Figure 1.1 – taille du web, d’apres le site wordwidewebsize.com
Graphics (SGI) in 2003. The company has remained at this location ever
since, and the complex has since become known as the Googleplex (a play
on the word googolplex, a number that is equal to 1 followed by a googol of
zeros). In 2006, Google bought the property from SGI for 319 million.
Google’s declared code of conduct is « Don’t be evil », a phrase which they
went so far as to include in their prospectus, noting, « We believe strongly
that in the long term, we will be better served, as shareholders and in all
other ways, by a company that does good things for the world even if we
forgo some short term gains. » Vous pouvez regarder sur Youtube une video
de Serguei Brin devant des étudiants de l’Université de Berkeley.
1.2 Le graphe du web

La taille du web est gigantesque et en perpétuelle évolution. Pour une es-
timation à jour le nombre de pages indexées par les moteurs de recherche,
voir le site http://www.worldwidewebsize.com/. A la date 10 mars 2010,
il y avait au moins 20.109 pages web. A la date du 16 mars 2011, il y avait
au moins 25.109 pages web, à la date du 21 mars 2012 il y en aurait environ
50 · 109 indexées par Google, voir figure 1.1. . . A la date du 8 avril 2013,
dernière mise à jour de ce poly, la taille est à peu près la même qu’en 2012,
le web semble avoir atteint sa taille stationnaire voir figure 1.2. . .
Figure 1.2 – taille du web, début 2013 d’après le site wordwidewebsize.com
1.3 Exploration du web

Nous allons construire en TP une sous-matrice de la matrice totale.., res-
treinte au web du site du departement de math, par exemple et ou tous les
liens sortants vers l’exterieur seront regroupe vers un site fictif. Il y a un
algorithme en matlab qui sait faire le crawl.
1.3.1 un programme MATLAB.
function [U,G] = surfer(root,n)

% SURFER Create the adjacency graph of a portion of the Web.
% [U,G] = surfer(root,n) starts at the URL root and follows
% Web links until it forms an adjacency graph with n nodes.
% U = a cell array of n strings, the URLs of the nodes.
% G = an n-by-n sparse matrix with G(i,j)=1 if node j is linked to node i.
%
% Example: [U,G] = surfer(’http://www.harvard.edu’,500);
% See also PAGERANK.
%
% This function currently has two defects. (1) The algorithm for
% finding links is naive. We just look for the string ’http:’.
% (2) An attempt to read from a URL that is accessible, but very slow,
1.3. EXPLORATION DU WEB 11
% might take an unacceptably long time to complete. In some cases,

% it may be necessary to have the operating system terminate MATLAB.
% Key words from such URLs can be added to the skip list in surfer.m.
% Initialize
clf
shg
set(gcf,’doublebuffer’,’on’)
axis([0 n 0 n])
axis square
axis ij
box on
set(gca,’position’,[.12 .20 .78 .78])
uicontrol(’style’,’frame’,’units’,’normal’,’position’,[.01 .09 .98 .07]);
uicontrol(’style’,’frame’,’units’,’normal’,’position’,[.01 .01 .98 .07]);
t1 = uicontrol(’style’,’text’,’units’,’normal’,’position’,[.02 .10 .94 .04], ...
’horiz’,’left’);
t2 = uicontrol(’style’,’text’,’units’,’normal’,’position’,[.02 .02 .94 .04], ...
’horiz’,’left’);
slow = uicontrol(’style’,’toggle’,’units’,’normal’, ...
’position’,[.01 .24 .07 .05],’string’,’slow’,’value’,0);
quit = uicontrol(’style’,’toggle’,’units’,’normal’, ...
’position’,[.01 .17 .07 .05],’string’,’quit’,’value’,0);
U = cell(n,1);
hash = zeros(n,1);
G = logical(sparse(n,n));
m = 1;
U{m} = root;
hash(m) = hashfun(root);
j = 1;
while j < n & get(quit,’value’) == 0
% Try to open a page.
try
set(t1,’string’,sprintf(’%5d %s’,j,U{j}))
set(t2,’string’,’’);
drawnow
page = urlread(U{j});
catch
set(t1,’string’,sprintf(’fail: %5d %s’,j,U{j}))
drawnow
continue
end
if get(slow,’value’)
pause(.25)
end
% Follow the links from the open page.
for f = findstr(’http:’,page);
% A link starts with ’http:’ and ends with the next quote.
e = min([findstr(’"’,page(f:end)) findstr(’’’’,page(f:end))]);
if isempty(e), continue, end
url = deblank(page(f:f+e-2));
url(url<’ ’) = ’!’; % Nonprintable characters
if url(end) == ’/’, url(end) = []; end
% Look for links that should be skipped.
skips = {’.gif’,’.jpg’,’.pdf’,’.css’,’lmscadsi’,’cybernet’, ...

’search.cgi’,’.ram’,’www.w3.org’, ...
’scripts’,’netscape’,’shockwave’,’webex’,’fansonly’};
skip = any(url==’!’) | any(url==’?’);
k = 0;
while ~skip & (k < length(skips))
k = k+1;
skip = ~isempty(findstr(url,skips{k}));
end
if skip
if isempty(findstr(url,’.gif’)) & isempty(findstr(url,’.jpg’))
set(t2,’string’,sprintf(’skip: %s’,url))
drawnow
pause(.25)
end
end
1.3. EXPLORATION DU WEB 13
continue
end
% Check if page is already in url list.
i = 0;
for k = find(hash(1:m) == hashfun(url))’;
if isequal(U{k},url)
i = k;
break
end
end
% Add a new url to the graph there if are fewer than n.
if (i == 0) & (m < n)
m = m+1;
U{m} = url;
hash(m) = hashfun(url);
i = m;
end
% Add a new link.
if i > 0
G(i,j) = 1;
set(t2,’string’,sprintf(’%5d %s’,i,url))
line(j,i,’marker’,’.’,’markersize’,6)
drawnow
pause(.25)
end
end
end
j = j+1;
end
delete(t1)
delete(t2)
delete(slow)
set(quit,’string’,’close’,’callback’,’close(gcf)’,’value’,0)
%------------------------
function h = hashfun(url)
% Almost unique numeric hash code for pages already visited.
h = length(url) + 1024*sum(url);
1.4 TP1
le but de ce TP est d’apprendre les rudiments de MATLAB et de construire
le graphe d’une portion du web, ainsi que la matrice correspondante.
1. récuperer le fichier surfer.m sur l’espace pédagogique.
2. créer un répertoire mathduweb sur votre compte et y placer le fichier
surfer.m
3. ouvrir un terminal et lancer MATLAB : matlab &
4. lancer les demos de matlab intitulées : Basic Matrix Operations, Matrix
Manipulations pour vous familiariser un peu avec MATLAB. Ne pas
viser une connaissance exhaustive d’emblée. Nous apprendrons peu à
peu.
Nous allons utiliser le programme surfer.m pour créer le graphe d’une por-
tion du web. Le programme surfer(’racine’,n) part d’un site ’racine’ et
explore le web à partir de ce site, jusqu’à ce qu’il ait trouvé n sites distincts.
Ce qui suit reproduit la session matlab.
>> [U,G]=surfer(’http://www.math.univ-montp2.fr’,20);
>> U
U =
’http://www.math.univ-montp2.fr’
’http://www.univ-montp2.fr’
’http://www.cnrs.fr/languedoc-roussillon’
’http://ens.math.univ-montp2.fr/SPIP/Enseignement’
’http://ens.math.univ-montp2.fr/SPIP/I3M-UMR-5149’
’http://ens.math.univ-montp2.fr/SPIP/D’
1.4. TP1 15
’http://www.math.univ-montp2.fr/frontweb’
’http://ens.math.univ-montp2.fr/SPIP/auteur.php3’
’http://www.irem.univ-montp2.fr’
’http://ens.math.univ-montp2.fr/contacts.php’
’http://ens.math.univ-montp2.fr/adresse.php’
’http://ens.math.univ-montp2.fr/informatique’
’http://ens.math.univ-montp2.fr/informatique/intraweb.php’
’http://www.math.univ-montp2.fr/index_en.php’
’http://www.cnrs.fr’
’http://www.ufr.univ-montp2.fr’
’http://www.polytech.univ-montp2.fr’
’http://www.iutmontp.univ-montp2.fr’
’http://www.iut-nimes.fr’
’http://www.unimes.fr’
>> G
G =
(1,1) 1
(2,1) 1
(3,1) 1
(4,1) 1
(5,1) 1
(6,1) 1
(7,1) 1
(8,1) 1
(9,1) 1
(10,1) 1
(11,1) 1
(12,1) 1
(13,1) 1
(14,1) 1
(15,1) 1
(16,1) 1
(17,1) 1
(18,1) 1
(19,1) 1
(20,1) 1
(16,2) 1
(18,2) 1
(19,2) 1
(15,3) 1
(1,4) 1
(2,4) 1
(4,4) 1
(7,4) 1
(9,4) 1
(16,4) 1
(1,5) 1
(2,5) 1
(3,5) 1
(4,5) 1
(7,5) 1
(9,5) 1
(15,5) 1
(1,6) 1
(2,6) 1
(4,6) 1
(7,6) 1
(9,6) 1
(15,6) 1
(16,6) 1
(1,7) 1
(1,8) 1
(2,8) 1
(3,8) 1
(4,8) 1
(7,8) 1
(9,8) 1
(15,8) 1
(2,9) 1
(1,10) 1
(2,10) 1
(3,10) 1
(4,10) 1
(5,10) 1
(6,10) 1
(7,10) 1
(8,10) 1
(9,10) 1
(10,10) 1
1.4. TP1 17
(11,10) 1
(12,10) 1
(13,10) 1
(14,10) 1
(15,10) 1
(16,10) 1
(17,10) 1
(18,10) 1
(19,10) 1
(20,10) 1
(1,11) 1
(2,11) 1
(3,11) 1
(4,11) 1
(5,11) 1
(6,11) 1
(7,11) 1
(8,11) 1
(9,11) 1
(10,11) 1
(11,11) 1
(12,11) 1
(13,11) 1
(14,11) 1
(15,11) 1
(16,11) 1
(17,11) 1
(18,11) 1
(19,11) 1
(20,11) 1
(1,12) 1
(2,12) 1
(3,12) 1
(4,12) 1
(5,12) 1
(6,12) 1
(7,12) 1
(8,12) 1
(9,12) 1
(10,12) 1
(11,12) 1
(12,12) 1
(13,12) 1
(14,12) 1
(15,12) 1
(16,12) 1
(17,12) 1
(18,12) 1
(19,12) 1
(20,12) 1
(1,13) 1
(2,13) 1
(3,13) 1
(4,13) 1
(5,13) 1
(6,13) 1
(7,13) 1
(8,13) 1
(9,13) 1
(10,13) 1
(11,13) 1
(12,13) 1
(13,13) 1
(14,13) 1
(15,13) 1
(16,13) 1
(17,13) 1
(18,13) 1
(19,13) 1
(20,13) 1
(1,14) 1
(2,14) 1
(3,14) 1
(7,14) 1
(8,14) 1
(9,14) 1
(10,14) 1
(11,14) 1
(12,14) 1
(13,14) 1
(15,14) 1
(16,14) 1
1.4. TP1 19
(17,14) 1
(18,14) 1
(19,14) 1
(20,14) 1
(2,16) 1
(16,16) 1
(2,17) 1
(2,18) 1
(18,18) 1
(2,19) 1
(19,19) 1
>>
La figure 1 donne le profil de la matrice. On peut obtenir la profil d’une
matrice A par la commande spy(A) Essayer
>> A= ones(20,20);
>> spy(A)
Le nombre de coefficients non nuls est nz. Pour la matrice G, le nombre
de termes non nuls est faible par rapport au nombre total 400 = 20 × 20.
Ce fait est général, la matrice du web est creuse(beaucoup de termes sont
nuls). Vous pouvez essayer l’algorithme avec une autre racine, par exemple
’http ://www.montpellier.fr’ et n = 50. La matrice G obtenue est encore
creuse. Le programme s’arrête parfois, car certaines pages n’ont pas de liens
sortants et la navigation est alors bloquée (page sans issue.) Pour une grande
matrice, charger la matrice ’harvard500.mat’ de taille 500x500 ou bien té-
lécharger sur la plate-forme pédagogique mon.univ-montp2.fr, unité d’en-
seignement mathématiques du web, une matrice 1000x1000 obtenue par un
étudiant de 2009-2010, Bastien Vialla.
>> load(’harvard500.mat’);
>> size(U);
>>size(G);
>>spy(G);
A quoi correspond le résultat de la commande suivante ?

>> sum(G,2)
La portion du graphe du réseau explorée est-elle explorée en profondeur ou
en largeur ?
Chapitre 2
Modélisation de grands ensembles

de documents pour la recherche
d’information
Les notions vues dans ce chapitre s’applique indifféremment aux bases de

données et au réseau internet, le « web ».
2.1 Indexation du web ou d’une base de don-

née.
Lorsque on formule une requête sur un moteur de recherche sur le web ou dans
une base de donnée, les résultats sont souvent très nombreux et apparaissent
par ordre de pertinence décroissant. La pertinence mesure la proximité entre
les mots de la requête et les expressions trouvées dans les sites archivés par
Google. les robots Google (« googlebot ») parcourent sans arrêt le réseau à
la recherche de nouvelles pages. Ensuite chaque page trouvée est numérotée,
analysée, purifiée et indexée. L’analyse garde la trace des liens sortants dans
le graphe du web. La purification consiste d’une part à éliminer certains mots
(conjonctions, mots-valises, voir ftp://ftp.cs.cornell.edu/pub/smart/english.stop
pour une liste type en anglais ; a a’s able about above according accordingly across
actually after afterwards again against ain’t all allow allows almost alone along already
also although always am among amongst an and another any anybody anyhow anyone any-
thing anyway anyways anywhere apart appear appreciate appropriate are aren’t around
as aside ask asking associated at available away awfully b be became because become
becomes becoming been before beforehand behind being believe below beside besides best
better between beyond both brief but by c c’mon c’s came can can’t cannot cant cause
causes certain certainly changes clearly co com come comes concerning consequently consi-
21
22CHAPITRE 2. MODÉLISATION DE GRANDS ENSEMBLES DE DOCUMENTS POUR
der considering contain containing contains corresponding could couldn’t course currently
d definitely described despite did didn’t different do does doesn’t doing don’t done down
downwards during e each edu eg eight either else elsewhere enough entirely especially et
etc even ever every everybody everyone everything everywhere ex exactly example except f
far few fifth first five followed following follows for former formerly forth four from further
furthermore g get gets getting given gives go goes going gone got gotten greetings h had
hadn’t happens hardly has hasn’t have haven’t having he he’s hello help hence her here
here’s hereafter hereby herein hereupon hers herself hi him himself his hither hopefully
how howbeit however i i’d i’ll i’m i’ve ie if ignored immediate in inasmuch inc indeed
indicate indicated indicates inner insofar instead into inward is isn’t it it’d it’ll it’s its
itself j just k keep keeps kept know knows known l last lately later latter latterly least less
lest let let’s like liked likely little look looking looks ltd m mainly many may maybe me
mean meanwhile merely might more moreover most mostly much must my myself n name
namely nd near nearly necessary need needs neither never nevertheless new next nine no
nobody non none noone nor normally not nothing novel now nowhere o obviously of off
often oh ok okay old on once one ones only onto or other others otherwise ought our ours
ourselves out outside over overall own p particular particularly per perhaps placed please
plus possible presumably probably provides q que quite qv r rather rd re really reasonably
regarding regardless regards relatively respectively right s said same saw say saying says
second secondly see seeing seem seemed seeming seems seen self selves sensible sent serious
seriously seven several shall she should shouldn’t since six so some somebody somehow
someone something sometime sometimes somewhat somewhere soon sorry specified specify
specifying still sub such sup sure t t’s take taken tell tends th than thank thanks thanx that
that’s thats the their theirs them themselves then thence there there’s thereafter thereby
therefore therein theres thereupon these they they’d they’ll they’re they’ve think third
this thorough thoroughly those though three through throughout thru thus to together
too took toward towards tried tries truly try trying twice two u un under unfortunately
unless unlikely until unto up upon us use used useful uses using usually uucp v value va-
rious very via viz vs w want wants was wasn’t way we we’d we’ll we’re we’ve welcome well
went were weren’t what what’s whatever when whence whenever where where’s whereafter
whereas whereby wherein whereupon wherever whether which while whither who who’s
whoever whole whom whose why will willing wish with within without won’t wonder would
would wouldn’t x y yes yet you you’d you’ll you’re you’ve your yours yourself yourselves z
zero d’autre part à ne conserver que les racines des mots (en enlevant les pré-
fixes et suffixes). Cette étape s’appelle la lemmatisation.Ainsi, on ne conserve
que les mots importants (mots-clefs). Exemple : enseignement, enseignant,
enseignante, enseignants, enseigner, enseignent, sont représentés par un seul
terme enseigner. Cette étape est délicate à cause de la polysémie : le mot
enseigne par exemple peut avoir deux sens au moins. L’indexation consiste
alors à compter les fréquences et la position (comme la présence dans le titre,
dans les balises, . . . des mots-clefs dans la page. Finalement le web ou la base
2.2. MODÉLISATION PAR ESPACE VECTORIEL. 23
de documents est résumée dans trois fichiers :

– fichier des « documents ». A chaque document ou page est associé un nu-
méro j variant de 1 à p. le document dj est alors enregistré sous forme
purifiée 1
– dictionnaire des termes ou des mots. Tous les termes du web purifié sont
répertoriés (avec leur fréquence). A chaque mot est associé un numéro i
variant de 1 à m.
– liste inversée. A chaque mot ou terme du dictionnaire, on associe les nu-
méros des documents ou pages où il apparait, ainsi que la position, la
fréquence ou mieux le poids dans la page en question.
2.2 Modélisation par espace vectoriel.

Ceci peut se définir mathématiquement par un modèle de type espace vecto-
riel. A chaque page web trouvée par un googlebot, on attribue un numéro
unique i ∈ N. Chaque page trouvée est analysée et tous les mots principaux
sont également numérotés (on ignore les mots comme les articles ’le’, ’la’, les
conjonctions ’et’, ’ou’, les espaces ’ ’, les caractères de ponctuation ’ ;’,. . . )
Puis les termes ou mots principaux sont repertoriés dans un annuaire in-
versé. Typiquement si le mot numéro 10 est « enfant », on aura dans cet
annuaire la liste de tous les numéros des pages webs qui contiennent le mot
« enfant ». Une immense matrice A terme X page ou terme X document, de
taille m×p, où m est le nombre de mots du dictionnaire purifié et p le nombre
de pages web repertoriées : ai,j = nombre de fois 2 où le terme i apparaît dans
la page j.
Pour donner un ordre de grandeur, le nombre de mots du plus grand diction-
naire anglais est environ 300000, supposons qu’après nettoyage et purification
il n’en reste que m = 100000. Le nombre de site est d’environ p = 20·109 . 3 La
matrice A est gigantesque, pour la stocker il faut a priori 100000 × 20 · 109 =
2 · 1015 octets, autrement dit 2000 Teraoctets. . . Heureusement la plupart des
coefficients de cette matrice sont nuls, car un site ne contient en général qu’un
petit nombre de mot. On dit que la matrice A est creuse. On peut ne stocker
que les coefficients non nuls dans chaque colonne. Il existe des formats pra-
tiques pour cela (format sparse en MATLAB).
1. ou non selon la capacité de stockage des serveurs qui s’accroît constamment

2. Cette description est simplifiée. Les termes apparaissant dans les pages peuvent
figurer dans le titre, les balises, le texte simple. On peut attribuer un poids plus important
au terme selon les cas.
3. c’est une estimation basse du 10 mars 2010 d’après
http://www.worldwidewebsize.com/. Wikipedia donne 11.5 · 109 en 2005
Les colonnes de la matrice A correspondent aux différents sites du web. Les

lignes correspondent aux termes ou mots. Plus précisément l’espace vectoriel
engendré par les colonnes de A est un sev de Rm . L’espace vectoriel engendré
par les lignes de A est un sev de Rp .
Suposons qu’un utilisateur formule une requête sur un moteur de recherche

sous forme de la phrase « cours de ski pour enfants ». Tout d’abord les petits
mots, articles, conjonction et les caractères de ponctuation sont ignorés pour
extraire les principaux mots de la requête : cours, ski, enfants. La requête
correspond alors à un vecteur colonne q :
q = (0, . . . , 1, 0, . . . , 1, 0, . . . , 1, 0, . . .)T
dont tous les coefficients sont nuls sauf pour les indices correspondant à
l’indice de cours, enfant et ski. Ensuite il faut choisir parmi toutes les pages
web, celles qui sont le plus proche de la requête, les plus pertinentes. Pour
cela on calcule tout simplement l’angle
q T · Cj
cos θj = ∈ [0, 1]
||q||||Cj ||
entre la requête q et chaque colonne Cj de A. Remarquer que l’angle ou son
cosinus est une mesure qui ne dépend pas de la taille ou de la norme des deux
vecteurs requête q et colonne Cj . Une mesure, comme le produit scalaire par
exemple, qui dépendrait de la longueur de la requête ou de la taille de la
page ne serait pas fiable, c’est pourquoi il est nécessaire de renormaliser le
produit scalaire. Plus le cosinus est grand, plus le site j est pertinent vis à
vis de la requête. Cela permet de donner un score de pertinence. Lorsque le
cosinus est trop faible en dessous d’un certain seuil fixé a priori, le site est
jugé non pertinent. Dans l’espace vectoriel des colonnes, il y a donc un cône
limite de pertinence :
qT · x
{x, ≤ }
||q||||x||
Remarque. En Matlab, les vecteurs colonnes de A s’obtiennent aisément :

A(:,j) représente la j-ième colonne. De même A(i,:)représente la i-ième
ligne. 2
Cependant l’approche précédente est limitée par la polysémie. le même terme
peut désigner des choses très différentes : par exemple le mot avocat peut dé-
signer un fruit ou un homme de loi. . . Les exemples sont légion. La notion de
contexte est absente de la modélisation par espace vectoriel. On peut toute-
fois essayer des outils plus sophistiqué d’algèbre pour capturer l’information
sémantique latente. C’est le but de la prochaine section.
2.3. LA DÉCOMPOSITION DE VALEUR SINGULIÈRE : UN OUTIL PUISSANT POUR L’INDEXA
2.3 La décomposition de valeur singulière : un

outil puissant pour l’indexation sémantique
latente.
2.4 Un peu d’algèbre linéaire.
Théorème 1 Soit A une matrice m × p. Elle se factorise en
A = U ΣV T ,
où U matrice orthogonale m × m, V matrice orthogonale p × p et Σ matrice

rectangle m × p dont tous les termes extra diagonaux sont nuls.
 
σ1 0 . . . 0 0 . . . 0
. . . .. 
 0 σ2 . . .. .. . 

 . . . . .. 
 .. . . . . 0 .. . 
 
Σ =  0 . . . 0 σr 0 . . . 0 


 0 ... ... 0 0 ... 0 
 
 . . . .
. . . .

 . . . . 
0 ... ... 0 0 ... 0
Les termes diagonaux non nuls, rangés par ordre décroissant σ1 ≥ σ2 ≥ . . . ≥

σr > 0 sont les valeurs singulières de A. Ce sont les racines carrées positives
des valeurs propres de AT A (ou de AAT ), l’entier r désigne le rang de A.
Remarque. Dans le cas m = p, on retrouve la propriété qu’un matrice symé-

trique réelle se diagonalise dans une base orthonormée . 2
Preuve. Soit S = AT A matrice carrée p × p. La matrice S est symétrique :
S T = (AT A)T = AT (AT )T = AT A. Ainsi on peut la diagonaliser dans une
base orthonormée :
S = V DV T (2.1)
où D = diag(λ1 , λ2 , . . . , λp ) est la matrice diagonale des valeurs propres de
S rangées en ordre décroissant : λ1 ≥ λ2 ≥ . . . ≥ λp et où les colonnes de
V = [V1 , V2 , . . . , Vp ] constituent une base orthonormale de vecteurs propres
de S :
SVj = λj Vj ∀j = 1 . . . p
et
V T = V −1 .
(2.1) peut s’écrire aussi

 
λ1 0 ... 0
 0 λ2 ... 0 
SV =V 
 
.. .. .. .. 
 . . . . 
0 0 . . . λp
Remarquons que les valeurs propres de S sont positives. En effet
AT Ax = λx ⇒ xT AT Ax = λxt x
autrement dit
||Ax||2 = λ||x||2 ⇒ λ ≥ 0.
Soit r l’indice au delà duquel λj = 0. Les valeurs propres de S sont donc
λ1 ≥ λ2 ≥ . . . ≥ λr > 0 et λr+1 = λr+2 = . . . λp = 0. Pour 1 ≤ j ≤ r, on
définit les valeurs singulières p
σ j = λj
et on pose
1
Uj = A Vj
σj
Comme A est de format m × p et Vj est de format p × 1, Uj est de format
m × 1. C’est un vecteur colonne à m composantes. Montrons que les vecteurs
U1 , U2 , . . . Ur sont de norme unité et orthogonaux deux à deux :
1 1 1
||Uj ||2 = UjT Uj = (A Vj )T A Vj = 2 VjT AT A Vj
σj σj σj
1 T λj
= V λj Vj = 2 VjT Vj = ||Vj ||2 = 1.
2 j
σj σj
Pour i 6= j
1 1 1
< Uj , Ui >= UjT Ui = (A Vj )T A Vi = VjT (AT A) Vi
σj σi σi σj
1 λi T
= VjT λi Vi = V Vi = 0.
σi σj σi σj j
On dispose donc d’une famille orthonormée r vecteurs colonnes de Rm . On la
complète par m − r vecteurs pour avoir une base othonormée (U1 , U2 , . . . Um )
de Rm . Soit la matrice U = [U1 , U2 , . . . , Um ] dont les colonnes sont les Ui . La
matrice U est orthogonale :
U T = U −1 .
2.4. UN PEU D’ALGÈBRE LINÉAIRE. 27
Montrons finalement que
A = U ΣV T ⇔ AV = U Σ
où  
σ1 0 ... 0 0 ... 0
... .. .. .. 
0 σ2 . . . 


 .. .. .. .. .. 

 . . . 0 . . 
Σ=
 0 . . . 0 σr 0 ... 0  

 0 ... ... 0 0 ... 0  
 .. .. .. .. 
 . . . . 
0 ... ... 0 0 ... 0
est une matrice m × p.
Montrons que AV = U Σ colonne par colonne.
Pour j ≤ r, par définition de Uj , on a AVj = σj Uj et U Σj = σj Uj donne le
même résultat.
Pour j > r, Vj est vecteur propre de AT A pour λj = 0 i.e. AT AVj = 0 donc
VjT AT AVj = 0 ce qui s’écrit encore ||AVj ||2 = 0, ce qui implique AVj = 0 et
U Σj = 0 donne le même résultat.
Il reste à constater que r est exactement le rang de A puisque c’est la di-
mension de l’espace ImA engendré par U1 = AV1 , U2 = AV2 , . . . , Ur = AVr .
Exemple. Donnons quelques exemples.

     
2 0 0 1 0 3 0
 0 −3  =  −1 0 0  ·  0 2  · 0 1
1 0
0 0 0 0 1 0 0
Il faut faire attention au format des matrices :

     
−1 −1/3 2/3 2/3 3
 2  =  2/3 −1/3 2/3  ·  0 · 1
2 2/3 2/3 −1/3 0
Un dernier exemple :
√ √ √ 
√ √ √

1/√6 −2/ 6 1/√6
−1 1 0 −1/√2 1/√2 3 0 0 
= · · −1/√2 √0 1/√2

0 −1 1 1/ 2 1/ 2 0 1 0
1/ 3 1/ 3 1/ 3
Une conséquence immédiate du théorème précédent est la proposition.

Proposition 1 Cette décomposition SVD permet de connaître immédiate-

ment le rang r de A. De plus si on note U = (U1 , . . . , Um ), Uj désignant la
j e colonne de U et V = (V1 , . . . , Vp ), Vk désignant la k e colonne de V , on a
les résultats suivants :
1. (U1 , . . . , Ur ) est une base orthonormée de l’espace des colonnes de A
qui est aussi ImA.
2. (V1 , . . . , Vr ) est une base orthonormée de l’espace des lignes de A qui
est aussi Im(AT ).
3. (Ur+1 , . . . , Um ) est une base orthonormée de (ImA)⊥ = ker(AT ).
4. (Vr+1 , . . . , Vp ) est une base orthonormée de kerA.
Ainsi ou peut lire dans U et V les bases des 4 sous-espaces fondamentaux :
ImA, kerA, ImAT et kerAT .
la démonstration est demandée au TD qui suit.
Remarque. je vous suggère pour des complément d’algèbre linéaire, de voir
le livre de Strang [1] et aussi son cours en ligne gratuit sur le site du MIT :
http://ocw.mit.edu/courses/mathematics/18-06-linear-algebra-spring-2010/
également disponible sur YouTube ! Lecture 29 linear algebra. 2
Remarque. L’espace des colonnes est ImA, l’espace des lignes est ImAT .
Rappelons la propriété élémentaire : ImAT = (KerA)⊥
2
Remarque. Il est clair que la factorisation n’est pas unique, par exemple,
pour A = Id on a Id = QQT pour toutes les matrices orthogonales Q. De
même pour A orthogonale on peut écrire indifféremment A = Id · Id · Q ou
A = Q · Id · Id mais Σ = Id. Les valeurs singulières sont uniques. C’est
le même phénomène que la diagonalisation des matrices, les valeurs propres
sont uniques mais pas la base de vecteurs propres. 2
Il est aisé de prouver la propriété.
Propriété 1
kAxk
kAk = sup = σ1
x6=0 kxk
La norme d’une matrice est égale à sa plus grande valeur singulière.
Preuve. Donnons une preuve géométrique. Décomposons x suivant la base
orthonormale V1 , V2 , . . . Vp .
X
x= < x, Vi > Vi
1≤i≤p
Ainsi X X
Ax = < x, Vi > AVi = < x, Vi > σi Ui
1≤i≤p 1≤i≤r
!
X X
kAxk2 =< Ax, Ax >= σi2 < x, Vi >2 ≤ σ12 < x, Vi >2 = σ12 kxk2 .
1≤i≤r 1≤i≤r
D’où l’on tire

kAxk
∀x 6= 0, ≤ σ1 .
kxk
Enfin en prenant x := V1 on constate que σ1 est atteint.
Remarque. Ce fait permet de donner une interprétation géométrique simple

des valeurs singulières. Soit E = {Ax; kxk = 1}. L’ensemble E est l’image
par A de la sphère unité, c’est une « ellipsoïde ». Les valeurs singulières de A
sont les longueurs des demi-axes de E. Pour le prouver, il suffit de remarquer
que la sphère denrayon unité s’écrit simplement dans la base
o orthonormée des
2
P P
Vi comme S = x = 1≤i≤p αi Vi , tel que 1≤i≤p αi = 1 . Donc
( )
X X
E= y= αi σi Ui , avec αi2 = 1 .
1≤i≤r 1≤i≤p
Mais on peut poser yi = αi σi et alors deux cas se présentent.

– Si r = p ( )
X X y2
i
E= y= yi Ui , avec 2
=1
1≤i≤p
σ
1≤i≤p i
qui est bien l’équation d’un ellipsoïde de demi-axes σi dans la base ortho-
normée des Ui , 1 ≤ i ≤ p
– sinon r < p et
( )
X X y2
i
E= y= yi Ui , avec 2
≤1
1≤i≤r 1≤i≤r
σi
qui est bien l’équation du volume intérieur (en dimension r) de l’ellipsoïde

de demi-axes σi dans la base orthonormée des Ui , 1 ≤ i ≤ r.
2
Dans le cas des matrices carrées inversibles, les valeurs singulières servent
aussi à calculer le conditionnement.
Propriété 2 le conditionnement (pour la norme matricielle subordonnée à

la norme euclidienne) d’une matrice est donné
σmax
cond(A) =
σmin
où σmax (resp. σmin ) désigne la plus grande (resp. petite) valeur singulière de
la matrice.
Preuve. La norme d’une matrice est égale à sa plus grande valeur singulière.
Donc
kAk = σ1
1
kA−1 k =
σn
Et cond(A) = kAkkA−1 k d’où la propriété.
On peut écrire un peu différemment la SVD :
A = σ1 U1 V1T + . . . σr Ur VrT
où les matrices Ui ViT sont des matrices m × p de rang un. En effet il suffit
d’utiliser la définition du produit matriciel :
X r
X r
X
ai,j = (U Σ)i,k (V T )k,j = σk Ui,k Vj,k = σk (Uk VkT )i,j .
k k=1 k=1
Nous allons voir plusieurs applications de la SVD. Elles reposent toutes sur
le fait que la SVD permet une compression optimale de la matrice au sens
suivant : si on ne conserve dans Σ que les k < r valeurs singulières les plus
grandes σ1 ≥ σ2 ≥ . . . ≥ σk on obtient une matrice notée
Ak = σ1 U1 V1T + . . . σk Uk VkT
qui est de rang k. Nous allons montrer que c’est la meilleure approximation
de rang k de A au sens où kA − Ak k est minimum. Ainsi les matrices Ak
fournissent des compressions optimales de A pour un rang donné. le rang
correspond à la richesse de l’information contenue, c’est la dimension de
l’espace engendré par les colonnes ou les lignes de la matrice. Les matrices
Ak sont donc des versions appauvries de A puisqu’elles ont un rang inférieur
mais en quelque sorte ce sont les plus fidèles possibles à rang fixé.
Théorème 2 Soit k < r = rang(A) et soit
Ak = σ1 U1 V1T + . . . σk Uk VkT
la matrice obtenue en ne conservant que les k plus grosses valeurs singulières

de A. Alors
min kA − Bk = kA − Ak k = σk+1 .
rang(B)=k
Preuve. Considérons la décomposition en valeurs singulières de A = U ΣV T .

Alors Ak = U Σk V T où
 
σ1 0 . . . 0 0 . . . 0
. . . .. 
 0 σ2 . . .. .. . 

 . .
 .. . . . . . 0 ... .. 
. 
 
Σk = 
 0 . . . 0 σ k 0 . . . 0 .

 0 ... ... 0 0 ... 0 
 
 . . . .
 .. .. .. .. 

0 ... ... 0 0 ... 0
Comme U et V sont des matrices carrées inversibles, elles ne modifient pas

le rang et le rang de Ak est donc exactement k. Considérons A − Ak =
U diag(0, . . . , 0, σk+1 , σk+2 , . . . , σr , 0, . . . , 0)V T où la notation diag(. . .) désigne
la matrice de format m×p dont la diagonale est 0, . . . , 0, σk+1 , σk+2 , . . . , σr , 0, . . . , 0.
Commençons par calculer kA − Ak k. Comme A − Ak = U (Σ − Σk )V T , les

valeurs singulières de A − Ak sont évidemment σk+1 , . . . σr . En vertu de la
propriété 1, kA − Ak k = σk+1 .
Considérons ensuite une matrice B de format m × p quelconque de rang k.
Par le théorème du rang, la dimension du noyau est dim ker B = p − k. Les
sous-espaces V ect{V1 , V2 , . . . , Vk+1 } et ker B ont une intersection non nulle :
V ect{V1 , V2 , . . . , Vk+1 } ∩ ker B 6= {0} .
Sinon ils seraient en somme directe et la dimension
dim V ect{V1 , V2 , . . . , Vk+1 } ⊕ ker B ≥ p + 1
ce qui est impossible car ce sont des sous-espaces de Rp . Soit donc un vecteur
z ∈ ker B ∩V ect{V1 , V2 , . . . , Vk+1 } et tel que kzk = 1. On a d’une part Bz = 0
puisque z ∈ ker B. D’autre part Pz se décompose suivant laPfamille orthonor-
male V1 , V2 , . . . , Vk+1 en z = 1≤i≤k+1 < z, Vi > Vi = 1≤i≤k+1 (ViT z) Vi .
Donc X X
Az = (ViT z) A Vi = (ViT z) σi Ui .
1≤i≤k+1 1≤i≤k+1
On est en mesure de calculer
kA − Bk = sup k(A − B)xk ≥ k(A − B)zk = kAzk.

kxk=1
Maintenant la norme de Az est facile à obtenir à partir de ses composantes

dans la base orthonormale U1 , U2 , . . . Um
!
X X
kAzk2 = (ViT z)2 σi2 ≥ σk+1
2
(ViT z)2
1≤i≤k+1 1≤i≤k+1
| {z }
kzk2 =1
Ainsi on a bien prouvé kA − Bk ≥ σk+1 .

Remarque. Si on utilise la norme de Frobenius des matrices
X
kAkF = |ai,j |2
i,j
au lieu de la norme de l’endormorphisme associé
kAxk
kAk = sup
x6=0 kxk
on a un résultat analogue pour la matrice Ak à savoir

q
2
min kA − BkF = kA − Ak kF = σk+1 + . . . σr2 .
rang(B)=k
Pour le prouver, il faut sur l’espace vectoriel des matrices m × p utiliser le

produit scalaire associé à la norme de Frobenius : < A, B >= tr(AT B) =
T
P
i,j ai,j · bi,j et le fait que Ui Vj , 1 ≤ i ≤ m, 1 ≤ j ≤ p forme une base or-
thonormée de cet espace. C’est un bel exercice d’algèbre linéaire euclidienne. 4
2
2.5 TD autour de la décomposition de valeurs

singulières.
On rappelle le théorème vu en cours
4. Attention au fait que la norme de Frobenius est une norme matricielle mais qu’elle
n’est pas subordonnée à une norme vectorielle.
2.5. TD AUTOUR DE LA DÉCOMPOSITION DE VALEURS SINGULIÈRES.33
S oit A une matrice m × p. Elle se factorise en
A = U ΣV T ,
où U matrice orthogonale m × m, V matrice orthogonale p × p et Σ matrice

rectangle m × p dont tous les termes extra diagonaux sont nuls.
 
σ1 0 . . . 0 0 . . . 0
. . . .. 
 0 σ2 . . .. .. . 

 . . . . .. 
 .. . . . . 0 .. . 
 
Σ=  0 . . . 0 σr 0 . . . 0 

 0 ... ... 0 0 ... 0 
 
 . . . .
. . . .

 . . . . 
0 ... ... 0 0 ... 0
Les termes diagonaux non nuls, rangés par ordre décroissant σ1 ≥ σ2 ≥ . . . ≥

σr > 0 sont les valeurs singulières de A. Ce sont les racines carrées positives
des valeurs propres de AT A.
On note U = (U1 , . . . , Um ), Uj désignant la j e colonne de U et V = (V1 , . . . , Vp ),
Vk désignant la k e colonne de V , prouver les résultats suivants :
1. le rang de A est r.
2. (U1 , . . . , Ur ) est une base orthonormée de l’espace des colonnes de A
qui est aussi ImA.
3. (V1 , . . . , Vr ) est une base orthonormée de l’espace des lignes de A qui
est aussi Im(AT ).
4. (Ur+1 , . . . , Um ) est une base orthonormée de (ImA)⊥ = ker(AT ).
5. (Vr+1 , . . . , Vp ) est une base orthonormée de kerA.
Ainsi ou peut lire dans U et V les bases des 4 sous-espaces fondamentaux :
ImA, kerA, ImAT et kerAT .
Indication : On commencera par constater que l’espace des colonnes est ImA,
l’espace des lignes est ImAT . La décomposition svd de A donne la décompo-
sition svd de AT = V ΣT U T .Il suffit d’échanger U et V ! Les questions 3 et
4 découlent donc immédiatement des questions 2 et 5. Pour démontrer 1, 2
et 5, on remarquera que
AVj = σj Uj , j ≤ r; AVj = 0, j ≥ r + 1.
Application à laP compression de matrices P

Montrer que A = rj=1 σj Uj VjT . On note Ak = kj=1 σj Uj VjT la somme des
k premiers termes. On peut démontrer que, parmi toutes les matrices de rang
inférieur ou égal à k, Ak est la plus proche de A, au sens ou ||A − Ak || est mi-

nimum. Ainsi pour compresser l’information contenue dans A, on remplace
A par Ak . Pour voir l’effet d’une telle compression en traitement d’image,
effectuer l’exercice 10b) du résumé Matlab (chapitre final) : Les instructions
matlab load gatlin, figure(1), image(X), colomap(map), title(caption)
affichent une photographie des principaux créateurs de l’analyse numérique
matricielle. Calculer la décomposition en valeurs singulières de la matrice X
(de taille 640x480) et afficher l’image obtenue en ne conservant que les 100
premières valeurs singulières (au lieu de 480). Voici une procédure concernant
ce calcul (voir poly, partie matlab)
.% 10b) Usage de valeurs singulières

load gatlin
figure(1), image(X), colormap(map), title(caption)
[U,S,V]=svd(X,0);
k=1:100; X=U(:,k)*S(k,k)*V(:,k)’; figure(2), image(X), colormap(map),
title(caption)
% exemple_uicontrol à voir plus loin
disp(’ appuyez sur une touche pour continuer’),
pause, close all, clear, clc
Pour effectuer la décomposition de valeur singulière en MATLAB, utiliser la

commande
[U,Sigma,V]=svd(A)
Si on ne veut garder que les k plus grandes valeurs singulières
[Uk,Sigmak,Vk]=svds(A,k)
2.6 TP 2
Construction d’un petite matrice terme document et SVD. D’après Berry-
Browne. le tableau suivant donne les titres de livre correspondant à une
recherche sur amazon.com.
2.6. TP 2 35
termes documents
T1 bab(y,ies,y’s) D1 infant and toddler first aid
T2 child(ren’s) D2 babies and children’s room (for your home)
T3 guide D3 child safety at home
T4 health D4 your baby’s health and safety : from infant to toddler
T5 home
T6 infant D5 baby proofing basics
T7 proofing D6 your guide to easy rust proofing
T8 safety D7 beanie babies collector’s guide
T9 toddler
1. Construire la matrice terme/document de taille 9×7. La normaliser, i.e.
faire en sorte que chaque colonne soit de norme euclidienne unité.Soit
A la matrice ainsi construite.
2. Effectuer la requête « child proofing ». Calculer le vecteur q correspon-
dant à la requête et calculer la pertinence de chaque document, i.e.
calculer cos θj de l’angle entre q et aj , où aj est la j-ème colonne de
A. Avec un seuil de pertinence de 0.5 ; quels seraient les documents
selectionnés ?
3. Quel est le rang de A ?
4. approximation de rang faible pour la recherche sémantique. Effectuer la
décomposition de valeur singulière de A. Construire une approximation
de A de rang 5 (resp. 4), notée A5 (resp. A4 ) . Quel est l’erreur relative
en norme euclidienne
||A − A5 ||
?
||A||
5. calculer à nouveau les cos θj (avec la matrice A remplacée par A5 ou
A4 ? Commenter. Indication : Soit Ak = Uk Σk VkT . Soit sj = Σk VkT ej .
Montrer que
sj T (UkT q)
cos θj =
||sj ||||q||
les k composantes de sj sont les coordonnées de la j-ème colonne de Ak
dans la base définie par les colonnes de Uk . Les k composantes de UkT q
sont les composantes dans cette même base de la projection Uk UkT q du
vecteur requête q sur l’espace des colonnes de Ak
Chapitre 3
Le moteur de recherche Google et

le page ranking.
3.1 L’équation du PageRank

Pour classer la popularité ou l’importance des sites, les fondateurs de Google,
S. Brin et L. Page (sic) ont eu l’idée de leur attribuer un score, le désormais fa-
meux PageRank. Pour le voir, il suffit de télécharger la barre d’outil Google
qui est gratuite. Pour cela, aller sur google.fr et sélectionner l’onglet plus.
Dans cet onglet, sélectionner l’onglet et encore plus. Parmi les autre pro-
duits figure la barre d’outil. Une fois la barre d’outil installée sur votre
navigateur,vous voyez le curseur pagerank qui vous donne la popularité de
chaque page affichée, sur une échelle allant de 0 à 10 (le score de google.com.
Un site i est d’autant plus important que sont nombreux les sites pointant
vers lui. Mais si le nombre de liens pointant vers le site est une indication de
son importance, il faut aussi tenir compte du poids de chaque site pointant
vers i.
– Lorsqu’un site j pointe vers un site i, cela signifie que le site j « recom-
mande »le site i
– lorsque le site i est recommandé par un site j, la recommandation aura
d’autant plus de poids que le site j est important.
– Lorsqu’un site recommande beaucoup de sites, le poids de sa recomman-
dation doit être relativisé d’autant.
C’est une peu comme si on mesurait la valeur d’une personne en fonc-
tion de ses lettres de recommandation. Plusieurs recommandations valent
mieux qu’une. Une recommandation d’une personnalité importante a plus de
poids qu’une recommandation d’un inconnu, mais si une personnalite impor-
tante distribue ses recommandations a tout le monde, ses recommandations
37
38CHAPITRE 3. LE MOTEUR DE RECHERCHE GOOGLE ET LE PAGE RANKING.
perdent de la valeur. La valeur d’une page Pi , appelée pagerank(Pi ) est donc

la somme X
pagerank(Pi ) = pagerank(Pj )/|Pj | (3.1)
Pj →Pi
où |Pj | = lj désigne le nombre de liens sortants de Pj .
3.1.1 Traduction matricielle.

Considérons le réseau réduit à 6 pages dont le graphe d’incidence est donné
par la matrice  
0 1 1 0 0 0
 0 0 0 0 0 0 
 
 1 1 0 0 1 0 
G=  0 0 0 0

 1 1 

 0 0 0 1 0 1 
0 0 0 1 0 0
Représenter le graphe correspondant. Soit H la matrice normalisée suivante :
 
0 1/2 1/2 0 0 0
 0 0 0 0 0 0 
 
 1/3 1/3 0 0 1/3 0 
H=  0

 0 0 0 1/2 1/2 

 0 0 0 1/2 0 1/2 
0 0 0 1 0 0
Soit le vecteur ligne

r = (pagerank(Pi ))i=1,...,n
La formule (3.1) s’écrit simplement :
r =r·H
autrement dit H T rT = rT , rT est vecteur propre de H T pour la valeur propre

1. On dit aussi que r est vecteur propre à gauche de H. La première méthode
utilisée par Brin et Page pour résoudre cette équation est la méthode itéra-
tive :
r(k+1) = r(k) H (3.2)
où r(0) est un vecteur initial, par exemple (1/6, 1/6, . . . , 1/6) qui correspond
au même page rank initial pour tout lemonde.
Remarque. Cette méthode est peu coûteuse en calcul, car la matrice H est
creuse ! 2
3.2. L’ALGORITHME PAGE RANK. 39
Mais si on itère, rapidement les trois derniers noeuds monopolisent le page

rank : après 13 itérations, r(13) ≈ (0.0000, 0.0000, 0.0000, 0.2666, 0.1333, 0.2000).
Ce n’est pas très heureux, car comment départager les noeuds 1, 2, 3 ? En
fait les noeuds 1,2, 3 sont transitoires.
Remarque. On peut aussi avoir des cycles pour des matrices particulières, par
exemple
0 1
1 0
2
Tout cela vient du fait que la matrice H est sous-stochastique (i.e. la somme
des lignes est inférieure ou égale à l’unité) et qu’elle n’est pas irréductible.
En fait on peut démontrer
 
0.0000 0.0000 0 0.0889 0.0444 0.0667

 0 0 0 0 0 0 

k ∞
 0 0.0000 0.0000 0.1778 0.0889 0.1333 
H →H = 

 0 0 0 0.4444 0.2222 0.3333  
 0 0 0 0.4444 0.2222 0.3333 
0 0 0 0.4444 0.2222 0.3333
Et on observe en plus que selon le vecteur initial r(0) , la limite de r(k) n’est pas
la même ! ! les questions suivantes se posent, auxquelles nous allons résoudre
dans la suite du cours :
– est-ce que l’algorithme itératif (3.4) converge ?
– Quelles propriétes de H garantissent la convergence ?
– Y-aura-t-il une limite unique ?
– la limite dépendra -t- elle de la donnée initiale ?
– la convergence sera-t-elle rapide ?
3.2 L’algorithme page rank.

3.2.1 modification de la matrice H
On règle le problème des noeuds cul-de-sac : on remplace les lignes
nulles par 1/n, 1/n, . . . , 1/n.
 
0 1/2 1/2 0 0 0
 1/6 1/6 1/6 1/6 1/6 1/6 
 
 1/3 1/3 0 0 1/3 0 
S=  0

 0 0 0 1/2 1/2 
 0 0 0 1/2 0 1/2 
0 0 0 1 0 0
Matriciellement, cela s’écrit simplement

1 T
S=H+ ae
n
où a est le vecteur colonne dont toutes les composantes sont nulles sauf
lorsque l’indice correspond à un cul-de-sac : ai = 1 si Pi n’a pas de lien
sortant. Le vecteur e est le vecteur (1, 1, . . . , 1)T .
Si on calcule la limite de S n on obtient aisément avec MATLAB
>> S^100
ans =
0.0000 0.0000 0.0000 0.4444 0.2222 0.3333

0.0000 0.0000 0.0000 0.4444 0.2222 0.3333
0.0000 0.0000 0.0000 0.4444 0.2222 0.3333
0 0 0 0.4444 0.2222 0.3333
0 0 0 0.4444 0.2222 0.3333
0 0 0 0.4444 0.2222 0.3333
La limite est bien la même quelque soit le vecteur initial. Et c’est bien un
vecteur normalisé. MAIS les noeuds 1, 2, 3 ont disparu et les noeuds 4,5,
6 monopolisent le classement. Cela provient de ce que tous les noeuds ne
communiquent pas. En fait le graphe n’es pas irréductible. Une fois arrivé
sur les noeuds 4, 5 ou 6 le robot ne peut revenir dans les noeuds 1, 2 ou 3.
Cette propriété est néfaste, il faut que tous les noeuds communiquent. Pour
régler ce problème simplement on va ajouter une peu de diffusion. C’est à
dire que l’on ajoute une proportion de la matrice
 
1/n 1/n . . . 1/n
 1/n 1/n . . . 1/n  1
T
..  = ee
 
 .. ..
 . . ... .  n
1/n 1/n . . . 1/n
Il faut veiller à ce que la matrice reste stochastique, donc on prend une com-
binaison convexe de S et n1 eeT .
On règle ainsi le problème de la régularité de la matrice (irréduc-
tibilité et apériodicité) :
1
G = αS + (1 − α) eeT
n
α est un paramètre à choisir judicieusement.
Remarque. Cela revient à ajouter un peu de diffusion, procédé de régularisa-

tion bien connu en analyse. Posant = 1 − α,
1
G = (1 − ) S + e eT
n
2
 
1/60 7/15 7/15 1/60 1/60 1/60
 1/6 1/6 1/6 1/6 1/6 1/6 
 
 19/60 19/60 1/60 1/60 19/60 1/60 
Exemple. Pour α = 0.9, on obtient G =   1/60 1/60 1/60 1/60 7/15
.
 7/15 

 1/60 1/60 1/60 7/15 1/60 7/15 
1/60 1/60 1/60 11/12 1/60 1/60
Historiquement, le paramètre choisi par Google est α = 0.85. Nous verrons
plus loin comment ce paramètre contrôle la vitesse de convergence de l’algo-
rithme (3.4) où H est remplacée par G.
Pour α = 0.9, on calcule
>> G^100
ans =
0.0372 0.0540 0.0415 0.3751 0.2060 0.2862

0.0372 0.0540 0.0415 0.3751 0.2060 0.2862
0.0372 0.0540 0.0415 0.3751 0.2060 0.2862
0.0372 0.0540 0.0415 0.3751 0.2060 0.2862
0.0372 0.0540 0.0415 0.3751 0.2060 0.2862
0.0372 0.0540 0.0415 0.3751 0.2060 0.2862
on obtient que l’algorithme converge toujours vers la même limite, π =
(0.03721, 0.05396, 0.04151, 0.3751, 0.206, 0.2862) quel que soit l’initialisation.
Les pages de ce mini réseau peuvent donc être classées dans l’ordre d’impor-
tance décroissante : 4 6 5 2 3 1,
On définit alors le vecteur page rank par
Théorème et Définition 1 Il existe un unique vecteur π = (π1 , . . . , πn ) à
coefficients positifs tel
Pque :
– π est normalisé : i πi = 1
– π = πG
Ce vecteur est appelé vecteur pagerank.
Remarque. En fait le page rank affiché dans la barre d’outil google et égale-
ment par différents « add-ons » du navigateur Firefox est une image logarith-
mique : au lieu de πi on affiche le nombre [(10 + log πi )+ ], de sorte que pour
πi = 1 on trouve 10, que si on divise par 10 le nombre πi le page rank affiché

diminue de une unité, que le page rank affiché soit nul pour πi < 10−10 . Ici
[·] désigne la fonction partie-entière et (·)+ la fonction partie positive. 2
Preuve. Il faut prouver que la définition précédente est légitime i.e. que le
page rank existe et qu’il est unique. Nous donnons une preuve constructive
par le théorème du point fixe (cf [7] et le document en ligne
http://images.math.cnrs.fr/Comment-Google-classe-les-pages.html ).
Soit ( )
X
B = x ∈ Rn ; xi = 1, ∀i, xi ≥ 0 .
i
C’est une partie fermée donc complète de Rn . Considérons l’application
T : x ∈ Rn 7→ x G ∈ Rn .
T laisse stable la partie B : Si x ∈ B alors T (x) ∈ B. En effet, si on pose

y = T (x)
!
X XX XX X X X
yi = xj gj,i = xj gj,i = xj gj,i = xj = 1
i i j j i j i j
T est contractante sur B :
x G − y G = (x − y)(αS + (1 − α)1/neeT )
or
(x − y)eeT = 0
donc
xG − yG = α · (x − y)S
Prenons la norme
kxG − yGk = α|||S|||kx − yk
|||S||| ≤ 1 Il suffit de prendre la norme matricielle associée à la norme
Enfin P
|x| = |xi | sur Rn .
X X XX X X X
kzSk = | zi Si,j | ≤ |zi |Si,j ≤ |zi | Si,j ≤ |zi |.
j i j i i j i
Donc
kT (x) − T (y)k ≤ αkx − yk. (3.3)
Le théorème du point fixe de Banach pour l’application T : B → B permet
d’affirmer que T possède un unique point fixe π dans B. Cela signifie qu’il
existe un unique vecteur positif normalisé tel que π = T (π) = π G. La

définition du page rank est donc légitime.
De plus le théorème du point fixe est constructif : il dit aussi que la suite
définie par la relation de récurrence
x(k+1) = x(k) G (3.4)
où x(0) est un vecteur initial positif et normalisé quelconque de Rn converge
vers π et que la convergence s’effectue au moins aussi vite que la convergence
de la suite géométrique αk vers 0 :
kx(k) − πk ≤ αk kx(0) − πk.
Ce dernier point est facile à prouver par récurrence car
kx(k) − πk = kT (x(k−1) ) − T (π)k ≤ αkx(k−1) − πk
grâce à (3.3). On dispose donc d’un algorithme qui converge à vitesse géo-
métrique O(αk ) vers le page rank :
– Initialisation π ← (1/n, . . . , 1/n)
– Répéter πold ← π, π ← π G //itération
– jusqu’à kπ − πold k < tolerance// test d’arrêt
Le problème c’est que maintenant la matrice G est pleine et l’algorithme
itératif
π (k+1) = π (k) G
peut-être coûteux.
En fait on peut le réecrire en fonction de la matrice creuse H.

(k+1) (k) 1 T (1 − α) (k) T
π =π αS + (1 − α) ee = απ (k) S + π ee
n n
Comme π (0) est de somme unité (vecteur normalisé) et que G est stochastique
on a que π (k) est de somme unité et donc que π (k) e = 1.
π (k+1) = απ (k) H + απ (k) a + (1 − α) eT /n.

Le nombre de coefficients non nuls de H, noté nnz(H) ≈ 10·n car en moyenne

une page web possède environ 10 liens sortants. Nous allons voir que le coût
d’une multiplication x · H est linéaire en n, au lieu de O(n2 ), si la matrice
était pleine. On a X X
yj = xi hi,j = xi /li
i i→j
où l’on note li le nombre de liens sortant de i.

Un algorithme optimal pour calculer y = x · H est :
– Initialisation y ← 0
– Pour i=1 à n faire
– Pour j tels que i → j faire yj ← yj + xi /li Fin pour
– Fin pour
– Retourne y
Remarquez que tel qu’il est codé, l’algorithme effectue une boucle sur les liens
sortants de chaque page i et que chaque lien i → j est traitéPexactement une
fois. le nombre total d’opération est donc proportionnel à i li . Si les pages
¯ ¯
émettent en moyenne l liens, la complexité vaut i li = nl au lieu de n2 si
P
la matrice était pleine.
C’est ce qui fait que cette méthode, appelée méthode de la puissance peut
être utilisée en pratique pour les matrices creuses.
3.2.2 Le choix de α
α s’interprète comme le pourcentage du temps pendant lequel le googlebot
navigue suivant les probabilités données par S, 1 − α correspond au pourcen-
tage restant pendant lequel le googlebot navigue complètement au hasard sur
le web, suivant une loi uniforme (tous les sites ont la même probabilité 1/n).
La vitesse à laquelle αk → 0 donne le nombre d’itération nécessaires à une
précision donnée : Pour avoir le page rank à 10−10 près, il faut 34 itérations
pour α = 0.5 81 itérations pour α = 0.75 142 itérations pour α = 0.85
Mais si α est trop petit, la matrice S qui résume le web est complètement
absorbée par la matrice uniforme n1 eeT Il faut faire un compromis. Le choix
α = 0.85 en est un acceptable.
Le problème se pose aussi de la sensibilité du page rank vis à vis du paramètre
α. On peut prouver [3] le théorème :
Propriété 3 Soit π(α) = (π1 (α), . . . , πn (α)) alors
dπj (α) 1
| |≤
dα 1−α
Ainsi si on prend α pas trop près de un, le résultat n’est pas trop sensible
vis à vis de α. La démonstration fait l’objet du TD 4.
3.2.3 TD 4 : sensibilité du page rank vis à vis du para-

mètre α.
Soit
1
G(α) = α S + (1 − α) e eT
n
et π(α) = (π1 (α), . . . , πn (α)) le vecteur page rank associé. le but de ce TD

est la démonstration de la propriété :
dπj (α) 1
| |≤
dα 1−α
1. En utilisant π(α) · e = 1, montrer que
dπ(α)
·e=0
dα
2. En déduire
dπ(α) 1
· (I − α S) = π(α)(S − e eT )
dα n
I désigne la matrice identité.
3. On suppose 0 < α < 1. Montrer que (I − α S) est inversible et que
(I − α S)−1 est à coefficients positifs.
4. Soit x et y des vecteurs colonnes de Rn . On suppose que xT e = 0.
Montrer que
X (ymax − ymin )
|xT y| ≤ ( |xi |)
i
2
où ymax = max yi et ymin = min yi .

5. En utilisant les points précédents, on peut écrire
dπ(α) 1
= π(α)(S − e eT )(I − α S)−1
dα n
Et donc
dπj (α) 1
= π(α)(S − e eT )(I − α S)−1 ej (3.5)
dα n
où ej désigne le j e vecteur de la base canonique.
Poser alors xT = π(α)(S − n1 P e eT ) et y = (I − α S)−1 ej .
Montrer que xT e = 0 et que i |xi | ≤ 2.
6. En utilisant la question (3), prouver que ymin ≥ 0
1
7. En utilisant que (I − α S) e = (1 − α) · e, prouver que ymax ≤ 1−α
.
8. Conclure à l’aide de (4) et de l’équation (3.5).
3.2.4 Point de vue spectral : puissance de matrice et

valeurs propres.
L’algorithme précédent est bien connu pour le calcul des valeurs propres, et
s’appelle méthode de la puissance itérée. En élévant la matrice à des puis-
sances successives on fait ressortir la valeur propre de module maximum. La
méthode itérative de la puissance repose sur la propriété suivante.
Propriété 4 Soit M une matrice n × n diagonalisable dont le spectre est

λ1 = 1, λ2 , . . . , λn où les v.p. sont rangées par module décroissant 1 > |λ2 | ≥
. . . |λn | alors l’algorithme
x(k+1) = M x(k) , x(0) = x
converge vers un vecteur propre associé à la valeur propre 1 à la vitesse

contrôlée par |λ2 |k
Preuve. On décompose X
x= xj uj
j
où uj est un vecteur propre associé à λj .

X
M kx = λkj xj uj
j
On a immédiatement
X
||M k x − x1 u1 || ≤ |λ2 |k ( |λj /λ2 |k |xj |||uj ||) ≤ C · |λ2 |k
j≥2
Le résultat suivant est fondamental. C’est un cas particulier du théorème de

Perron-Frobenius.
Propriété 5 (Perron-Frobenius) Soit P matrice stochastique. Alors 1 est

valeur propre pour le vecteur propre e = (1, 1, . . . , 1)T . De plus toutes les
autres valeurs propres sont de module inférieur ou égal à un. D’autre part, 1
est également valeur propre à gauche de P pour un vecteur propre à gauche
π dont tous les coefficients sont positifs.
Si de plus les coefficients de P sont strictement positifs, alors les coefficients
de π le sont aussi, 1 est valeur propre simple de P et les autres valeurs
propres sont de module strictement inférieur à 1.
Preuve. Soit P stochastique. Soit le vecteur colonne e = (1, 1, . . . , 1)T . Cal-

culons X X
P ·e=( pi,j , . . . , pi,j )T = e.
j j
Donc 1 est valeur propre de P de vecteur propre e. Soit λ valeur propre

associée à un vecteur propre v supposé non colinéaire à u. Montrons que
|λ| ≤ 1. En effet on a
P · v = λ · v.
La ie ligne s’écrit. X
pi,j vj = λvi .
j
Prenons le module.
X X
|λ||vi | = | pi,j vj | ≤ pi,j |vj |.
j j
Soit |vm | = maxj |vj | une composante de module maximum. On a |vm | > 0
car v 6= 0. On a X
|λ||vm | ≤ pm,j |vj |.
j
En divisant par |vm | on obtient

X |vj |
|λ| ≤ pm,j
j
|vm |
on tire X
|λ| ≤ pm,j = 1.
j
Donc |λ| ≤ 1. Nous avons donc prouvé à la fois que 1 est valeur propre
et que toutes les autres valeurs propres sont de module inférieur ou égal à
un. Montrons maintenant que la valeur propre 1 admet un vecteur propre à
gauche dont toutes les composantes sont positives (resp. strictement positives
si pi,j > 0. Comme P et P T ont les mêmes valeurs propres, on sait que 1 est
valeur propre de P T associée au vecteur propre colonne aT . Donc a · P = a.
X
aj = ai pi,j
i
Soit b = |a| le vecteur de composantes bj = |aj |. En prenant le module

X X
|aj | = | ai pi,j | ≤ |ai | pi,j
i i
P
Notons cj = i |ai | pi,j . Calculons en permutant les sommations en i et j.
X X X X
cj = |ai | pi,j = |ai |
j i j i
P P
puisque P est stochastique. On a donc |aj | ≤ cj et i |ai | = j cj donc on
a l’égalité |aj | = cj , ∀j. Cela prouve que b est vecteur propre à gauche pour
la valeur propre 1. Les coefficients de b sont évidemment positifs.
Supposons maintenant que P est à coefficients strictement positifs. Montrons
que les coefficients de π sont strictement positifs . On a
X
bj = |ai | pi,j
i
or pi,j > 0 et au moins un des |ai | > 0 donc bj > 0 et ceci vaut ∀j.
Montrons enfin, et c’est la partie la plus délicate de la preuve, que 1 est valeur
propre simple de P et les autres valeurs propres sont de module strictement
inférieur à 1. Soit λ valeur propre associée à un vecteur propre v supposé non
colinéaire à u. Montrons que |λ| < 1. Nous avons déja prouvé que |λ| ≤ 1.
Envisageons le cas d’égalité |λ| = 1. Nous obtenons, avec la même notation
|vm | = maxj |vj |,
X |vj | X
|λ| = 1 ≤ pm,j ≤ pm,j = 1
j
|vm | j
Comme pm,j > 0 et |vj | ≤ |vm | cela implique que |vj | = |vm | donc tous les
coefficients vj sont de même module, disons ρ. Prenant le module de
X
pi,j vj = λvi .
j
Avec l’inégalité triangulaire on tire

X X X
|λ||vi | = ρ = | pi,j vj | ≤ pi,j |vj | = pi,j ρ = ρ
j j j
On est donc dans le cas d’égalité de l’inégalité triangulaire : |z1 +z2 +. . . zn | =

|z1 | + |z2 | + . . . + |zn | qui ne se produit que si les complexes zj sont tous
colinéaires et de même sens. Ici zj = pi,j vj Donc tous les vj sont colinéaires
et de même sens, or ils sont situés sur le cercle de rayon ρ donc tous les vj sont
égaux et v est colinéaire à e, ce qui est exclu pas hypothèse. En conclusion, le
cas |λ| = 1 est impossible. On a prouvé que tout vecteur propre non colinéaire
à e était associé à une valeur propre de module strictement inférieur à 1.
Donc dim Ker(P − I) = 1 et toutes les valeurs propres différentes de 1 sont

de module strictement inférieur.
Remarque. La propriété précédente donne une autre démonstration de l’exis-

tence et de l’unicité du vecteur page rank. 2
L’intérêt de l’ajout de la diffusion réside dans la proposition suivante, qui
montre que le module de la valeur propre λ2 de G est au plus égal à α.
Propriété 6 (Ecartement des valeurs propres.) Si le spectre de la matrice

stochastique S est {1, λ2 , . . . , λn }, le spectre de G est {1, αλ2 , . . . , αλn }
Preuve. Soit S matrice stochastique de valeurs propres 1, λ2 , . . . , λn . Posons

G = αS + (1 − α) n1 eeT . S est stochastique sonc S · e = e. le vecteur colonne e
est vecteur propre de S pour la valeur propre 1. Posons (notation par blocs)
Q = (e, X)
où X est une matrice n × (n − 1) choisie de sorte que Q soit inversible. C’est

possible, par le théorème de la base incomplète, il suffit de choisir les colonnes
de X (notation MATLAB) de sorte que (e, X(:, 1), . . . , X(:, n − 1) soit une
base de Rn . Notons T
−1 y
Q =
YT
où y T est un vecteur ligne et Y T une matrice n − 1 × n. Effectuons le produit
par blocs T T
−1 y y e yT X
In = Q Q = (e, X) =
YT Y Te Y TX
On en déduit
 
0
y T e = 1, Y T X = In−1 , Y T e =  ...  , y T X = (0 . . . 0).
 
0
Considérons
T T T T
−1 y y y y e y T SX
Q SQ = S (e, X) = (Se, SX) = (e, SX) =
YT YT YT Y T e Y T SX

−1 1 ∗
Q SQ = T
O Y SX
la matrice Q−1 SQ étant semblable à S a exactement les mêmes valeurs

propres 1, λ2 , . . . , λn . Donc les valeurs propres de Y T SX sont λ2 , . . . , λn .
Calculons enfin

−1 −1 1 T 1 ∗
Q GQ = Q (αS + (1 − α) ee )Q =
n O α(Y T SX)
dont les valeurs propres sont évidemment 1, αλ2 , . . . , αλn .
Corollaire 1 Soit P matrice stochastique dont tous les coefficients sont stric-
tement positifs. Alors lorsque k → ∞, la matrice P k converge vers une ma-
P et égales à π unique vecteur ligne
trice dont toutes les lignes sont identiques
à coefficients positifs que π = π · P et i πi = 1.
Preuve. Si on admet que P est diagonalisable il suffit d’appliquer la prop 5.
Les valeurs propres sont 1, λ2 , . . . , λn et |λn | ≤ . . . ≤ |λ2 | < 1
P = QDQ−1
où D = diag(1, λ2 , . . . , λn ).
P k = QDk Q−1
où Dk = diag(1, λk2 , . . . , λkn ). Les coefficients diagonaux de Dk sont des suites
géométriques, donc Dk → diag(1, 0, . . . , 0) et
 
1 0 ... 0
 0 0 ... 0 
 −1
P k → Q  .. .. . Q .

 . . . . . .. 
0 0 ... 0
Il suffit ensuite d’effectuer le produit (associatif). Notant L = (l1 , l2 , . . . , ln )
la première ligne de Q−1 . On a
   
1 0 ... 0 l1 l2 . . . ln
 0 0 ... 0   0 0 ... 0 
 −1 
.  Q =  .. ..
 
 .. .. .. 
 . . . . . ..   . . ... . 
0 0 ... 0 0 0 ... 0
Puis
   
l1 l2 . . . ln l1 c1 l2 c1 . . . l n c1
 0 0 ... 0   l1 c2 l2 c2 . . . l n c2 
Q· ..  =  .. ..  = (l1 C, l2 C, . . . ln C).
   
.. .. ..
 . . ... .   . . ... . 
0 0 ... 0 l1 cn l2 cn . . . ln cn
où C désigne la première colonne de Q. Or la matrice P k étant stochastique

∀k on a que la matrice limite également, ce qui donne pour la ligne i (l1 +
l2 + . . . + ln )ci = 1 donc
1
ci =
l1 + l2 + . . . + ln
La matrice  
l1 ln
l1 +l2 +...+ln
... l1 +l2 +...+ln
 .. .. 
 . ... . 
Pk → 
 .. ..


 . ... . 
l1 ln
l1 +l2 +...+ln
... l1 +l2 +...+ln
Notons
l1 l2 ln
π=( , ,..., .
l1 + l2 + . . . + ln l1 + l2 + . . . + ln l1 + l2 + . . . + ln
On a i πi = 1. De plus comme P est à coefficients positifs, P k est aussi

P
à coefficients positifs donc la matrice limite de P k également. Ainsi π est à
coefficient positif. Enfin lim P k+1 = lim P k d’une part. D’autre part par conti-
nuité des opérations somme et produit, lim P k+1 = lim P k · P . Considérons
la première ligne de lim P k+1 = π et la première ligne de lim P k · P = π · P
on obtient finalement
π = π · P.
Remarque. La preuve précédente repose sur la diagonalisation de P . Si P n’est

pas diagonalisable, il faut utiliser la forme de Jordan (voir cours de Strang, [1]
ou son cours en ligne gratuit au MIT et montrer que la multiplicité algèbrique
de 1 est encore un. 2
Remarque. On peut donner une démonstration élémentaire de la convergence

de la puissance d’une matrice stochastique irréductible apériodique dans le
cas où tous les coefficients sont non nuls, sans utiliser la diagonalisation. Voir
le TD sur les chaînes des Markov qui suit, question 6. 2
3.2.5 Résolution directe du système linéaire

Propriété 7
xT (I − αH) = eT , π T = x/xT e
Cette méthode est intéressante si la taille du réseau n’est pas trop grand
(intraweb, par exemple). La matrice H est creuse cependant. On peut en
déduire une formule théorique pour le vecteur pagerank :
∞
X
T
x = α k eT H k
k=1
3.3 TD. Introduction aux chaînes de Markov.

Un robot (Googlebot) navigue au hasard sur le réseau (ou graphe), supposé
comporter n sites (ou noeuds) distincts. On donne la matrice de transition
du web P = (pi,j ). A chaque unité de temps, le robot passe d’un site à l’autre
avec la probabilité Prob(i → j) = pij . On donne la position initiale du robot.
1. Montrer que la matrice
P à coefficients positifs P = (pij )(1≤i,j≤n) est sto-
chastique : ∀i, p
j ij = 1.
2. On se donne une population de 100 robots naviguant selon les mêmes
règles. Déterminer la répartition des robots après k unités de temps i.e.
calculer la proportion (ou pourcentage) de robots initialement dans le
site i qui se trouvent dans le site j après k unités de temps. On pourra
(k)
noter (pij ) les coefficients de la matrice P k . Vérifier que P k est une
matrice stochastique.
3. Dans cette question n = 3.
 
1/3 1/3 1/3
P =  1/4 1/4 1/2 
3/5 1/5 1/5
Calculer la proportion de robots passant du noeud 1 au noeud 3 en
deux unités de temps.
4. On donne la répartition initiale (20%, 70%, 10%) des robots. Calculer la
répartition limite α = (α1 , α2 , α3 ) au bout d’un grand nombre d’unité
de temps. On ne demande pas de prouver la convergence indication :
montrer que α = α · P Ce résultat dépend-il de la position initiale des
robots ?
5. Prouvez la convergence de P k vers une matrice stochastique dont toutes
les lignes sont égales à α. On pourra calculer numériquement les valeurs
propres de P T avec MATLAB.
6. (difficile) Soit P une matrice de transition dont tous les coefficients
sont strictement positifs.. 1 Montrer que limk→∞ P k = P ∞ existe et est
1. cela implique l’irréductibilité de la chaîne : tous les états communiquent.
3.4. TP4 53
une matrice stochastique dont toutes les lignes sont égales à α, que α
est la distribution limite des robots, quel que soit leur position initiale.
Montrer de plus que ∀i, αi > 0.
Indications : d’après Kemeny-Snell, Finite Markov chains [6],pp. 69-70. On
commencera par noter d = min pij . Montrer que pour N ≥ 2, 0 < d ≤ 1/2.
Considérant ensuite la j e colonne, poser
(n) (n)
Mn = max pij = pbj
i
et
(n) (n)
mn = min pij = paj .
i
Nous allons montrer que
Mn+1 ≤ Mn , mn+1 ≥ mn , Mn − mn → 0,
ce qui impliquera que la matrice P n converge vers une matrice constante par
colonne, i.e. dont toutes les lignes sont égales. Remarquer ensuite que
! !
X (n)
X (n)
Mn+1 = max pik pkj = max pik pkj + pia mn
i i
k k6=a
!
X
≤ pik Mn + pia mn = (1 − pia ) Mn + pia mn = Mn − (Mn − mn ) pia
k6=a
On obtient ainsi
Mn+1 ≤ Mn − (Mn − mn ) d.
Prouver de même
mn+1 ≥ mn + (Mn − mn ) d.
En soustrayant, cela donne
(Mn+1 − mn+1 ) ≤ (1 − 2d) (Mn − mn ).

Comme 0 ≤ 1 − 2d < 1, le résultat en découle pour la j e colonne.
3.4 TP4
On suppose n = 500. A partir de la matrice G = harvard500.mat vue dans le
TP1, fabriquer une matrice de transition du web, i.e. une matrice stochastique
P dont tous les coefficients soient strictement positifs. On pourra d’abord
– calculer la somme de chaque ligne,sum G(i,:)

– normaliser les lignes non nulles afin que la somme soit l’unité,
1
– remplacer les lignes nulles par 500 · (1, . . . , 1). Soit S la matrice obtenue à
ce stade.
1
– Soit P = α · S + (1 − α) · 500 ones(500, 500), où α ∈ [0, 1]. Montrer que P
convient. Pour Google, α = 0.85.
– Calculer la distribution limite π des googlebots naviguant sur la portion
du web dont le graphe estharvard500.mat suivant la matrice de transition
P . Le classement Pagerank n’est autre que le classement des sites suivant
la taille de πi .
– Changer la valeur du paramètre α et examiner la dépendance du classement
PageRank obtenu.
En MATLAB
– la fonction ones(p,q) construit une matrice de taille p × q dont tous les
coefficients sont égaux à 1.
– les valeurs propres et vecteurs propres s’obtiennent par la fonction eig
La procédure suivante effectue la renormalisation.

s=0;H=double(G);
for i=1:500
s=sum(H(i,:));
if (s == 0) H(i,:) =1/500*ones(1,500);
else a=H(i,:); S(i,:) = 1/s*a;
end
end;
3.5. TP4 (VARIANTE) 55
3.5 TP4 (variante)

Le but de ce TP est de construire une matrice stochastique à partir de la
matrice d’hyperliens G construite au TP 1.
>> S=sum(G,2);
P
la commande » S=sum(G,2) effectue la somme de chaque ligne j G(i, j) et
range les résultats dans un vecteur colonne. On normalise à 1 la somme de
chaque ligne en divisant G(i, j)/S(i) lorsque S(i) est non nul.
>> for i=1:20

H(i,:) = G(i,:)/S(i)
end;
VOIR le chapitre linear equations dans Moler et les exercices correspondants.

soit E = 1/n · ones(n, n) la matrice dont tous les termes sont égaux à 1/n.
Soit G = αH + (1 − α)E, pour α = 0.85 Calculer les puissances de G. Que
constatez vous ? Etudiez l’effet du paramètre α.
Remarque. Lorsque une ligne est nulle, ce qui correspond à une page sans
issue, ou une image, on remplace la ligne par (1/n, . . . , 1/n), ce qui veut dire
qu’on peut aller de façon indifférente vers tous noeuds du réseau. Ici, pour le
réseau considéré cela n’est pas nécessaire, mais c’est le cas en géneral. 2
3.5.1 Promenade aléatoire sur le Web.
3.6 un programme MATLAB.

function x = pagerank(U,G,p)
% PAGERANK Google’s PageRank
% pagerank(U,G,p) uses the URLs and adjacency matrix produced by SURFER,
% together with a damping factory p, (default is .85), to compute and plot
% a bar graph of page rank, and print the dominant URLs in page rank order.
% x = pagerank(U,G,p) returns the page ranks instead of printing.
% See also SURFER, SPY.
if nargin < 3, p = .85; end
% Eliminate any self-referential links
G = G - diag(diag(G));
% c = out-degree, r = in-degree
[n,n] = size(G);
c = sum(G,1);
r = sum(G,2);
% Scale column sums to be 1 (or 0 where there are no out links).
k = find(c~=0);
D = sparse(k,k,1./c(k),n,n);
% Solve (I - p*G*D)*x = e
e = ones(n,1);
I = speye(n,n);
x = (I - p*G*D)\e;
% Normalize so that sum(x) == 1.
x = x/sum(x);
% Bar graph of page rank.
shg
bar(x)
title(’Page Rank’)
% Print URLs in page rank order.
if nargout < 1
[ignore,q] = sort(-x);
disp(’ page-rank in out url’)
k = 1;
while (k <= n) & (x(q(k)) >= .005)
j = q(k);
disp(sprintf(’ %3.0f %8.4f %4.0f %4.0f %s’, ...
j,x(j),r(j),c(j),U{j}))
k = k+1;
end
end
Chapitre 4
Résumé MATLAB.
Auteur : Michel Cuer. (M. Cuer : attention il est indispensable de lire ce résumé devant un
ordinateur en effectuant les manipulations nécessaires à la compréhension)
A) Préliminaires.
Le sigle MATLAB signifie “matrix laboratory” et à l’origine ce logiciel était
utilisé, et l’est encore, pour la recherche en analyse numérique matricielle. La
partie analyse numérique matricielle repose sur les bibliothèques FORTRAN
du domaine public BLAS (basic linear algebra subroutines) et LAPACK (li-
near algebra package qui fait suite à LINPACK et EISPACK) disponibles à
l’adresse internet http ://www.netlib.org/lapack ainsi que sur des procédures
particulières aux grandes matrices creuses (contenant beaucoup de zéros) en
particulier celles de la bibliothèque C UMFPACK (Unsymmetric MultiFron-
tal method : voir http ://www.cise.ufl.edu/research/sparse/umfpack) pour
la résolution des grands systèmes linéaires creux, et celles de la bibliothèque
FORTRAN ARPACK (ARnoldi PACKage : voir http ://www.caam.rice.edu/software/ARPACK/)
pour le calcul de quelques valeurs propres de très grandes matrices creuses.
Les développements ultérieurs de ce logiciel en ont fait l’OUTIL de l’analyse
numérique et des bureaux d’études de l’industrie. MATLAB n’est pas gra-
tuit et est même très coûteux et les logiciels du domaine public, OCTAVE et
SCILAB, bien moins performants ont des syntaxes très voisines (octave en
particulier) permettant, le cas échéant, de faire quelques tests sans disposer
de MATLAB.
Il est indispensable de consulter la documentation en ligne pour utiliser mat-
lab et on peut recommander aussi les livres : Cleve Moler, 2004, Numerical
Computing with MATLAB, SIAM, Philadelphia (dont on peut récupérer une
version internet, avec des codes, à l’adresse http ://www.mathworks.fr/moler/,
via mozilla ; C. Moler, professeur d’analyse numérique, est le créateur du
logiciel et directeur scientifique de la société mathworks qui le commercia-
lise et l’améliore constamment ; ce livre est excellent à condition de faire les
57
58 CHAPITRE 4. RÉSUMÉ MATLAB.
exercices) ; D.J. Higham, N.J. Higham, 2005, Matlab Guide, Second Edition,
SIAM, Philadelphia (plutôt mathématique) et D.C. Hanselman, B.L. Little-
field, 2004, Mastering MATLAB 7 : Prentice Hall, Upper Saddle River, NJ
(plutôt complet).
B) Mise en train et tour d’horizon de la documentation en ligne.
Après avoir lancé MATLAB ou bien par la commande matlab& dans une
fenêtre ou bien au moyen de la souris après avoir repéré son emplacement
dans un des menus du bureau, on obtient une fenêtre où il n’est pas difficile
de constater ce que font par exemple les commandes :
> > 1+9
ans =
10
> > 4*8
ans =
32
> > A=[1 2 3; 4 5 6; 7 8 9], rand(’state’,0), x=rand(3,1), A*x, x’*A
...
> > xx=-pi:0.01:pi; plot(xx,sin(xx))
> > hold on, plot(xx,0), hold off
Il est important de comprendre que matlab, qui peut se comporter comme
une calculette, manipule des matrices, un scalaire étant une matrice 1×1.
Il n’y a aucune déclaration de type ou de dimension et les fonctions
size et length, permettent de connaître les dimensions
 d’un
 objet, la matrice
1 2 3
vide étant Av=[].Ici A est la matrice 3×3 A = 4 5 6  : les coefficients

7 8 9
d’une ligne sont séparés par des espaces ( ) ou des virgules (,) et les dif-
férentes lignes sont séparées par des points-virgules (;), l’ensemble étant
entre crochets ([ ]). L’instruction rand(’state’,0) initialise le générateur
de nombres pseudo-aléatoires, x est un vecteur colonne à 3 composantes, A*x
est le produit de A par x (vecteur colonne) et x’*A le produit de xT (vecteur
ligne) par A (vecteur ligne). À noter qu’il est possible de placer plusieurs ins-
tructions sur une ligne 1 à condition de les séparer par des virgules, auxquels
cas les résultats sont affichés, ou des points-virgules auxquels cas les résul-
tats ne sont pas affichés (c’est l’opposé de la convention de maple)... xx est
le vecteur ligne (−π, −π + 0.01, −π + 0.02, ..., “π 00 ), avec bien sûr des arrondis
qui font que par exemple la dernière composante xx(length(xx)) n’est pas
π mais 3.1384... (faire aussi, “pour voir”, plot(diff(diff(xx))) et consul-
1. Mais il me semble que pour la programmation, les experts matlab qui ont “le bon
style de programmation”, n’écrivent qu’une instruction par ligne.
59
ter la fonction linspace), et sin(xx) est le vecteur ligne (sin(−π), sin(−π +

0.01), sin(−π + 0.02), ..., sin(“π 00 )). plot(xx,sin(xx)) affiche le graphe de
sin(x) dans une fenêtre – la dernière ligne avec hold on, sert à ajouter le
graphe de 0 à cette figure –. Tout est discrétisé et les manipulations des
vecteurs et matrices font qu’on retrouve à peu de chose près les notations
familières de l’analyse numérique, sans qu’il soit nécessaire de coder de longs
programmes avec de nombreuses déclarations. Il faut cependant ajouter que
des codes Fortran ou C sont plus rapides.
Comme la fonction sin, toutes les fonctions élémentaires (trigonométriques,
logarithmes, exponentielles ...) et spéciales (Bessel, erf, intégrales elliptiques,
gamma, Legendre ...) dont on peut trouver les listes à partir de celle des
commandes classées par catégories dans la fenêtre Help, peuvent être appli-
quées à un vecteur ou une matrice et donnent comme résultat, le vecteur ou
la matrice dont les composantes ou les coefficients proviennent de l’action
de cette fonction sur les différentes composantes du vecteur initial ou sur les
coefficients de la matrice initiale. Dans le même ordre d’idées les opérateurs
* / ^, qui combinés avec des vecteurs ou (et) matrices ou scalaires ont le
sens habituel en mathématiques, lorsque ce sens existe (par exemple a*b n’a
pas de sens si a et b sont deux vecteurs colonnes ou deux vecteurs lignes,
mais si a est un vecteur colonne et b un vecteur ligne, b*a est un produit
scalaire si les dimensions sont les mêmes et a*b est une matrice) ont des
extensions très utilisées notés .* ./ .^ qui réalisent les opérations cor-
respondantes éléments par éléments pourvu que ce soit possible. Ainsi [1 4
6].^2 est [1 16 36] et [1 4 6].*[7 5 3] est [7 20 18]. Ce point est très
important lors des écritures de sous programmes : par exemple pour calculer
R 104 dx
l’intégrale −104 1+x 2 au moyen de la fonction quad, l’instruction quad(@(x)
1./(1+x.^2),-10000,10000) fonctionne alors que l’écriture plus naturelle

quad(@(x) 1/(1+x^2),-10000,10000) produit une erreur. Cela provient du
fait que quad utilise la fonction à intégrer (ici @(x) 1/(1+x^2)) de manière
vectorielle. Il faut le plus souvent vectoriser les fonctions scalaires qu’on
définit. On peut même comprendre dans le détail en tapant type quad qui
fournit tout le code de la fonction quad (beaucoup de fonctions sont de tels
codes mais le noyau d’algèbre linéaire, par exemple, est “précompilé”). À noter
aussi l’existence de fonctions de matrices comme expm. Concernant toujours
les matrices, il convient de préciser que ’ est l’opération de passage au trans-
posé et complexe conjugué (transconjugué) et que .’ est la transposition
stricte.
Le signe : est largement utilisé : A(:,2) est la deuxièmecolonnede A,
4 5
A(1,:) la première ligne, A(2:3,1:2) la sous matrice extraite , 4:8
7 8
est le vecteur ligne [4 5 6 7 8]. Les matrices sont rangées en mémoire co-
lonnes par colonnes ; A(5) est donc ici 5 et A(5)=10 équivaut à A(2,2)=10. Si
z est un vecteur ou une matrice w=z(:) est un vecteur colonne contenant tous
les éléments de z dans l’ordre où ils sont en mémoire. À partir d’opérateurs
booléens (logiques) et de vecteurs, matrices et scalaires
 fabrique des vec-
on 
1 1 1
teurs ou matrices booléennes : B=A<=5 est  1 1 0 (attention ces 1
0 0 0
sont des “true”, vrai et ces 0 sont des “false”, faux et non des entiers ou des flot-
tants – il n’y a pas de déclarations de type mais il y a des types en matlab qui
sont produits par le “contexte” – attention aussi de manipuler avec la bonne
matrice A définie plus haut par exemple en la réinitialisant en utilisant la pe-
tite flèche verticale vers le haut du clavier, ou en copiant à la souris l’instruc-
tion convenable de la fenêtre “Command History” dans la fenêtre “Command
Window”). De plus si C et D sont deux matrices de mêmes dimensions, C étant
par exemple de type réel (flottant double) et D de type booléen, alors C(D)
donne un vecteur colonne qui contient tous les coefficients de C pour lesquels
le coefficient de D de même indice est vrai dans l’ordre du rangement des
colonnes de C ; par exemple A(A<=5)  est [1 42 5 3]’. Aussi l’instruction
3 2 1
A(A<=5)=[3 5 2 4 1] fournit A =  5 4 6  (et A(A<=5)=11 fournit A =
7 8 9
 
11 11 11
 11 11 6  car un scalaire peut toujours être apparié avec une matrice
7 8 9
 
4 5 6
–A+3 est  7 8 9 –). On a là un exemple d’indexation booléenne
10 11 12
et une autre illustration, si xx=linspace(-pi,pi,100), yy=sin(xx), est le
fait que zz=max(0,yy) équivaut à zz=yy, zz(zz<0)=0, mais cette deuxième
possibilité est plus lente que la première.
Il y a deux façons de définir des sous programmes en matlab en plus de la com-
mande inline qui n’est utilisable que par compatibilité avec les versions anté-
rieures. La première, à n’utiliser que pour des fonctions simples, est l’usage de
fonctions dites anonymes comme dans 2 f=@(x,y) cos(y*x)./(1+x.^2);
g=[]; for y=-5:0.1:5, g=[g, quad(f,-10000,10000,[],[],y)]; end, plot(-5:0.1:5
L’autre façon, la plus courante, consiste à taper, par exemple au moyen de
l’éditeur, le fichier suivant, dit “M-fonction”, dont le nom doit être f.m (on
peut rencontrer aussi function [args1,args1,...]=nom(arge1,arge2,...)) :
2. La fonction est f=@(x,y) cos(y*x)./(1+x.^2) et le résultat de l’ensemble est

π exp(−|y|) ce qu’il est facile de le contrôler avec les instructions, à la suite de celles
indiquées, hold on, plot(-5:0.1:5,pi*exp(-abs([-5:0.1:5]))).
61
function z=f(x,y)
y=cos(y*x)./(1+x.^2);
et le calcul est fait au moyen des instructions suivantes lancées dans la fe-
nêtre “Command Window” comme plus haut : g=[]; for y=-5:0.1:5, g=[g,
quad(@f,-10000,10000,[],[],y)]; end, plot(-5:0.1:5,g). On fait ici
référence à la poignée (handle) @f de la “M-fonction” définie dans le fi-
chier f.m. Il est important de savoir que ce fichier sera dans le répertoire
visible dans la fenêtre “Current Directory” et il est donc judicieux de créer
un répertoire de travail appelé par exemple temp_matlab (la commande
unix est mkdir temp_matlab ; !mkdir temp_matlab peut se faire à partir de
matlab ...) et de faire en sorte que le “Current Directory” soit toujours
temp_matlab ou un de ses sous-répertoires. Si nécessaire, il peut être utile
de consulter les commandes eval et feval et de lancer type fcnchk.
Le troisième et dernier point non trivial, à propos des sous programmes,
concerne le fait que par l’intermédiaire des arguments varargin (en entrée)
et varargout (en sortie) on peut définir des sous programmes à listes
d’arguments non figées a priori . Ceci est utilisé dans l’exemple précé-
dent et cela se comprend en lançant type quad pour constater que la première
ligne de quad.m est (on peut savoir où se trouve ce code en lançant which
quad) : function [Q,fcnt] = quad(funfcn,a,b,tol,trace,varargin) et
que, dans ce sous programme, funfcn est calculée par exemple dans les ins-
tructions (ne pas trop chercher à éclaircir l’usage de fcnchk ; on peut consi-
dérer que f est funfcn ; nargin et nargout sont évidemment les nombres
d’arguments d’entrée et de sortie ; de plus les lignes commençant par % sont
des commentaires et il est possible d’introduire des blocs entiers de commen-
taires en les plaçant entre %{ et }%) :
f = fcnchk(funfcn);
if nargin < 4 || isempty(tol), tol = 1.e-6; end;
if nargin < 5 || isempty(trace), trace = 0; end;
% Initialize with three unequal subintervals.
h = 0.13579*(b-a); x = [a a+h a+2*h (a+b)/2 b-2*h b-h b]; y = f(x,
varargin{:}); fcnt = 7;
La variable supplémentaire y qui a été utilisée plus haut, est vue, dans la
fonction quad, comme varargin, varargin{1} en fait, et il peut y en avoir
autant qu’on veut varargin{1}, varargin{2}, ... et la même chose est vraie,
avec varargout pour les arguments de sortie. On notera aussi plus haut,
l’usage de vides [] pour tol et trace. Pour plus de détails, il faut consulter
la documentation en ligne, ainsi que les codes des “demos” ou du livre de
Moler.
Entre deux calculs il peut être nécessaire de libérer de la place mémoire –
la liste des variables conservées en mémoire avec leurs tailles et leurs valeurs
se trouve dans la fenêtre “Workspace” – et cela se fait au moyen de l’ins-

truction clear : clear efface tout, clear nom efface la variable nom. Cela
peut être important si on utilise des noms de variables qui sont des noms de
commandes (et ceci est possible sauf pour les noms que donne l’instruction
iskeyword qui sont les mots clés du langage à savoir ’break’ ’case’ ’catch’
’continue’ ’else’ ’elseif’ ’end’ ’for’ ’function’ ’global’ ’if’ ’otherwise’
’persistent’ ’return’ ’switch’ ’try’ ’while’ ; il peut être utile d’éviter aussi
les constantes ’ans’ ’eps’ ’intmax’ ’intmin’ ’realmax’ ’realmin’ ’pi’ ’i’ ’j’
’inf’ ’NaN’ ’computer’ ’version’ ) 3 . Si par exemple on pose quad=5, il n’est
plus possible d’utiliser quad pour calculer une intégrale définie sans avoir au
préalable exécuter la commande clear quad. Enfin la commande clc efface
la fenêtre “Command Window” et la commande close all efface toutes les
figures.
En ce qui concerne l’environnement il faut aussi observer ce qui résulte d’un
clic sur une flèche du genre % puis - sur le coin haut droit d’une fenêtre,
et encore une fois les zones “Current Directory”, “Workspace”, “Command
History”, les boutons “couper, copier, coller” ainsi que le menu “Desktop ->
Desktop Layout -> Default” pour tout remettre en ordre si nécessaire. Il
est important d’arrêter matlab à la fin d’une séance : si non un bureau trop
chargé peut bloquer un futur démarrage.
Ce qui suit, jusqu’à la fin de la page 4, correspond à la version de MATLAB
utilisée durant l’année universitaire 2005-2006 et depuis il y a eu plusieurs
nouvelles versions. C’est un bon exercice que de comparer le contenu “du
Help” actuel avec ce qui suit et de corriger en conséquence. Les corrections
sont mineures.
La fenêtre “Help” permet d’avoir un sentiment de maîtrise de l’outil. Cette
aide est composée des parties suivantes (en plus des “Release Notes”, “Ins-
tallation” et des documentations des boîtes à outils dont on ne parlera pas
ici, mais qui sont plus simples) :
Getting Started , introduction de 188 pages très claire décomposée en In-
troduction, Matrices and Arrays, Graphics, Programming, Creating Graphical
User Interfaces et Desktop Tools and Development Environment ;
Examples (la liste d’exemples) ;
Desktop Tools and Development Environement ;
Mathematics décomposée en Matrices and linear algebra, Polynomials and
3. Dans cette première version on ne donne pas d’autres indications condensées sur le
langage et à la place on demande de consulter la documentation en ligne concernant ces
mots clés et ces constantes ainsi que sur la commande format. Il faut ajouter qu’un nom de
variable doit commencer par une lettre (les majuscules et les minuscules sont différentes)
et est composé de lettres, de chiffres et éventuellement du symbole _ le nombre maximal
de symboles reconnus dans ce nom étant les namelengthmax (63) premiers.
63
Interpolation (où il a aussi des interpolations à plusieurs variables), Fast

Fourier Transform(FFT), Function Functions (où il y a des outils élémen-
taires pour calculer des zéros, des minimums et des intégrales), Differential
Equations, Sparse matrices (les matrices creuses) et enfin Examples ; il faut
rappeller ou préciser ici qu’en machine on manipule des entiers codés en bi-
naire 4 et, plus important encore du point de vue de l’analyse numérique,
certains rationnels dits flottants codés sous forme de mantisses et exposants
en simple ou double précision 5 ; par défaut matlab fait des calculs en double
4. Sur 8, 16, 32 ou 64 chiffres binaires appelés bits — cela a été fonction de la technologie
et semble ne plus évoluer : 8 bits font un octet et chaque octet a une adresse sur une
machine dite 32 bits — : s’il s’agit d’entiers signés, le dernier bit sert à coder le signe ;
(b6 26 + ... + b0 ) si b7 = 0
ainsi b7 b6 ...b0 = (tous les bi sont 0 ou 1) si bien
−(2 − b7 27 − b6 26 − ... − b0 ) si b7 = 1
8
que le plus grand entier sur 8 bits est 27 − 1 et le plus petit −(28 − 27 ) = −27 , de la même
manière les entiers signés sur 16, 32 et 64 bits vont de −215 à 215 − 1, −231 à 231 − 1 et
de −263 à 263 − 1 ; bien évidemment les entiers non signés sont aussi utilisés et vont de 0
à 28 − 1 sur 8 bits et etc...
5. En simple précision ces flottants sont codés en général — cela a été fonction de la
technologie et ne change plus maintenant — sur 32 bits (4 octets de 8 bits) en une mantisse
et un exposant, un des octets servant à coder l’exposant et le signe : si b31 , b30 , ..., b0
représente ces bits le nombre est défini comme suit : “si b30 27 + ... + b23 = 255 mais
b22 ...b0 6= 0, la machine dit NaN (not a number) ; si b30 27 + ... + b23 = 255 et b22 ...b0 = 0,
on convient de dire que le nombreest +∞ si b31= 0 et −∞ si b31 = 1 ; si 1 ≤ b30 27 +
+ si b31 = 0 7
... + b23 ≤ 254, le nombre vaut : (1 + b222 + ... + 2b23
0
)2b30 2 +...+b23 −127 ;
− si b31 = 1
si b30 ...b23 = 0 et b22 ...b0 = 0, le nombre est zéro (on dit ± zéro selon que b31 est 0
1) ; si b30 ...b23 = 0 et b22 ...b0 6= 0, le nombre est dit dénormalisé, sa “valeur” est
ou
+ si b31 = 0
( b222 + ... + 2b230
)2−126 mais dans les opérations habituelles on considère
− si b31 = 1
que ce nombre est nul” ; ainsi en simple précision, le plus petit nombre machine non
négligeable devant 1, pour l’addition, est 2123 ' 1.2 10−7 , le plus petit nombre machine en
valeur absolue est 2−126 ' 1.2 10−38 et le plus grand ' 3.4 1038 .
En double précision, les flottants sont codés sur 64 bits (8 octets) et la règle pour
b63 b62 ...b0 est (l’exposant et la mantisse apparaissent dans un même octet ! ! !) : “si b62 210 +
... + b52 = 2047 mais b51 ...b0 6= 0, la machine dit NaN (not a number) ; si b62 210 + ... + b52 =
2047 et b51 ...b0 = 0, on convient de dire que le nombreest +∞ si b63 = 0 et −∞ si
+ si b63 = 0
b63 = 1 ; si 1 ≤ b62 210 + ... + b52 ≤ 2046, le nombre vaut : (1 + b251 + ... +
− si b63 = 1
b0 b62 210 +...+b52 −1023
252 )2 ; si b62 ...b52 = 0 et b51 ...b0 = 0, le nombre est zéro (on dit ± zéro
selon que b63 est 0 ou 1) ; sib62 ...b52 = 0 et b51 ...b0 6= 0, le nombre est dit dénormalisé, sa
+ si b63 = 0
“valeur” est ( b251 + ... + 2b52
0
)2−1022 mais dans les opérations habituelles on
− si b63 = 1
considère que ce nombre est nul” : ainsi en double précision, le plus petit nombre machine
non négligeable devant 1, pour l’addition, est eps= 2152 ' 2.2 10−16 (mais attention si
1 + 2153 fait 1 en machine 1 − 2153 ne fait pas 1, avec quelque chose du même genre en
simple précision : utiliser la nouvelle fonction matlab single pour expérimenter cela si le
temps le permet), le plus petit nombre machine en valeur absolue est 2−1022 ' 2.25 10−308
précision, mais on peut maintenant utiliser la simple précision bien que ce

ne soit pas très souple (le dernier paragraphe du chapitre d’introduction de
Moler est consacré au codage des flottants) ;
Data Analysis (où on trouve des éléments de statistiques, des outils pour
calculer des différences finies et la transformée de Fourier) décomposée en
Fundamentals of Data Analysis, Data Fitting Using Linear Regression, Ana-
lyzing Time Series from the Command Line, Using the Time Series Tools
GUI et Examples ;
Programming, en 750 pages, décomposée en Data Structures, Data Types,
Basic Program Components, M-File Programming, Types of Functions, Data
Import and Export, Error Handling, Classes and Objects, Scheduling Program
Execution with Timers, Improving Peformance and Memory Usage, Program-
ming Tips, Examples ;
Graphics décomposée en MATLAB Plotting Tools, Data Exploration Tools,
Annotating Graphs, Basic Plotting Commands, Creating Specialized Plots,
Displaying Bit-Mapped Images, Printing and Expoting, Handle Graphics Ob-
jects (à ce propos le graphique est un domaine où il y a beaucoup de pro-
grammation objet), Figure Properties, Axes Properties et Examples ;
3-D visualization décomposée en Creating 3-D Graphs, Defining the View,
Lighting as a Visualization Tool, Transparency, Creating 3-D Models with
Patches, Volume Visualization Techniques et Examples ;
Creating Graphical User Interfaces décomposée en Getting Started with GUIDE,
Creating a GUI, Laying Out GUIs and Setting Properties, Programming
GUIs, GUI Applications, Working with Callbacks(Draft) et Examples ;
Functions – Categorial List décomposée en Desktop Tools and Deve-
lopment Environment, Mathematics, Data Analysis, Programming and Data
Types, File I/O, Graphics, 3-D Visualization, Creating Graphical User Inter-
faces, External Interfaces ;
Functions – Alphabetical List (très utile) ;
Handle Graphics Property Browser , outil très utile pour se renseigner
sur les propriétés des objets graphiques ;
External Interfaces qui n’est utile, comme la partie suivante, que pour des
travaux très volumineux avec des “jonctions” avec FORTRAN ou (et) C++
et le plus grand 2(1 − 2153 )21023 ' 1.8 10308 . On pourrait parler aussi d’architecture “little
endian” et “big endian” ; il suffit de savoir qu’il s’agit d’un problème d’ordre de rangement
des bits dans l’octet.
Pour voir tous les caractères ”standards” et visibles du code ACSII (American Stan-
dard Code for Information Interchange), faire, comme indiqué dans le livre de Moler :
x=reshape(32:127,32,3), char(x) (les 31 premiers caractères du code, caractères de
contrôle, ainsi que le 128ième en principe, ne sont pas visibles) mais vous pouvez aussi re-
garder les 129ième ... 256ième caractères avec char([129:256]) ; nos accents s’y trouvent.
65
ou(et) java ;
External Interfaces references
External Interfaces Reference
Release Notes
Printable Documentation (PDF) : fichiers qui sont sur internet.
Pour ne pas se noyer au début, il vaut se servir de Functions – Alphabe-
tical List, Functions – Categorial List, Handle Graphics Property
Browser. En cliquant sur un mot on est conduit vers les “bonnes” défini-
tions, et bien sûr il est très important de consulter des exemples de codes,
ceux du livre de Moler par exemple.
C) Exemple d’utilisation de matlab presque comme une calculette.

Énoncés de quelques exercices de calcul numérique suivi de leurs corrigés. Il
est conseillé de les faire en s’aidant des corrigés et en consultant la documen-
tation en ligne, à partir des listes alphabétiques et par catégories des fonctions
matlab. Des espaces blancs peuvent servir à compléter ces informations tout
à fait incomplètes.
1) Si on convient de dire que le premier nombre premier est 2, donner la liste
des 128 premiers d’entre eux.
2) Donner le déterminant, l’inverse, les divers conditionnements pour la ré-
solution de systèmes linéaires, de la matrice A=pascal(7) puis les décom-
positions LU, QR et de Cholesky de A et préciser ce qu’est A\b lorsque
b=A*ones(7,1). Ici ones(7,1) est le vecteur de R7 dont toutes les com-
posantes sont 1. Refaire la dernière manipulation ... A\b ... avec la matrice
A=hilb(15).
3) Calculer et afficher les polynômes pn (x) de degrés n =0, 1, 7, 9 qui ajustent
les valeurs du tableau suivant au sens des moindres carrés, c’est dire mini-
Pi=10
misent i=1 (pn (xi ) − yi )2 (tableau qui peut être obtenu par les instructions
matlab x=(0.1:0.1:1)’, rand(’state’,0), y=-3+6*rand(10,1) :
xi 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
yi 2.7008 -1.6132 0.6411 -0.0841 2.3478 1.5726 -0.2612 -2.8890 1.9284 -0.331
4) a) Calculer et afficher les différents polynômes d’interpolation que per-
1+4x2
met matlab de la fonction x → U (x) = − cosh(x) 2 au points x=-5,-4,-3,-
2,1,0,1,2,3,4,5.
b) Dans la documentation en ligne, partie “Mathematics”, chapitre “Po-
lynomials and Interpolation”, paragraphe “Interpolation”, lire les sections “
Two-Dimensional Interpolation” et “Comparing Interpolation Methods” et
exécuter les manipulations proposées concernant l’interpolation à deux va-
riables sur une grille régulière.
c) Dans la documentation en ligne, dans le même paragraphe, un peu loin,
lire la section “Triangulation and Interpolation of Scattered Data” et exécu-
ter les manipulations proposées concernant le calcul d’enveloppes convexes,
la triangulation de Delaunay et l’interpolation à deux variables à partir de
données obtenues sur une grille irrégulière.
67
% 1) Calculs de nombres premiers

N=128; k=2*round(N/2)+1; while size(primes(k))<N, k=k+1; end; liste=primes(k)
disp(’fin question 1, appuyez sur une touche pour continuer’), pause,
close all, clear, clc
% 2) Analyse numérique matricielle
A=pascal(7) % lire les C(n,p) dans les “anti-diagonales”
det(A), inv(A), [cond(A,1) cond(A) cond(A,’fro’) cond(A,’inf’)]
[L1,U1,P1]=lu(A), [L2,U2]=lu(A), norm(L2-P1’*L1) % L2 est en fait
P1’*L1
[Q1,R1]=qr(A), [Q2,R2,E2]=qr(A), chol(A)
b=A*ones(7,1), x=A\b % est la solution de Ax=b obtenue par élimination
de Gauss c’est à dire par
%décomposion LU
norm(A*x-b), norm(x-ones(7,1))
n=15, A=hilb(n), b=A*ones(n,1), x=A\b, norm(A*x-b), norm(x-ones(n,1))
% 3) Ajustement aux moindres carrés par un polynôme
x=(0.1:0.1:1)’, rand(’state’,0), y=-3+6*rand(10,1), xx=(0.1:0.01:1)’;
hold on, for n=[0 1 7 9], plot(x,y,’o’,xx,polyval(polyfit(x,y,n),xx)),
end, hold off
% 4a) Interpolation à une variable
U=@(x) -(1+4*x.^2)./cosh(x).^2; x=-5:1:5; y=U(x); xx=-5:0.05:5;
figure(1), plot(x,y,’o’,xx,U(xx),xx,interp1(x,y,xx,’nearest’)), title(’constant
par morceaux’)
figure(2), plot(x,y,’o’,xx,U(xx),xx,interp1(x,y,xx)), title(’linéaire
par morceaux’)
figure(3), plot(x,y,’o’,xx,U(xx),xx,interp1(x,y,xx,’spline’)), title(’spline’)
figure(4), plot(x,y,’o’,xx,U(xx),xx,interp1(x,y,xx,’pchip’)), title(’cubique
par morceaux’)
figure(5), plot(x,y,’o’,xx,U(xx),xx,interp1(x,y,xx,’v5cubic’)), title(’cubique
version matlab 5’)
% il y a aussi (mais le résultat n’est pas bon)
figure(6), plot(x,y,’o’,xx,U(xx),xx,interpft(y,size(xx,2)))
title(’reéchantillonnage de la transformée de Fourier’)
% on a mieux avec
figure(7), z=-5:0.25:5; plot(z,U(z),’o’,xx,U(xx),xx,interpft(U(z),size(xx,2)))
title(’ça peut marcher’)
disp(’fin question 4a), appuyez sur une touche pour continuer’),

% 4b) Interpolation à deux variables sur grille régulière
[x,y]=meshgrid(-3:1:3); z=peaks(x,y);
[xi,yi] = meshgrid(-3:0.25:3);
figure(1), zi=peaks(xi,yi); subplot(2,1,1), surf(xi,yi,zi)
subplot(2,1,2), contour(xi,yi,zi)
figure(2), zi=interp2(x,y,z,xi,yi,’nearest’); subplot(2,1,1), surf(xi,yi,zi)
figure(3), zi=interp2(x,y,z,xi,yi,’linear’); subplot(2,1,1), surf(xi,yi,zi)
figure(4), zi=interp2(x,y,z,xi,yi,’cubic’); subplot(2,1,1), surf(xi,yi,zi)
disp(’fin question 4b), appuyez sur une touche pour continuer’),
% 4c) Interpolation à deux variables sur grille irrégulière
load seamount, plot(x,y,’.’,’markersize’,12)
k = convhull(x,y); hold on, plot(x(k),y(k),’-r’), hold off
xlabel(’Longitude’), ylabel(’Latitude’), grid on
tri = delaunay(x,y); hold on, triplot(tri,x,y), hold off
figure, hidden on, trimesh(tri,x,y,z), grid on
xlabel(’Longitude’); ylabel(’Latitude’); zlabel(’Depth in Feet’)
figure, [xi,yi] = meshgrid(210.8:.01:211.8,-48.5:.01:-47.9);
zi = griddata(x,y,z,xi,yi,’cubic’); % ici il y a une interpolation
[c,h] = contour(xi,yi,zi,’b-’); clabel(c,h), xlabel(’Longitude’),
ylabel(’Latitude’)
% les autres manipulations, qui concernent les commandes dsearch,
tsearch et voronoi
% sont laissées au lecteur
disp(’fin question 4c), appuyez sur une touche pour continuer’),
69
2
1+4x
5) La fonction x → U (x) = − cosh(x) 2 a trois extremums : un maximum
local en x = 0 et des minimums globaux en x = −xm et x = xm où 21 <

xm < 2 (pour établir cela, on note que la dérivée de U est x → U 0 (x) =
2 ) sinh(x)
−2 4x cosh(x)−(1+4x
cosh(x)3
et donc ses extremums sont les racines de tanh(x) −
4x 4x 2
1−4x
1+4x2
; or il est facile de voir que 1+4x 2 – fonction dont la dérivée est 4 (1+4x2 )2
– est croissante de 0 à 1 pour x variant de 0 à 21 et décroissante de 1 à 0 pour

x variant de 21 à +∞ et qu’on a tanh(x) < x < 1+4x 4x 1
2 pour 0 < x < 2 ; alors
le résultat découle de tanh( 12 ) − 1 < 0 et 0.1640 ' tanh(2) − 17 8

> 0).
4x
a) Calculer xm comme racine de g(x) = tanh(x)− 1+4x 2 située entre x = 0.5
et x = 2 et U (xm ) = U (−xm ).
b) Retrouver ce résultat en calculant xm comme l’abscisse du minimum
de U (x) située entre x = 0.5 et x = 2.
c) Pour U (xm ) < E < 0, trouver toutes les racines de E − U (x) = 0
(distinguer les cas U (xm ) < E < 1, E = −1 et −1 < E < 0). Donner les
résultats numériques pour E = −0.5 (racine xa dans ]0, 5[), E = −1 (racine
xb dans ]xm , 5[) et E = −1.5 (racines xc1 dans ]0, xm [ et xc2 dans ]xm , 5[).
1+4x2
6) Toujours avec U (x) = − cosh(x) 2 , calculer les intégrales :
Z xa Z xc2
dx dx
Ta = 4 p |E=−0.5 , Tc = 2 p |E=−1.5
0 E − U (x) xc1 E − U (x)
Ra
Ta , qui est aussi 2 −xa a √ dx |E=−0.5 , est la période du mouvement d’un
E−U (x)
point matériel de masse 1 et d’énergie E = −0.5 dans le potentiel U (x), de
même Tc est la période du mouvement d’un point matériel de masse 1 et
d’énergie E = −1.5 dans le potentiel U (x) : voir à ce sujet le paragraphe “11
Mouvement linéaire” (chapitre III, Intégration des équations du mouvement)
du livre L. Landau, E. Lifchitz, 1966, Mécanique : Mir, Moscou (on y trouve,
1
en exercice, le cas, calculable à la main, du potentiel U (x) = − cosh(x)2 ).
7a) Résoudre les deux problèmes de conditions initiales pour une équation
différentielle du deuxième ordre suivants, afficher les résultats et retrouver
les périodes des oscillations (qu’on a déjà calculées) :

2 2
dx dU 4x cosh(x) − (1 + 4x ) sinh(x) dx p 
= − (x) = 2 , x(0) = xm , (0) = 2(E − U (xm )) pour E =
dt2 dx cosh(x)3 dt 
(le choix de dx
dt
(0) provient de la conservation de l’énergie 12 ( dx
dt
(t))2 + U (x(t))
dans le mouvement).
7b) Résoudre les deux systèmes différentiels de Lorenz (d’abord dans un cas
qui montre un comportement chaotique puis dans un autre qui tend vers un
comportement périodique) :
− 38 y1 + y2 y3
     
y1 y1 (0) ∈ [5, 35]
d 
y2  =  −10y2 + 10y3  ,  y2 (0) ∈ [−39, 5] 
dt
y3 −y2 y1 + (28 puis 99.65)y2 − y3 y3 (0) ∈ [−5, 35]
les valeurs initiales étant choisies de manière aléatoire dans les intervalles
indiqués.
71
% 5) Calculs de zéros et d’extremums de fonctions d’une variable

réelle
% 5a)
U=@(x) -(1+4*x.^2)./cosh(x).^2;
xx=-5:0.01:5; plot(xx,U(xx),xx,-0.5,xx,-1,xx,-1.5); title(’Potentiel’)
g=@(x) tanh(x)-4*x./(1+4*x.^2); x_m=fzero(g,[0.5 2]), U_m=U(x_m)
% 5b)
fminbnd(U,0.5,2), x_m-ans
% 5c)
f=@(x,E) E-U(x);
x_a=fzero(f,[0 5],[],-0.5) % cas E=-0.5: il y a deux racines -x_a
et x_a
x_b=fzero(f,[x_m 5],[],-1) % cas E=-1: il y a trois racines -x_b,
0, x_b
x_c1=fzero(f,[0 x_m],[],-1.5) % cas E=-1.5:
x_c2=fzero(f,[x_m 5],[],-1.5) % il y a 4 racines -x_c2 -x_c1 x_c1
x_c2
disp(’fin question 5), appuyez sur une touche pour continuer’), pause
% 6) Calculs d’intégrales
h=@(x,E) 1./sqrt(2*(E-U(x))); 4*quad(h,0,x_a,[],[],-0.5), T_a=4*quadl(h,0,x_a,[],[],
% Les deux calculs donnent pratiquement les mêmes résultats et pour
éviter la singularité faire
hp=@(y,E,x_a) y./sqrt(2*(E-U(x_a-y.^2))); T_a=8*quad(hp,0,sqrt(x_a),[],[],-0.5,x_a)
8*quadl(hp,0,sqrt(x_a),[],[],-0.5,x_a)
% 2*quad(h,-x_a,x_a,[],[],-0.5), 2*quadl(h,-x_a,x_a,[],[],-0.5) %
deux vérifications de plus
T_c=2*quad(h,x_c1,x_c2,[],[],-1.5)
% avec quad(h,x_c1*(1+eps),x_c2*(1-eps),[],[],-1.5) on évite le message
d’erreur et on trouve le même résultat
disp(’fin question 6), appuyez sur une touche pour continuer’), pause
% 7a) Résolution de problèmes de conditions initiales de solutions
périodiques
Up=@(t,x,x0) [x(2);(8*x(1).*cosh(x(1))-2*(1+4*x(1).^2).*sinh(x(1)))./cosh(x(1)).^3]
x0=[x_m;sqrt(2*(-0.5-U(x_m)))];
% Faire le fichier events.m suivant:
% function [val,isterm,dir]=events(t,x,x0)
% val=x(1)-x0(1); isterm=1; dir=1;
opts=odeset(’events’,@events);
[t,x,te,xe]=ode45(Up,[0 2*T_a],x0,opts,x0); te, figure(2), plot(t,x(:,1))
title([’E=-0.5 T=’,num2str(T_a)])
% et te est bien voisin de T_a
x0=[x_m;sqrt(2*(-1.5-U(x_m)))];
[t,x,te,xe]=ode45(Up,[0 2*T_c],x0,opts,x0); te, figure(3), plot(t,x(:,1))
title([’E=-1.5 T=’,num2str(T_c)])
% et te est voisin de T_c
% Pour E=-1, normalement il faut un temps infini pour atteindre x=0
à partir de x=x_m , mais les
% erreurs d’arrondi font que ceci est impossible à illuster (de l’importance
des bases théoriques)
x0=[x_m;sqrt(2*(-1-U(x_m)))]; opts=odeset(’RelTol’,1e-3,’AbsTol’,1e-6);
[t,x]=ode113(Up,[0 20],x0,opts,x0); figure(4), subplot(2,1,1), plot(t,x(:,1))
title(’E=-1: Ces figures devraient être presque identiques’)
opts=odeset(’RelTol’,1e-10,’AbsTol’,eps);
[t,x]=ode113(Up,[0 20],x0,opts,x0); subplot(2,1,2), plot(t,x(:,1))
% 7b) Résolution de problèmes de conditions initiales pour le sys-
tème de Lorenz
F=@(t,y) [-8/3 0 y(2); 0 -10 10; -y(2) 28 -1]*y
% puis (faire les mêmes manipulations: ce n’est plus chaotique)
% F=@(t,y) [-8/3 0 y(2); 0 -10 10; -y(2) 99.65 -1]*y
sol=ode45(F,[0 50],[rand*30+5;rand*35-30;rand*40-5]);
xx=0:0.01:50; yy=deval(xx,sol);
figure(1), plot(xx,yy), figure(2), plot3(yy(1,:),yy(2,:),yy(3,:))
figure(3), comet3(yy(1,:),yy(2,:),yy(3,:))
% on peut faire aussi
figure(4), opts = odeset(’OutputFcn’,@odephas3);
ode45(F,[0 50],[rand*30+5;rand*35-30;rand*40-5],opts);
disp(’fin question 7b), appuyez sur une touche pour continuer’),
73
8) Résoudre le problème aux limites, dont la solution exacte est (1−x) exp(x) :
−y 00 + xy = (1 + 2x − x2 ) exp(x), y(0) = 1, y(1) = 0.
9a) Le fichier train.mat (qu’on trouve dans le répertoire $MATLAB/toolbox/matlab/audiovideo/,

par exemple /usr/local/matlab/toolbox/matlab/audiovideo/ ou /usr/local/matlab71/toolbox
est le son d’un train qu’on peut jouer, sur un ordinateur équipé d’une carte
son, au moyen des instructions matlab : load train; sound(y,Fs). Afficher
ce signal ainsi que l’amplitude de son spectre de Fourier. R∞
9b) Évaluer au moyen de la procédure fft, la transformée de Fourier −∞ exp(−2iπλx)U (x)dx
sur une plage de valeurs de λ “significatives” et comparer le temps de calcul
avec celui que donne l’utilisation de la procédure quad.
10a) Calculer les valeurs propres et les vecteurs propres de la matrice A=pascal(7).
Appliquer aussi la procédure matlab schur à cette matrice et commenter.
Même question avec la matrice B=[1 2 3; 4 5 6; 7 8 9]. Expérimenter le
calcul des valeurs propres de la matrice C=gallery(5).
10b) Les instructions matlab load gatlin, figure(1), image(X), colomap(map),
title(caption) affichent une photographie des principaux créateurs de l’ana-
lyse numérique matricielle. Calculer la décomposition en valeurs singulières
de la matrice X (de taille 640x480) et afficher l’image obtenue en ne conservant
que les 100 premières valeurs singulières (au lieu de 480). Une procédures de
type “interface utilisateur graphique” (“gui” en anglais) concernant ce calcul
est donnée plus loin.
11) Résoudre le problème de Dirichlet homogène −∆u(x, y) = 1 pour (x, y) ∈
Ω, u(x, y) = 0 pour (x, y) ∈ ∂Ω frontière de Ω, le domaine Ω étant le carré
] − 1, 1[×] − 1, 1[ auquel on a enlevé une partie en forme d’ailes de papillon
∂2 ∂2
et ∆ = ∂x 2 + ∂y 2 l’opérateur Laplacien. On utilisera les procédures matlab
1
numgrid, delsq et on affichera le maillage (par exemple avec un pas h = 30 =
hx = hy ) et la forme de la matrice du problème au moyen de la procédure
spy et la solution à la fois au moyen des procédures contourf et surf (ou
surfl). Il faut préciser aussi ici que le Laplacien discret d’une fonction U ,
approximation du Laplacien ∆ en un noeud (ih, jh), (i, j) ∈ Z2 de la grille
est ∆h U (ih, jh) = U ((i−1)h,jh)+U (ih,(j−1)h)−4U (ih,jh)+U
h2
((i+1)h,jh)+U (ih,(j+1)h)
.
% 8) Problèmes aux limites pour les équations différentielles

f=@(x,y) [y(2); x.*y(1)-(1+2*x-x.^2).*exp(x)];
cl=@(ya,yb) [ya(1)-1; yb(1)];
solinit.x=0:0.1:1; solinit.y=[1-(0:0.1:1); -ones(1,11)];
sol = bvp4c(f,cl,solinit);
x = linspace(0,1); y = deval(sol,x); plot(x,y(1,:));
norm((1-x).*exp(x)-y(1,:))
% avec solinit.x=0:0.01:1; solinit.y=[1-(0:0.01:1); -ones(1,101)];
la
% précision est plus grande
disp(’fin question 8), appuyez sur une touche pour continuer’), pause,
% 9a) Transformée de Fourier rapide
load train; sound(y,Fs), n=size(y,1); t=(0:n-1)/Fs; plot(t,y)
Y=fft(y); f=(0:n/2)*Fs/n; figure(2), plot(f,abs(Y(1:n/2+1)))
% on observe 6 pics: 704Hz, 886Hz, 1166Hz, 2115Hz, 2659Hz, 3111Hz.
% 9b) Transformée de Fourier rapide
U=@(x) -(1+4*x.^2)./cosh(x).^2;
N=8192; Xmax=20; Fs=(N-1)/Xmax; x=linspace(0,Xmax,N); y=U(x); plot(x,y)
tic, Y=2/Fs*fft(y); toc, f=(0:100)*Fs/N;
% f=(0:30)*Fs/N; plot(f,real(Y(1:31))) est aussi intéressant
g=@(x,lambda) -cos(2*pi*lambda*x).*(1+4*x.^2)./cosh(x).^2;
tic
for i=1:length(f)
Ye(i)=2*quad(g,0,Xmax,[],[],f(i));
end
toc
plot(f,real(Y(1:101)),f,Ye), legend(’fft’,’quad’)
[norm(real(Y(1:101))-Ye), norm(Ye)]
% 10a) Calcul de valeurs propres
format short e, A=pascal(7), [V,D]=eig(A), [U,T]=schur(A) % même
résultat
B=[1 2 3; 4 5 6; 7 8 9], [V,D]=eig(B), [U,T]=schur(B), B*B’-B’*B
% cette matrice n’est pas normale et la décomposition de Schur ne
donne que les valeurs propres
C=gallery(5), C^4, C^5, condeig(C), [eig(C), diag(schur(C,’complex’))]
75
% Le conditionnement de cette matrice pour le calcul des valeurs

propres est très mauvais
% (la seule valeur propre est zéro et le sous espace propre est de
dimension 1)
% 10b) Usage de valeurs singulières
load gatlin
figure(1), image(X), colormap(map), title(caption)
[U,S,V]=svd(X,0);
k=1:100; X=U(:,k)*S(k,k)*V(:,k)’; figure(2), image(X), colormap(map),
title(caption)
% exemple_uicontrol à voir plus loin
disp(’fin question 10), appuyez sur une touche pour continuer’),
% 11) Équation de Poisson
% On peut remplacer B par S, L, C, D, A ou H pour avoir d’autres
formes
m=30; h=1/m; L=numgrid(’B’,2*m+1); figure(1); spy(L)
A=delsq(L)/h^2; figure(2); spy(A); u=A\ones(size(A,1),1);
U=L; U(L>0)=full(u(L(L>0))); x=linspace(-1,1,2*m+1); [X,Y]=meshgrid(x,x);
figure(3); clabel(contourf(X,Y,U))
figure(4); surf(X,Y,U) % ou mesh(X,Y,U) ou surfl(X,Y,U), shading
interp, colormap copper
D) Compréhension des procédures matlab numgrid et delsq utilisées

dans la question 11 précédente.
a) numgrid, dont le code est le suivant, est assez facile.
function G = numgrid(R,n)
%NUMGRID Number the grid points in a two dimensional region.
% G = NUMGRID(REGION,N) numbers the points on an N-by-N grid in
% the subregion of -1<=x<=1 and -1<=y<=1 determined by REGION.
% SPY(NUMGRID(REGION,N)) plots the points.
% DELSQ(NUMGRID(REGION,N)) generates the 5-point discrete Laplacian.
% The regions currently available are:
% ’S’ - the entire square.
% ’L’ - the L-shaped domain made from 3/4 of the entire square.
% ’C’ - like the ’L’, but with a quarter circle in the 4-th square.
% ’D’ - the unit disc.
% ’A’ - an annulus.
% ’H’ - a heart-shaped cardioid.
% ’B’ - the exterior of a "Butterfly".
% ’N’ - a nested dissection ordering of the square.
% To add other regions, edit toolbox/matlab/demos/numgrid.m.
%
% See also DELSQ, DELSQSHOW, DELSQDEMO.
% Copyright 1984-2005 The MathWorks, Inc.
% $Revision: 5.8.4.1 $ $Date: 2005/03/23 20:24:00 $
if R == ’N’
G = nested(n);
else
x = ones(n,1)*[-1, (-(n-3):2:(n-3))/(n-1), 1];
y = flipud(x’);
if R == ’S’
G = (x > -1) & (x < 1) & (y > -1) & (y < 1);
elseif R == ’L’
G = (x > -1) & (x < 1) & (y > -1) & (y < 1) & ( (x > 0) |
(y > 0));
elseif R == ’C’
G = (x > -1) & (x < 1) & (y > -1) & (y < 1) & ((x+1).^2+(y+1).^2
> 1);
elseif R == ’D’
G = x.^2 + y.^2 < 1;
elseif R == ’A’
G = ( x.^2 + y.^2 < 1) & ( x.^2 + y.^2 > 1/3);
elseif R == ’H’
77
RHO = .75; SIGMA = .75;

G = (x.^2+y.^2).*(x.^2+y.^2-SIGMA*y) < RHO*x.^2;
elseif R == ’B’
t = atan2(y,x);
r = sqrt(x.^2 + y.^2);
G = (r >= sin(2*t) + .2*sin(8*t)) & ...
(x > -1) & (x < 1) & (y > -1) & (y < 1);
else
error(’Invalid region type.’);
end
k = find(G);
G = zeros(size(G)); % Convert from logical to double matrix
G(k) = (1:length(k))’;
end
Il suffit de comprendre les instructions suivantes (on laisse de coté la “nested
dissection”).
m=5; n=2*m+1; x=ones(n,1)*[-1,(-(n-3):2:(n-3))/(n-1),1]; y=flipud(x’);
% grille contenant tout
G=(x>-1)&(x<1)&(y>-1)&(y<1)&((x>0)|(y>0)); % G est ici une matrice
booléenne
k=find(G); G=zeros(size(G)); G(k)=(1:length(k))’; % ici on passe à
une matrice de type double contenant les numéros des noeuds dans la matrice
finale du Laplacien.
G, spy(G)
b) delsq dont le code est le suivant, est plus dur.

function D = delsq(G)
%DELSQ Construct five-point finite difference Laplacian.
% delsq(G) is the sparse form of the two-dimensional,
% 5-point discrete negative Laplacian on the grid G.
% The grid G can be generated by NUMGRID or NESTED.
%
% See also NUMGRID, DEL2, DELSQDEMO.
% C. Moler, 7-16-91.
% Copyright 1984-2002 The MathWorks, Inc.
% $Revision: 5.7 $ $Date: 2002/04/15 03:34:05 $
[m,n] = size(G);
% Indices of interior points
p = find(G);
% Connect interior points to themselves with 4’s.
i = G(p);
j = G(p);
s = 4*ones(size(p));
% for k = north, east, south, west
for k = [-1 m 1 -m]
% Possible neighbors in k-th direction
Q = G(p+k);
% Index of points with interior neighbors
q = find(Q);
% Connect interior points to neighbors with -1’s.
i = [i; G(p(q))];
j = [j; Q(q)];
s = [s; -ones(length(q),1)];
end
D = sparse(i,j,s);
Pour la compréhension, les manipulations suivantes, à la suite de celles indi-
quées plus haut, peuvent être utiles :
[m,n]=size(G);
p=find(G) % numéros de 13 à 109
i=G(p), % numéros 1,2,..., 56
j=G(p); s=4*ones(size(p));
[G(p),G(p-1),G(p+m),G(p+1),G(p-m)]
Q=G(p-1); q=find(Q);
[G(p(q)),Q(q)]
Ici il faut penser à un maillage du rectangle [−1, 1] × [−1, 1] où les noeuds
2
ont pour coordonnées (xi , yj ) avec xi = −1 + ihx , 1 ≤ i ≤ m, hx = m−1 ,
79
2
yj = −1+jhy , 1 ≤ j ≤ n, hy = n−1 (d’où le choix m = 2k+1 fait d’habitude).
La matrice G est définie par :

le numéro du noeud Nij si ce noeud est dans le maillage
G(i, j) =
0 si non
où Nij est le numéro de l’inconnue correspondante (numéro d’une ligne ou
colonne de la matrice du Laplacien).
p=find(G) donne donc les numéros (i.e. l’adresse dans G) des G(i, j) non nuls
organisés colonnes par colonnes comme dans G( :) (entiers dans 1,2,...,11*11=121
ici)
. ce G(p) est donc la suite des G(i, j) non nuls : 1,2,3,...56 ici
i=G(p); j=G(p); s=4*ones(size(p)) ; % sans commentaires supplémen-
taires
. dans la numérotation des colonnes ou lignes
du Laplacien
Q=G(p+k) est la suite des G(i, j) qui sont voisins en “position k” par rapport
aux G(p) ; il est intéressant d’afficher :
[G(p), G(p-1),G(p+m),G(p+1),G(p-m)]
. dans la numérotation de p=find(G) donc celle des
colonnes ou lignes du Laplacien
q=find(Q) donne les indices des composantes non nulles du vecteur Q et donc
(c’est la plus difficile à comprendre) :
i=G(p(q)) est la suite des numéros (dans la numérotation des colonnes du
Laplacien) des noeuds ayant un voisin dans le maillage dans la direction k,
la suite des numéros de ces voisins étant j=Q(q)
Il faudrait étendre les procédures à des domaines où la frontière n’est plus
constituée de lignes de noeuds (usage de la fonction matlab inpolygon), puis
aux cas des problèmes de Dirichlet non homogènes, de Neumann et enfin aux
schémas à 9 points. Ce n’est probablement pas hors de portée.
E) Une “function” interface graphique pour la question 10b précé-

dente.
Voici un code qui produit une interface graphique pour la question 10b précé-
dente. La comparaison avec le corrigé précédent est très utile à la compréhen-
sion. On notera que forcément ce genre de code est récursif (voir le premier
callback) et que l’usage de la programmation est intensif (voir h.slider=
... et autre get et set).
function exemple_uicontrol(varargin)
persistent U S V map caption
if nargin == 0
shg, clf
h.slider=uicontrol(’units’,’norm’,’pos’,[.10 .02, .24 .04],...
’style’,’slider’,’value’,0,’callback’,’exemple_uicontrol(”slide”)’);
h.limit=uicontrol(’units’,’norm’,’pos’,[.34 .02, .05 .04],...
’style’,’text’);
h.rank=uicontrol(’units’,’norm’,’pos’,[.14 .06, .16 .04],...
’style’,’text’,’string’,’ ’);
h.close=uicontrol(’units’,’norm’,’pos’,[.80 .03, .10 .05],...
’string’,’close’,’callback’,’close’);
set(gcf,’userdata’,h)
load gatlin, image(X), colormap(map), axis off, title(caption)
[U,S,V]=svd(X,0);
[m,n]=size(X); mn=min(m,n);
set(h.slider,’val’,1,’min’,0,’max’,mn,’sliderstep’,[1/mn 10/mn]);
set(h.limit,’string’,int2str(mn));
set(h.rank,’string’,’ ’);
end
h=get(gcf,’userdata’);
r=round(get(h.slider,’value’)); set(h.slider,’value’,r);
set(h.rank,’string’,[’rank=’ num2str(r)]); k=1:r;
X=U(:,k)*S(k,k)*V(:,k)’; image(X), colormap(map), axis off, title(caption)
J’espère améliorer plus tard ce condensé au niveau des règles de programma-
tion et de la fabrication d’interfaces graphiques.
Bibliographie
[1] Gilbert Strang, linear algebra and its applications, Wellesley-Cambridge

press, 1986.
[2] H.R. Schwarz, Numerical Analysis, A comprehensive introduction, Wi-
ley, 1989.
[3] Amy N. Langville and Carl D Meyer, Googles’s PageRank and beyond,
the science of search engine rankings, Princeton university press, 2006.
[4] Cleve Moler, Numerical computing with Matlab,
http://www.mathworks.com/moler/
[5] Michael W. Berry and Murray Browne, Understanding search engines,
mathematical modeling and text retrieval, Cambridge university press,
2005.
[6] Kemeny, John G. ; Snell, J. Laurie Finite Markov chains, Van Nostrand,
1960.
[7] Comment fonctionne Google, Michael Eisermann
http://www.igt.uni-stuttgart.de/eiserm/popularisation/#google
[8] Cours en ligne de Daniel Lemire, université de Québec, Canada
81

Cours Web

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Web

Transféré par

Droits d'auteur :

Formats disponibles

Licence de Mathématiques.

1 Le réseau : un graphe gigantesque. 7

2 Modélisation de grands ensembles de documents pour la re-

3 Le moteur de recherche Google et le page ranking. 37

3.6 un programme MATLAB. . . . . . . . . . . . . . . . . . . . . 55

Ce fascicule volontairement succinct poursuit les buts suivants :

1.1 Google : la légende.

importance, it occurred to them that a search engine based on PageRank

Figure 1.1 – taille du web, d’apres le site wordwidewebsize.com

1.2 Le graphe du web

Figure 1.2 – taille du web, début 2013 d’après le site wordwidewebsize.com

1.3 Exploration du web

1.3.1 un programme MATLAB.

function [U,G] = surfer(root,n)

% might take an unacceptably long time to complete. In some cases,

% Try to open a page.

% Follow the links from the open page.

% Look for links that should be skipped.

skips = {’.gif’,’.jpg’,’.pdf’,’.css’,’lmscadsi’,’cybernet’, ...

% Check if page is already in url list.

% Add a new url to the graph there if are fewer than n.

% Add a new link.

A quoi correspond le résultat de la commande suivante ?

Modélisation de grands ensembles

Les notions vues dans ce chapitre s’applique indifféremment aux bases de

2.1 Indexation du web ou d’une base de don-

de documents est résumée dans trois fichiers :

2.2 Modélisation par espace vectoriel.

1. ou non selon la capacité de stockage des serveurs qui s’accroît constamment

Les colonnes de la matrice A correspondent aux différents sites du web. Les

Suposons qu’un utilisateur formule une requête sur un moteur de recherche

Remarque. En Matlab, les vecteurs colonnes de A s’obtiennent aisément :

2.3 La décomposition de valeur singulière : un

où U matrice orthogonale m × m, V matrice orthogonale p × p et Σ matrice

Les termes diagonaux non nuls, rangés par ordre décroissant σ1 ≥ σ2 ≥ . . . ≥

Remarque. Dans le cas m = p, on retrouve la propriété qu’un matrice symé-

(2.1) peut s’écrire aussi

Remarquons que les valeurs propres de S sont positives. En effet

Montrons finalement que

Exemple. Donnons quelques exemples.

Il faut faire attention au format des matrices :

Une conséquence immédiate du théorème précédent est la proposition.

Proposition 1 Cette décomposition SVD permet de connaître immédiate-

D’où l’on tire

Remarque. Ce fait permet de donner une interprétation géométrique simple

Mais on peut poser yi = αi σi et alors deux cas se présentent.

qui est bien l’équation du volume intérieur (en dimension r) de l’ellipsoïde

Propriété 2 le conditionnement (pour la norme matricielle subordonnée à

la matrice obtenue en ne conservant que les k plus grosses valeurs singulières

Preuve. Considérons la décomposition en valeurs singulières de A = U ΣV T .

0 ... ... 0 0 ... 0

Comme U et V sont des matrices carrées inversibles, elles ne modifient pas

Commençons par calculer kA − Ak k. Comme A − Ak = U (Σ − Σk )V T , les

V ect{V1 , V2 , . . . , Vk+1 } ∩ ker B 6= {0} .

Sinon ils seraient en somme directe et la dimension

dim V ect{V1 , V2 , . . . , Vk+1 } ⊕ ker B ≥ p + 1

On est en mesure de calculer

kA − Bk = sup k(A − B)xk ≥ k(A − B)zk = kAzk.

Maintenant la norme de Az est facile à obtenir à partir de ses composantes

Ainsi on a bien prouvé kA − Bk ≥ σk+1 .

au lieu de la norme de l’endormorphisme associé

on a un résultat analogue pour la matrice Ak à savoir

Pour le prouver, il faut sur l’espace vectoriel des matrices m × p utiliser le

2.5 TD autour de la décomposition de valeurs