Bonjour à tous,

Il est clair que R n'est pas très rapide, mais étant donnée notre objectif, il faudrait le montrer de manière un peu plus formelle. Pour cela, je pense qu'il faudrait comparer les performances relatives des différents langages. Un moyen simple serait de programmer le mini pseudo code suivant :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
### Lecture des données
A <- read.file("matrix5.csv") 

### Moyenne de chaque colonne, retourne un vecteur
meanCol(A) 

### Ecart type de chaque colonne, retourne un vecteur
sdCol(A) 

### Régression linéaire, la première colonne en fonction de toutes les autres
lm(A[,1]~A[,2]+A[,3]+A[,4]+A[,5]) 

### Régression linéaire, manuelle (détail dans le post suivant)
inv( t(B)*B ) * ( t(B)*a )
Voila pour l'idée générale. En pratique, ce qui nous intéresse est le temps d'exécution. De plus, on va faire REROLL=100 essais a chaque fois. Donc le code est :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
### Lecture des données
A <- read.file("matrix5.csv") 

### REROLL essais pour chaque opération.
tableauTemps <- matrice vide(4 colonnes et REROLL lignes)
boucle i variant de 1 à REROLL
   tableauTemps[i,1] <- temps de l'instruction( meanCol(A) )
   tableauTemps[i,2] <- temps de l'instruction( sdCol(A) )
   tableauTemps[i,3] <- temps de l'instruction( lm(A[,1]~A[,2]+A[,3]+A[,4]+A[,5]) )
   tableauTemps[i,4] <- temps de l'instruction( inv( t(B)*B ) * ( t(B)*a ) )
finBoucle
Et comme il est possible, pour les petites matrices, que cela soit trop rapide, on ajoute une boucle qui fait faire ITER fois chaque opération :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
### Lecture des données
A <- read.file("matrix5.csv") 

### 100 essais pour chaque opération.
tableauTemps <- matrice vide (4 colonnes et REROLL lignes)
boucle i variant de 1 à REROLL
   tableauTemps[i,1] <- temps de l'instruction(for(j variant de 1 à ITER) faire meanCol(A))
   tableauTemps[i,2] <- temps de l'instruction(for(j variant de 1 à ITER) faire sdCol(A))
   tableauTemps[i,3] <- temps de l'instruction(for(j variant de 1 à ITER) faire lm(A[,1]~A[,2]+A[,3]+A[,4]+A[,5]) )
   tableauTemps[i,4] <- temps de l'instruction(for(j variant de 1 à ITER) faire inv( t(B)*B ) * ( t(B)*a ) )
finBoucle

tableauTemps <- tableauTemps / ITER

Le but est de faire un code optimisé. Idéalement, il faudrait un exemple pour :
  • R (Christophe)
  • SAS(Laurent Orsy)
  • SPSS
  • STATA (Virginie)
  • R, avec pqr (Mamoun, Christophe)
  • R, avec compiler (Mamoun, Christophe)
  • R, avec parallel (Mamoun, Christophe)
  • C
  • C++
  • Calm
  • Java (Malek)
  • Phyton



A priori, il vous faut juste écrire le code, le tester sur 3 ou 4 matrices pour être sur qu'il marche, puis le poster ici. Les matrices sont là, soit en format wide (t colonnes, t² lignes), soit long (t² colonnes, t lignes) :


Dans tous les cas, CA N'EST PAS LA PEINE de faire tous les tests puisque je referais tout moi-même sur ma machine (histoire de faire les comparaisons a machine constante).

Des volontaires ? Qui fait quoi ?.

Christophe