Regression
Utilisation du sous-programme
Note au programmeur
Paul Salmon
Faculté des Sciences économiques
Université de Rennes 1
Février 2003
Avertissement
Pour aborder correctement le contenu de cette note, il est nécessaire de posséder quelques bases dans les domaines des méthodes statistiques de l’économétrie, la programmation en générale et la programmation avec Visual Basic ainsi que des connaissances de base en Finance et plus particulièrement le CAPM.
L’objectif de cette note est de permettre à un étudiant, un cadre ou un chercheur d’introduire un programme de régression dans ses propres applications. Celles-ci peuvent être sous Microsoft Excel, Visual Basic, voire dans d’autres langages.
Le code correspondant à l’ensemble du projet est disponible sur le site du Dess Finance d’Entreprise On Line à l’adresse suivante :
http://cerefia.eco.univ-rennes1.fr/newdessonline/Enseignement/Fin016/Code/
Avec le code, nous avons donné quelques exemples.
Une application sur le CAPM utilisant Regression est
aussi fournie à la même adresse. Il est indispensable d’avoir accès à la base
de données des cours de la Bourse de Paris.
Ce travail est aussi utilisé dans le cadre du projet
Bourse, dans la partie qui illustre le Datamining.
Le sous-programme Regression a fait l’objet de
nombreux tests (voir Annexe). Cependant cela n’exclut pas la possibilité de
voir ici et là apparaître des erreurs. Toutes les erreurs qui se trouveraient
dans les programmes sont sous la responsabilité de l’auteur. L’utilisation de
ce sous-programme est sous la responsabilité des utilisateurs.
Pour tout problème, n’hésitez pas à me contacter à
l’adresse suivante : Paul.Salmon@univ-rennes1.fr.
Rennes, le Mercredi 26 Février 2003
Paul Salmon.
Introduction.
Le
sous-programme Regression[1]
permet d’appliquer à une matrice de données spécifique
Regression a été créé pour être introduit dans des programmes construits pour des objectifs auxquels les logiciels habituels ne répondent pas ou difficilement.
L’utilisation
du sous-programme Regression lui-même est très simple. Cette simplicité repose
sur le fait que Regression ne nécessite qu’un argument : la matrice
L’appel de Regression se fait donc en Visual Basic, suivant votre préférence, de la manière suivante :
Call regression(
Ou
Regression
Dans ce qui suit, les appels des fonctions ou sous-programmes se feront de la seconde manière.
Comme on le
déduit de ce qui précède, l’utilisation de Regression implique toutefois un
préalable : la construction de la matrice
Avant de nous
lancer dans la description des différentes procédures que nous avons
développées, il faut d’abord rappeler la structure de la matrice
Nous avons soumis à des tests pour déterminer sa qualité. Les résultats de ces tests ont été mis en annexe.
Structure de la matrice
Il est important de rappeler la nature du problème que nous avons à traiter. Il s’agit de trouver un ensemble de coefficients qui minimisent la somme des carrés des résidus d’un système d’équations linéaires de la forme (1). Nous ne reviendrons pas ici sur les démonstrations et autres résultats qui nous amènent aux formules et résultats que nous utilisons. Comme nous l’avons déjà précisé précédemment, le lecteur se reportera sur la note Projet Econométrie : Regression.
Notre système se présente donc sous la forme ci-dessous :
La formulation matricielle de (2) s’écrit
dans laquelle
où
Le développement des calculs nous amène à voir que la principale relation pour les calculs des moindres carrés ordinaires est :
où
C’est sur la formule (5) qu’est construit le programme.
Il existe de
multiples façons d’aborder le problème.
Faire des produits de matrice ne pose aucun problème du point de vue informatique, il ne s’agit que de l’utilisation de boucle de type For. Construire la transposée d’un matrice me présente aussi aucune difficulté. La seule véritable difficulté réside dans le calcul de la matrice inverse. La difficulté est ici beaucoup plus délicate.
Il existe de nombreuses manières de procéder pour déterminer la matrice inverse. La consultation d’un ouvrage d’algorithmique sur le sujet permet de comprendre l’ampleur du problème. Nous n’entrerons pas dans le détail des discussions. Parmi toutes ces discussions, nous avons choisi de traiter le problème comme le fait Clopper Almon dans son ouvrage précédemment cité.
Cette approche repose sur la méthode de Gauss-Jordan et sur une analyse des divers résultats obtenus lors des modifications des lignes où se trouve le pivot. Clopper Almon nous montre la nature des différents résultats que l’on obtient à chaque nouveau pivot. Il montre ainsi que de très nombreux résultats sont obtenus lors de l’inversion de la matrice par la méthode de Gauss-Jordan ou encore méthode du pivot.
Pour réaliser
les calculs, Clopper Almon nous fait construire une matrice que nous appelerons
dans la suite
Il est donc
important de rappeler la structure de
La matrice
Regression
reçoit
La construction de
la matrice X.
Comme nous devons obtenir une matrice, il nous semble plus intéressant d’utiliser une fonction plutôt d’un sous-programme. La fonction nous permettant d’obtenir la matrice X, devra donc extraire les données de fichiers ou de base de données, les regroupées conformément à la structure de X.
Les données
utiles à la construction de
La liste des arguments de la fonction comprendra le nom complet de la base de données ou celui du fichier voire des fichiers ou bases de données nécessaires à la construction de X. En effet, les données nécessaires peuvent être contenues dans plusieurs sources d’information de formats différents.
La fonction permettant d’obtenir X se présente ainsi :
Fonction
MatX(NomConfigReg, NomDeFichier1, NomDeFichier2) ‘ ‘ 0 Déclarations des variables locales ‘ … suivant les langages ‘ ‘ 1 Ouverture et Lecture de
NomFicConfigReg ‘ Ouverture du fichier de configuration Boucle de lecture des lignes du fichier RegConfig Lecture des lignes du fichier de configuration Affectation des paramètres lus ‘ ‘ 2 Ouverture des fichiers, des bases de
données ou autres. ‘ ‘ 2.1 Ouverture
du ou des fichiers ASCII ‘ … Open ‘ ‘ 2.2 Ouverture
du ou des fichiers Excel ‘ … Objet
Excel, ADO, ODBC ‘ ‘ 2.3 Ouverture
du ou des bases de données ‘ … ADO,
ODBC ‘ ‘ 3 Extraction des données utiles. ‘ 3.1 Lecture des données dans les fichiers variant
suivant les structures des fichiers. 3.2 Affectations dans des tampons (Vecteurs,
Matrices, recordsets). ‘ ‘ 4 Transformations des données si nécessaires. ‘ 4.1 Taux de variation, Log, différence première, … 4.2 Les transformations peuvent utiliser tous les
types de transformations possibles. ‘ ‘ 5 Dimensionnement et Initialisation de la
matrice X ‘ 5.1 Nombre de colonnes (correspond au modèle,
cette valeur dépend du choix de l’utilisateur). 5.2 Nombre d’observation (correspond au nombre de
lignes lues moins quelque chose, ou au nombre de ligne du ReEcordSet, ou
autre). 5.3Introduction de la constante en colonne 0 et 0
partout ailleurs. ‘ ‘ 6 Ecriture de données dans la matrice. ‘ 6.1 Les dimensions de la matrice étant connues, il
faut affecter les différents vecteurs, matrices ou recordsets. Il faut
prendre bien soin du contenu des divers éléments. ‘ ‘ 7 Affectation de la matrice construite à la
fonction. ‘ MatX = MatTampon Fin
de la fonction |
Encadré 1 : Exemple de structure de fontion pour construire X
La fonction MatX nous permet de disposer d’une matrice X.
On trouvera dans l‘Encadré 2, un exemple de fonction de type MatX. La fonction est autodocumentée, le lecteur n’aura qu’à la lire pour en comprendre le contenu.
La fonction présentée dans l’Encadré ci-dessous permet de lire des fichiers séquentiels. La structure de ces fichiers séquentiels est décrite dans les commentaires, au début du programme.
Public
Function X(NomFichierDonnees As String) As Double() ' '---------------------------------------------------------------- ' Lecture des données -
construction de la matrice X '---------------------------------------------------------------- ' ' Pour utiliser Regression,
il faut construire une matrice X. ‘ Cette fonction construit
cette matrice à partir de fichier ‘ ayant pour structure : ' ' NVI NO Constante ' Données ' ' Ici, les données sont
séparées par des blancs. ' '------------------------------------------------------------------ ' © Février 2003 - Paul
Salmon '------------------------------------------------------------------ ' ' Arguments ' '
NomFichierDonnees ' Le nom est
construit dans la fonction ' ou
sous-programme appelant X ' '------------------------------------------------------------------ ' 0. Déclarations des variables locales. '------------------------------------------------------------------ ' Dim
MatX() As Double ' Matrice X
augmentée. Cette matrice ' contient les NVI
variables ' explicatives de
la colonne 0 à la ' colonne NVI - 1 et
la variable à ' expliquer dans
la NC ième colonne de ' la matrice. ' NC = NVI + 1.
Les lignes sont au ' nombre de NO. ' La première
ligne à pour indice 0. ' La matrice X est
définie comme suit : ' X( 0 To No - 1 , 0 to NC - 1 ) Dim
Compteur As Long ' Variable
contenant le numéro de la ' ligne en cours
de lecture. Dim
CONSTANTE As String ' Variable
indiquant si X contient en ' première colonne
des 1. Dim
DataLigne ' Vecteur tampon
contenant les résultats ' de la fonction Split Dim
i As Long ' Indice de
boucle Dim
j As Long ' Indice de
Boucle Dim
LigneDeTexte As String ' Ligne lue dans le fichier en cours ' de traitement Dim
NC As Long ' Nombre de
variables explicatives plus ‘ la variable
dépendante Dim
NO As Long ' Nombre
d'observations Dim
NVI As Long ' Nombre de
variables indépendantes ' '------------------------------------------------------------------ ' 2. Ouverture du fichier contenant les données à introduire ' dans
la matrice. '------------------------------------------------------------------ ' Open
NomFichierDonnees For Input As #1 ' ' Initialisation du
compteur du nombre de ligne lue ' '------------------------------------------------------------------ ' 3. Lecture des données à partir du fichier ouvert '------------------------------------------------------------------ ' ' Compteur = 0 ' Do While Not EOF(1) ' '
Incrémentation du compteur ' Compteur = Compteur + 1 ' ' Lecture de la ligne du fichier ASCII ' Line Input #1, LigneDeTexte ' ' Prise en compte du contenu de la
première ligne du ' fichier lu. ' If Compteur = 1 Then ' ' Recherche et affectations des information de la ' première ligne. ' '
Recherche ' DataLigne = Split(SubstitutionCaractereConsecutif(LigneDeTexte,
" "), _
" ", -1,
vbTextCompare) ' '
Affectation des valeurs contenues dans DataLigne ' NVI = DataLigne(0) NO = DataLigne(1) CONSTANTE = DataLigne(2) ' '---------------------------------------------------------- ' 5. Dimensionnement de la matrice X en fonction des ' informations lues dans le fichier de données.
'---------------------------------------------------------- ' If CONSTANTE = "True" Then ' ' Cas de l'introduction d'une
constante dans ' la matrice (cas général) '
ReDim MatX(0 To NO - 1, 0 To NVI + 1) ' Else ' ' Cas où la matrice ne contient
pas de constante. ' Dans ce cas les résultats de
Regression ' ne correspondent pas à ce cas. '
ReDim MatX(0 To NO - 1, 0 To NVI) ' ' Message d'avertissement ' MsgBox "Attention : Compte tenu de
votre choix 8 d'absence de constante dans X," &
vbCrLf & _ "les calculs obtenus
avec Regression seront 8 pour certains erronnés.", vbCritical ' End If '
'---------------------------------------------------------- ' 5. Initialisation de la matrice X
'---------------------------------------------------------- ' ' Si constante = True, alors introduction
de la ' constante dans le colonne 0 de X et
zéro dans ' toutes les autres colonnes. ' Sinon toutes les colonnes de la
matrice seront ' initialisées à 0. ' For j
= 0 To UBound(MatX, 2) - 1 If (j = 0) And (CONSTANTE = True) Then
For i = 0 To UBound(MatX, 1) MatX(i, j) = 1#
Next i
Else
For i = 0 To UBound(MatX, 1) - 1 MatX(i, j) = 0#
Next i
End If Next j ' ElseIf
Compteur > 1 And Compteur <= NO + 1 Then '
'---------------------------------------------------------- ' 6. Création du vecteur DataLigne contenant les données ' sur la ligne
'---------------------------------------------------------- ' DataLigne = 8 Split(Trim(SubstitutionCaractereConsecutif(LigneDeTexte,
" ")), _ " ", -1,
vbTextCompare) '
'---------------------------------------------------------- ' 6. Remplissage des colonnes, ligne par ligne ' L'itération débute en 1 car la colonne 0 contient ' les valeurs de la constante. '---------------------------------------------------------- ' For j
= 0 To UBound(MatX, 2) If
CONSTANTE = "True" Then
If j <> UBound(MatX, 2) Then
MatX(Compteur
- 2, j + 1) = CDbl(DataLigne(j)) End
If
Else
MatX(Compteur - 2, j) = CDbl(DataLigne(j))
End If ' Next j ' Else ' ' Gestion des
autres cas. Sortie de la boucle. ' Exit Do ' End If ' '------------------------------------------------------------------ ' 7. Affectation de la matrice MatX à la variable à retourner. '------------------------------------------------------------------ ' X = MatX ' '----------------------------------------------------------------- ' Fin de la fonction X '----------------------------------------------------------------- ' End Function |
Encadré 3 : Exemple de fonction de construction de la matrice X
La lecture de l’Encadré 2, nous montre bien ce que nous devons faire. On remarquera que dans le cas de l’Encadré 2, il n’y a pas de lecture d’un fichier de configuration de la régression.
Maintenant que nous savons construire la matrice X, voyons comment fonctionne Regression.
Le sous-programme Regression.
Dans ce qui suit nous nous intéresserons à la présentation du sous-programme. De ce fait, le lecteur connaîtra parfaitement tous les calculs réalisés dans le code. Sa connaissances du programmes et de Visual Basic lui permettront de faire d’éventuelles modifications et surtout ajouts.
Une fois le code compris, nous indiquerons les conditions d’utilisation de celui-ci ?
Compréhension
du code.
La compréhension de ce sous programme suppose la connaissance de la méthodes des moindres carrés ordinaires. Pour de plus amples détails, le lecteur se reportera à Maddala (1999), à Gurajati (1999), à Pindick et Rubinfeld (1981, 1991), à Green (1999) ou encore Almon (2001).
L’encadré 4 contient le code de Regression. Comme précédemment le code est auto documenté et sa lecture devrait être suffisante à sa compréhension.
Pou mieux comprendre la structure de la procédure, nous avons cru bon de mettre en gras et de faire précéder d’un chiffre les commentaires indiquant les diverses étapes qui ont été programmées. Le programme est discuté après l’encadré.
Public
Sub Regression(X() As Double) ' '------------------------------------------------------------------ ' Regression - Méthode des
Moindres Carrés Ordinaires avec ' ' 'constante
(MCO avec constante) '------------------------------------------------------------------ ' ' Ce programme de
régression est tiré de : ' ' Almon Clopper (1967), "Matrix in
economics", Addison Wesley, ' ' ' Le chapitre 3 contient une version
expliquée du code Fortran. ' ' Il s'agit ici d'une version écrite en
utilisant le langage de ' programmation
Visual
Basic 6 de Microsoft. '------------------------------------------------------------------ ' Versions '------------------------------------------------------------------ ' ' Version 1.0.0 - Février
2003 ' Mise en place du sous-programme. ' '------------------------------------------------------------------ ' Scalaires, Vecteurs et
Matrices disponibles en dehors de ' Regression si Public. '------------------------------------------------------------------ ' Coef - Tableaux contenant
toutes les statistiques relatives aux ' "coefficients" ' Affectation des colonnes ' ' Coef(i,0) - Coefficients de la régression ' Coef(i,1) - Mexval ' Coef(i,2) - Elasticité par rapport à la
moyenne ' Coef(i,3) - NorRes ' Coef(i,4) - Ecart-Type des coefficients ' Coef(i,5) - Moyenne des variables
expliquée et explicatives ' Coef(i,6) - Beta ' Coef(i,7) - t-Student ' Coef(i,8) - F-Stat ' ' MatCrossCorr - Matrice de
corrélation croisée. ' ' MatCovVarCoef - Matrice
de Variance-Covaraince des coefficients. ' ' PD - Matrice des dérivées
partielles. ' ' RegData - Matrice
contenant les informations sur Y, Yhat et les ' résidus. ' Affectation des colonnes ' ' RegData(i, 0) : les numéros des
observations ' RegData(i, 1) : Les observations de Y ' RegData(i, 2) : Les observations de Yhat ' RegData(i, 3) : Les observations des
résidus ' ' StatReg - Vecteur
contenant les statistiques de "qualité" de ' la régression ' Affectation des colonnes ' ' StatReg(0) = SEE ' StatReg(1) = R2 ' StatReg(2) = ' StatReg(3) = nobs ' StatReg(4) = 1 Première observation ' StatReg(5) = SEEP1 ' StatReg(6) = RBSQR ' StatReg(7) = DW ' StatReg(8) = DoFree ' StatReg(9) = Denière observation ? ' StatReg(10) = MAPE ' '------------------------------------------------------------------ ' © 2003 - Paul Salmon '------------------------------------------------------------------ ' ' 0.Déclarations locales ' Dim
NVI As Long ' Nombre de Variables Indépendantes Dim
NO As Long ' Nombre d'Observations Dim
NC As Long ' Nombre de Colonnes de la matrice ' X, (NVI + 1) ' Dim NOR As Long ' NO rectifié Dim
NVIR As Long ' NVIR rectifié ' ' Scalaires et Matrice
permettant d'effectuer l'inversion ' de la matrice X'X. ' Dim
A() As Double ' Matrice contenant les
résultats ' des calculs intermédiaires et ' terminal de la matrice inverse ' de X'X augmentée Dim
Pivot As Double ' Valeur du pivot Dim
AJI As Double ' ' ' Vecteurs et Matrices
temporaires pour la récupérations de ' résultats intermédiaires. ' Dim
Temp() As Double ' Dim
TempS() As Double ' ' ' Scalaires, Vecteurs et
Matrices contenant les résultats ' permettant d'analyser les
résultats obtenus par la méthode ' des moindres carrés
ordinaires (MCO). ' Dim
DoFree As Long ' Degré de liberté Dim
DW As Double ' Durbin-Watson Dim
errp1 As Double ' Dim
lresid As Double ' Contient le résidu précédent Dim MAPE As Double ' Mean Absolute Percentage Error Dim
Mean() As Double ' Moyenne de la variable à expliquer ' et
des variables explicatives. Dim
nobs As Long ' Nombre d'observations Dim
R2 As Double ' R2 Dim
RBSQR As Double ' R2 corrigé Dim
Resid() As Double ' Résidus Dim Dim
s2 As Double ' Ecart-type des résidus Dim
SEE As Double ' Ecart-type de l'estimation Dim
SEEP1 As Double ' Ecart-Type de l'estimation ' avec
correction Dim
somme1 As Double ' Variable tampon dans le calcul ' de SEEP1 Dim
SR2 As Double ' Variance des résidus Dim
SY2 As Double ' Variance de Y Dim
YHAT() As Double ' Y calculés ' ' Indice de boucle ' Dim
i As Long ' Indice de boucle Dim
j As Long ' Indice de boucle Dim
k As Long ' Indice de boucle Dim
n As Long ' Indice de boucle ' ' 1. Initialisation des variables ' Cette initialisation doit être faite avant
le dimensionnement ' des vecteurs et tableaux. ' NC
= UBound(X, 2) ' Nombre de variables indépendantes ' plus y NVI
= NC - 1 ' Nombre de variables indépendantes NO
= UBound(X, 1) '
Nombre d'observation ' NVIR
= NVI + 1 ' NVI "corrigée" NOR = NO + 1 ' NO "corrigée" ' ' 2. Dimensionnement des Vecteurs et Tableaux ' ReDim
A(0 To NC, 0 To NC) ' Matrice résultant du ' produit de X'X ' "augmentée" ReDim
Coef(0 To NVI, 0 To 8) ' Vecteur des coefficients ' de
régression ReDim
MatCrossCorr(0 To NC, 0 To NC) ' Matrice de corrélation ' croisée ReDim
MatVarCovCoef(0 To NVI, 0 To NVI) ' Matrice de Variance ' covariance des ' coefficients ReDim
Mean(0 To NC) ' Vecteur des moyennes ReDim
PD(0 To NVI, 0 To NVI) ' Matrice des dérivées ' partielles ReDim RegData(0 To UBound(X, 1), 0 To 3) ' Matrice contenant ' Y, Yhat et resid ReDim
Resid(0 To NO) ' Vecteur des résidus ReDim
StatReg(0 To 10) ' Vecteur des résultats ' statistiques ReDim Temp(0 To NC, 0 To NC) ' Matrice Temporaire ReDim
TempS(0 To NVI) ' Vecteur Temporaire ReDim
YHAT(0 To NO) ' Vecteur des valeurs ' calculées de
Y ' '------------------------------------------------------------------ ' 3. Construction de la Matrice X'X augmentée '------------------------------------------------------------------ ' For i = 0 To NC For j = 0
To NC ' '
Initialisation à 0. de l'élément (i,j) de A ' A(i, j) = 0# ' '
Calcul de la matrice symétrique X'X ' For n
= 0 To NO
A(i, j) = A(i, j) + X(n, i) * X(n, j) Next n ' '
Remplissage de la partie inférieure de la matrice ' A(j,
i) = A(i, j) ' Next j Next
i ' '------------------------------------------------------------------ ' 4. Inversion de la matrice X'X "augmentée" '------------------------------------------------------------------ ' For i = 0 To NVI ' '
Initialisation du pivot de la ligne ' Pivot = A(i, i) ' '
Division du pivot de la ligne par lui-même ' A(i, i) = 1 ' '
Division du pivot élément par le pivot ligne ' For k = 0
To NC If Pivot <> 0 Then
A(i, k) = A(i, k) / Pivot Else MsgBox "Le pivot est nul
pour la variable " & i & _ ". Le programme est
arrété." End End If Next k ' '
Réduction des lignes "non pivot" ' For j = 0 To NC ' '
Sauter la ligne pivot ' If i
<> j Then '
AJI = A(j, i) '
A(j, i) = 0# '
For k = 0 To NC
A(j, k) = A(j, k) - A(i, k) * AJI
' '-------------------------------------------------- ' 5. Récupération des valeurs
des variables au ' cours des différentes phases de la méthode. ' moyennes et des variances-covariances ' dans Temp et Temps '--------------------------------------------------
'
' i = 0; premier pivot
'
If i = 0 Then
If k = 0 Then Temp(0, k) = 1# Temp(j, k) = -A(j, k)
Else Temp(0, k) = 0# Temp(j, k) = A(j, k)
End If
End If ' ' Récupération de la Variance de Y '
If (j = NC) And (k = NC) Then TempS(i) = A(
End If
' Next k End If Next j Next
i ' '------------------------------------------------------------------ ' 6. Calculs des diverses matrices et statistiques de diagnostic '------------------------------------------------------------------ ' ' PD - Dérivées partielles
de la régression ' For i = 0 To NVI For k = 0
To i For j
= 0 To i
PD(k, j) = A(j, k) / A(j, j) Next j Next k Next i ' ' MatCrossCorr - Matrice de
corrélation croisée ' For i = 1 To NC For j = 1
To NC If i =
j Then
MatCrossCorr(i, j) = 1# Else
MatCrossCorr(i, j) = Temp(i, j) / _ (Sqr(Temp(i,
i) * Temp(j, j))) End If Next j Next i ' ' Pour faciliter la lecture
des formules. ' SR2
= TempS(NVI) SY2
= TempS(0) ' '
SEE - Standard Error of Estimate ' ' Cas Particulier suivant
les directives de Clopper Almon. ' StatReg(0) = Sqr(SR2 / NOR) ' '
R2 - ' StatReg(1) = 1 - (SR2 / SY2) ' '
RBSQ - ' StatReg(6) = 1 - ((SR2 / (NOR - NVIR)) / (SY2 / (NOR
- 1))) ' ' Ecart-type des résidus ' s2 = SR2 / (NOR - NVIR) ' ' Calcul de la matrice de
Variance-covariance des coefficients ' For i = 0 To NVI For j = 0
To NVI
MatVarCovCoef(i, j) = s2 * A(i, j) Next j Next i ' '
nobs - Nombre d'observations ' StatReg(3) = NO + 1 ' ' DoFree - Degrés de
liberté ' StatReg(8)
= StatReg(3) - NVI - 1 ' ' Calcul de l'écart-type
des coefficients et du t-student ' For i = 0 To NVI ' ' Coefficients ' Coef(i, 0)
= A(i, NC) ' ' MexVal ' Coef(i, 1)
= 100 * (Sqr(1 + (A(i, NC) ^ 2 / _
(A(i, i) * A( ' '
Elasticité par rapport à la moyenne ' Coef(i, 2)
= A(i, NC) * (Temp(i, 0) / Temp(NC, 0)) ' '
NorRes ' Coef(i, 3) = TempS(i) / TempS(NVI) ' '
Ecart-Type du coefficient ' If i = 0
Then
Coef(i, 4) = Sqr(Temp( Else
Coef(i, 4) = Sqr(MatVarCovCoef(i, i)) End If ' '
Moyenne de la variable ' If i = 0
Then
Mean(i) = Temp(NC, 0) ' Moyenne
de y Else
Mean(i) = Temp(i, 0) End If Coef(i, 5)
= Mean(i) ' ' Beta ' Coef(i, 6)
= A(i, NC) * (Sqr(Temp(i, i)) / Sqr(Temp( ' ' T
de Student du coefficient ' Coef(i, 7)
= A(i, NC) / Coef(i, 4) ' ' Fisher ' Coef(i, 8)
= (R2 / (1 - R2)) * ((NOR - NVIR) / (NVIR - 1)) Next i ' ' ' StatReg(4) = 1
' A revoir StatReg(9) = NO + 1 ' A revoir ' ' ' For i = 0 To NO ' '
Numéro de l'observation ' RegData(i, 0) = i + 1 ' ' y
- valeurs observées ' RegData(i,
1) = X(i, NC) ' '
yhat - valeurs calculées ' For j = 0 To NVI
RegData(i, 2) = RegData(i, 2) + (A(j, NC) * X(i, j)) Next j ' '
Resid - résidus entre y et yhat ' RegData(i,
3) = X(i, NC) - RegData(i, 2) ' Next
i ' ' Les calculs suivants
utilisent les résidus, ils viennent ' donc après le calculs des
résidus. ' ' '
MAPE - Mean Average Percentage Error ' For i = 0 To NO MAPE =
MAPE + Abs(RegData(i, 3) / X(i, NC)) Next i StatReg(10) = 100 * (MAPE / NOR) ' ' ' For i = 0 To NO - 1 DW = DW +
(RegData(i, 3) - RegData(i + 1, 3)) ^ 2 Next i ' '
DW - Durbin Watson ' StatReg(7) = DW / SR2 ' ' ' StatReg(2) = (2 - StatReg(7)) / 2 ' '
SEE+1 ' lresid = 0# For i = 0 To NO errp1 =
RegData(i, 3) - somme1 =
somme1 + errp1 * errp1 lresid =
RegData(i, 3) Next i StatReg(5) = Sqr(somme1 / (NO + 1)) ' '------------------------------------------------------------------ ' Fin du sous-programme de
régression. '------------------------------------------------------------------ ' End
Sub |
Encadré 4 : Le code du sous-programme Regression
La structure
débute ici comme précédemment par les déclarations locales de la procédure.
Après l’initialisation et le dimensionnement des vecteurs et matrices commence
la programmation de la méthode des moindres carrés ordinaires. Le premier
travail réalisé est la construction de la matrice
Comment
utiliser le code ?
L’utilisation du code de Regression, nous ramène à Visual Basic.
Vous pouvez
utiliser Regression où bon vous semble, à condition que vous ayez pris soin de
créer la matrice
' '
Déclarations "Public" de variables de Regression ' Public
Coef() As Double ' Tableau des
Coefficients Public
MatVarCovCoef() As Double ' Tableau des Variance-covariance ' des coefficients Public
PD() As Double ' Tableau des
Dérivées partielles Public
MatCrossCorr() As Double ' Tableau des
corrélations croisées. Public
RegData() As Double ' tableau
contenant Y, YHAT et resi Public
StatReg() As Double ' Tableau des
résultats des statistiques |
Si vous ne l’avez pas déjà fait dans votre application, vous devez créer un module où vous placerez les quelques lignes de codes ci-dessus. Nous attirons votre attention sur le fait que vous ne devez pas utiliser ces noms de variables dans vos programmes autrement que pour leurs utilisations comme résultat de Regression.
Quelles
utilisations de Regression
L’utilisation
de Regression est liée à vos besoins d’utilisation de la méthode des moindres
carrés ordinaires. Mais Regression est insuffisant pour prendre connaissance
des valeurs des variables qui y sont calculés. Comme, il était déjà perceptible
de créer une fonction qui permet de créer
Dans ce qui suit, nous vous proposons un exemples de procédure de visualisation à l’écran et une procédure graphique. Les deux sont en cours de développement. Elles ne feront dans la version de cette note l’objet d’aucun commentaire.
Affichage, fonction de visualisation des
résultats.
Option
Base 0 Public
Function Affichage(MatCoef() As Double, _ StatReg()
As Double, _ CrossCorrMat() As
Double, _ VarCovMatrix() As Double, _
PartialDerivatesMatrix()
As Double) As String ' '------------------------------------------------------------------ '
ImpResReg - Impression des résultats de la régression '------------------------------------------------------------------ ' Objet : Ce sous-programme créée la chaine
de caractères ' contenant tous les résultats calculés
par le ' sous-programme Regression. '------------------------------------------------------------------ ' Version 1.0.0 - 19 Février 2003 '------------------------------------------------------------------ '
© Février 2003 - Paul Salmon '------------------------------------------------------------------ ' '
Déclarations locales ' Dim
i As Long ' Indice de
boucle Dim
j As Long ' Indice de
boucle ' '
Lignes intermédiaires permettant de construire affichage ' Dim
Ligne0 As String ' Dim
Ligne1 As String ' Dim
Ligne2 As String ' Dim
Ligne3 As String ' Dim
Ligne4 As String ' Dim
Ligne5 As String ' Dim
Ligne6 As String ' Dim
Ligne7 As String ' ' Dim LigneVarCov As String ' Dim LignePD As String ' Dim LigneCrossCorrMat As String ' Dim LigneTableauCoef As String ' ' Dim LenToto As Long ' Dim PosPoint As Long ' ' Dim Titi(0 To 10) As String ' Dim Toto() As String ' Dim Intitule(0 To 9) ' Dim Tutu ' ' Dim NombreDiese As Long ' Dim Stringformat As String ' Dim MaxPosPoint As Long ' Dim MaxLen As Long ' Dim FlagMoins As Boolean ' Dim BlancSup As String ' Dim Test() As String ' Dim
MaxLongueurAvantPoint() As Long ' ReDim
MaxLongueurAvantPoint(0 To UBound(MatCoef, 2)) ' ' '------------------------------------------------------------------ '
Définitions des lignes de titre et de sous-titres '------------------------------------------------------------------ ' ' Traitement du tableau StatReg ' ReDim Toto(0 To 10, 0 To 3) ' '
Détermination de toute les informations nécessaires sur un élément de StatReg ' For i = 0 To UBound(StatReg) Toto(i, 0)
= CStr(Round(StatReg(i), 5)) Toto(i, 1)
= Len(Toto(i, 0)) Toto(i, 2)
= InStr(1, Toto(i, 0), ".", vbTextCompare) Toto(i, 3) = InStr(1, Toto(i, 0),
"-", vbTextCompare) Next
i ' '
Traitement des chaînes de caractères suivant leur position ' For i = 0 To UBound(StatReg) Select
Case i Case
0, 5, 10
MaxPosPoint = 0
For j = 0 To UBound(StatReg)
If j = 0 Or j = 5 Or j = 10 Then
If Toto(j, 2) > MaxPosPoint Then MaxPosPoint = Toto(j,
2)
End If
End If
Next j
NombreDiese = MaxPosPoint - 1
Stringformat = String(NombreDiese, "0") &
".00000"
Titi(i) = Format(StatReg(i), Stringformat) Case
1, 6
MaxPosPoint = 0
For j = 0 To UBound(StatReg)
If j = 1 Or j = 6 Then
If Toto(j, 2) > MaxPosPoint Then MaxPosPoint = Toto(j,
2)
End If
End If
Next j
NombreDiese = MaxPosPoint - 1
Stringformat = String(NombreDiese, "0") &
".00000"
Titi(i) = Format(StatReg(i), Stringformat) Case
2, 7
MaxPosPoint = 0
For j = 0 To UBound(StatReg)
If j = 2 Or j = 7 Then
If Toto(j, 2) > MaxPosPoint Then MaxPosPoint = Toto(j,
2)
End If
End If
Next j If
Toto(i, 3) = 1 Then
NombreDiese
= MaxPosPoint - 2 Stringformat =
String(NombreDiese, "0") & ".00000" Else NombreDiese = MaxPosPoint - 2 Stringformat
= " " & String(NombreDiese, "0") &
".00000"
End If
Titi(i) = Format(StatReg(i), Stringformat) Case
3, 8 MaxPosPoint = 0
For j = 0 To UBound(StatReg)
If j = 3 Or j = 8 Then
'
If Toto(j, 2) > MaxPosPoint Then MaxPosPoint = Toto(j,
2)
End If '
If MaxPosPoint = 0 Then MaxPosPoint = 3
End If
'
If Toto(3, 1) >= Toto(8, 1) Then If i = 3 Then Stringformat = String(Toto(3,
1), "#") Else Stringformat =
String(Toto(3, 1) - _ Toto(8,
1), " ") & _ String(Toto(8,
1), "#") End If '
ElseIf Toto(3, 1) < Toto(8, 1) Then If i = 3 Then Stringformat =
String(Toto(8, 1) - _
Toto(3,
1), " ") & _ String(Toto(3,
1), "#") Else Stringformat =
String(Toto(8, 1), "#") End If '
End If
'
End If
Next j '
Titi(i) = Format(StatReg(i), Stringformat) ' Case
4, 9
MaxPosPoint = 0
For j = 0 To UBound(StatReg)
If j = 4 Or j = 9 Then
'
If Toto(j, 2) > MaxPosPoint Then MaxPosPoint = Toto(j,
2)
End If
'
If MaxPosPoint = 0 Then MaxPosPoint = 3
End If
'
If Toto(4, 1) >= Toto(9, 1) Then If i = 4 Then Stringformat =
String(Toto(4, 1), "#") Else Stringformat =
String(Toto(4, 1) – _ Toto(9,
1), " ") & _ String(Toto(9,
1), "#") End If '
ElseIf Toto(4, 1) < Toto(9, 1) Then If i = 4 Then Stringformat =
String(Toto(9, 1) - _ Toto(4,
1), " ") & _ String(Toto(4,
1), "#") Else Stringformat =
String(Toto(9, 1), "#") End If '
End If '
End If
Next j '
Titi(i) = Format(StatReg(i), Stringformat) ' End Select Next i ' ' ' Ligne0
= " Régression de Test pour les étudiants" & vbCrLf Ligne1
= " SEE = " & Titi(0)
& " R2 = " &
Titi(1) & _ " RHO = " & Titi(2)
& " Obser = " &
Titi(3) & _ " A partir de " &
Titi(4) Ligne2
= " SEE+1 = " & Titi(5) & " RBSQ = " &
Titi(6) & _ " DW
= " & Titi(7) & " DoFree = " & _ Titi(8) & " Jusqu'à " & Titi(9) Ligne3
= " MAPE = " & Titi(10) ' '
Initialisation de Intitule ' Intitule est un tableau qui contient les
intitulés ' des colonnes des résultats des calculs sur
les ' coefficients estimés. ' Intitule(0)
= "Nom de variable" Intitule(1)
= "Coef-Reg" Intitule(2)
= "Mexval" Intitule(3)
= "Elas" Intitule(4)
= "NorRes" Intitule(5)
= "Sigma" Intitule(6)
= "Moyenne" Intitule(7)
= "Beta" Intitule(8)
= "t-Student" Intitule(9)
= "F-Stat" ' ' '
Création de la chaîne de caractères "Affichage" ' Affichage
= "" Affichage
= Affichage & Ligne0 & vbCrLf Affichage
= Affichage & Ligne1 & vbCrLf Affichage
= Affichage & Ligne2 & vbCrLf Affichage
= Affichage & Ligne3 & vbCrLf & vbCrLf ' '
Transformation de la matrice des nombres en une matrice ' contenant
les nombres sous forme de chaînes de caractères ' arrondis
avec n décimales. ' Test = PrepMat(MatCoef(), NumberDecimal) ' ' ' ReDim Toto(0 To UBound(Test, 1), 0 To UBound(Test,
2), 0 To 3) ' '
Affichage des coefficients et autres résultats liés ' For i = 0 To UBound(Test, 1) For j = 0
To UBound(Test, 2) ' ' Contient la valeur de Test initiale '
Toto(i, j, 0) = Test(i, j) ' ' Longueur de la chaîne Test '
Toto(i, j, 1) = Len(Toto(i, j, 0)) ' ' Position du point décimal '
Toto(i, j, 2) = InStr(1, Toto(i, j, 0), ".", vbTextCompare) ' ' Poisition du signe "-" '
Toto(i, j, 3) = InStr(1, Toto(i, j, 0), "-", vbTextCompare) ' ' Détermination de la taille maximale
pour un j donné ' de la partie entière ' If
Toto(i, j, 2) > MaxLongueurAvantPoint(j) Then MaxLongueurAvantPoint(j) =
Toto(i, j, 2) End
If Next j Next i ' Ligne4
= " " ' Dim
TailleColonne() As Integer ReDim TailleColonne(0 To UBound(Intitule)) For i = 0 To UBound(Intitule) If i = 0 Then ' ' Cas de "Nom de variable" ' Ligne4 = Ligne4 & Intitule(i)
& Space(16 - Len(Intitule(i))) TailleColonne(i) = 0 ' Else ' ' Cas pour les statistiques ' If
Len(Intitule(i)) >= MaxLongueurAvantPoint(i - 1) + _ NumberDecimal + 1 Then
Tutu = Len(Intitule(i)) + 1
'ElseIf Len(Intitule(i)) = (MaxLongueurAvantPoint(i - 1) +_ NumberDecimal + 1) Then ' Tutu = Len(Intitule(i)) Else
Tutu = MaxLongueurAvantPoint(i - 1) + NumberDecimal + 1 End If ' ' ' TailleColonne(i) = Tutu ' ' Construction progressive de la
"Ligne4" ' Ligne4 = Ligne4 & Space(Tutu -
Len(Intitule(i))) & Intitule(i) ' End If Next i ' Affichage
= Affichage & Ligne4 & vbCrLf ' '
Construction de la chaîne de caractères LigneTableaucoef ' LigneTableauCoef = Space(18) ' For i = 0 To UBound(Test, 1) For j = 0
To UBound(Test, 2) Toto(i, j, 0) = Space(TailleColonne(j
+ 1) _
- Len(Toto(i, j, 0)) - 1) &
Toto(i, j, 0) ' 'If
MaxLongueurAvantPoint(j) > Toto(i, j, 2) Then '
Toto(i, j, 0) = Space(MaxLongueurAvantPoint(j) _ - Toto(i, j, 2)) & Toto(i, j, 0) 'End
If '
LigneTableauCoef = LigneTableauCoef & Toto(i, j, 0) & "
" ' Next j '
LigneTableauCoef = LigneTableauCoef & vbCrLf & Space(18) ' Next i ' '
Ajout de LigneTableauCoef à Affichage ' Affichage
= Affichage & vbCrLf & LigneTableauCoef & vbCrLf ' '------------------------------------------------------------------ '
Affichage de la matrice de Variance-Covariance des coefficients '------------------------------------------------------------------ ' Ligne5
= " Matrice de Variance-Covariance des coefficients _ de régression" ' Affichage
= Affichage & Ligne5 & vbCrLf ' '
Transformation de la matrice des nombres en une matrice ‘
contenant les nombres sous forme de chaînes de caractères ‘arrondis
avec n décimales. ' Dim NumBerDecimalVarCov As Integer Dim Maxtest As Integer NumBerDecimalVarCov = 3 Maxtest = 0 Test = PrepMat(VarCovMatrix(), NumBerDecimalVarCov) ' '
Recherche du nombre de plus grande taille ' For i = 0 To UBound(VarCovMatrix, 1) For j = 0
To UBound(VarCovMatrix, 1) If
Len(Test(i, j)) > Maxtest Then
Maxtest = Len(Test(i, j)) End If Next j Next i ' For i = 0 To UBound(VarCovMatrix, 1) For j = 0
To UBound(VarCovMatrix, 2)
LigneVarCov = LigneVarCov & _
Space(Maxtest - Len(Test(i,
j))) & _
Test(i, j) & " " Next j
LigneVarCov = LigneVarCov & vbCrLf Next i ' ' ' Affichage
= Affichage & LigneVarCov & vbCrLf ' '------------------------------------------------------------------ '
Affichage de la matrice des dérivés partielles '------------------------------------------------------------------ ' Ligne6
= " Dérivées partielles des coefficients de régression _ les uns par rapport aux autres" ' Affichage
= Affichage & Ligne6 & vbCrLf ' '
Transformation de la matrice des nombres en une matrice ' contenant
les nombres sous forme de chaînes de caractères 'arrondis
avec n décimales. ' Dim NumBerDecimalPD As Integer NumBerDecimalPD = 3 Maxtest = 0 Test = PrepMat(PartialDerivatesMatrix(),
NumBerDecimalPD) ' '
Recherche du nombre de plus grande taille ' For i = 0 To UBound(PartialDerivatesMatrix, 1) For j = 0
To UBound(PartialDerivatesMatrix, 1) If
Len(Test(i, j)) > Maxtest Then Maxtest = Len(Test(i, j)) End If Next j Next i ' For i = 0 To UBound(PartialDerivatesMatrix, 1) For j = 0
To UBound(PartialDerivatesMatrix, 2)
LignePD = LignePD & Space(Maxtest - Len(Test(i, j))) & Test(i,
j) & " " Next j LignePD = LignePD & vbCrLf Next i ' Affichage
= Affichage & LignePD & vbCrLf ' '------------------------------------------------------------------ '
Affichage de la matrice de corrélation croisée et des écart-types '------------------------------------------------------------------ ' Ligne7
= " Ecrat-Type et matrice des coerrélations croisées" ' Affichage
= Affichage & Ligne7 & vbCrLf ' ' '
Transformation de la matrice des nombres en une matrice '
contenant les nombres sous forme de chaînes de caractères ' arrondis
avec n décimales. ' Dim NumBerDecimalCrossCorr As Integer NumBerDecimalCrossCorr = 3 Maxtest = 0 Test = PrepMat(CrossCorrMat(), NumBerDecimalPD) ' '
Recherche du nombre de plus grande taille ' For i = 0 To UBound(CrossCorrMat, 1) For j = 0
To UBound(CrossCorrMat, 2) If
Len(Test(i, j)) > Maxtest Then
Maxtest = Len(Test(i, j)) End If Next j Next i ' For i = 0 To UBound(CrossCorrMat, 1) For j = 0
To UBound(CrossCorrMat, 2)
LigneCrossCorrMat = LigneCrossCorrMat & _ Space(Maxtest - Len(Test(i, j))) & _ Test(i, j) & " " Next j
LigneCrossCorrMat = LigneCrossCorrMat & vbCrLf Next i ' 'Dim MaxCrossCorrMat 'For i = 1 To UBound(CrossCorrMat, 1) ' For j = 1
To UBound(CrossCorrMat, 2) ' If
Len(CStr(CrossCorrMat(i, j))) > MaxCrossCorrMat Then '
MaxCrossCorrMat = Len(CStr(CrossCorrMat(i, j))) ' End
If ' Next j 'Next i ''Debug.Print "MaxCrossCorrMat = " &
MaxCrossCorrMat 'For i = 1 To UBound(CrossCorrMat, 1) ' For j = 1
To UBound(CrossCorrMat, 2) '
LigneCrossCorrMat = LigneCrossCorrMat & Format(CrossCorrMat(i, j),
"#0.00000") & " " ' Next j '
LigneCrossCorrMat = LigneCrossCorrMat & vbCrLf 'Next i ' ' ' Affichage
= Affichage & LigneCrossCorrMat & vbCrLf ' '------------------------------------------------------------------ '
Fin du sous-programme d'écriture des résultats de la régression. '------------------------------------------------------------------ ' End Function |
Public Function PrepMat(MatCoef() As Double,
NbDecimaleApresPoint As Integer) As String() ' '------------------------------------------------------------------ '
PrepMat - Préparation des données sous diverses formes pour la publications '------------------------------------------------------------------ ' '------------------------------------------------------------------ ' © Copyright 2003 - Paul Salmon '------------------------------------------------------------------ ' Dim Tata As String Dim PosMoins As Long Dim PosPointDecimal As Long Dim PosE As Long Dim NbDecimales As Long Dim LenTata As Long Dim PartieDecimale As String Dim PartieE As String Dim PartieEntiere As String Dim Test() As String Dim i Dim
j ' '
Dimensionnement des matrices. ' ReDim PreMat(0 To UBound(MatCoef, 1), 0 To
UBound(MatCoef, 2)) ReDim Test(0 To UBound(MatCoef, 1), 0 To
UBound(MatCoef, 2)) ' ' ' For i = 0 To UBound(MatCoef, 1) For j = 0
To UBound(MatCoef, 2) ' ' Informations de base sur les nombres
à traiter ' Tata =
CStr(Round(MatCoef(i, j), NbDecimaleApresPoint)) ' ' Caractéristiques de la chaîne à
traiter ' '
Longueur de la chaîne ' LenTata = Len(Tata) ' '
Emplacement du premier moins
(Cas du type E-02) ' PosMoins = InStr(1, Tata,
"-", vbTextCompare) ' '
Emplacement du "." dans la chaîne de caratactères ' PosPointDecimal = InStr(1, Tata,
".", vbTextCompare) ' ' Détermination du nombre de
décimales ' If
PosPointDecimal <> 0 Then
NbDecimales = LenTata - PosPointDecimal Else NbDecimales = 0 End If ' ' Construction de la partie décimale ' If
NbDecimales >= NbDecimaleApresPoint Then
PartieDecimale = _ Mid(Tata,
PosPointDecimal, 1 + NbDecimaleApresPoint) ElseIf
NbDecimales > 0 And NbDecimales _ < NbDecimaleApresPoint Then
PartieDecimale = Mid(Tata, PosPointDecimal, _ 1 + NbDecimales) & _
String(NbDecimaleApresPoint - NbDecimales, "0") ElseIf
NbDecimales = 0 Then PartieDecimale = "." &
String(NbDecimaleApresPoint, "0") End If ' ' Construction de la partie entière ' If
PosPointDecimal <> 0 Then
PartieEntiere = Mid(Tata, 1, PosPointDecimal - 1) Else PartieEntiere = Tata End If '
Test(i, j) = PartieEntiere & PartieDecimale ' Next j Next i PrepMat = Test ' '------------------------------------------------------------------ '
Fin de la fonction PrepMat '------------------------------------------------------------------ ' End
Function |
Plot, fonction de graphique
Les graphiques
Private
Sub Form_Load() ' Change d'abord le type de graphique en
un ' graphique 3D pour voir toutes les
parties du tracé. MSChart1.chartType =
VtChChartType2dLine Dim Toto()
As Double Dim i Dim j Dim
MinRegData Dim
MaxRegData ' MinRegData
= 10000000 MaxRegData
= 0 ReDim
Toto(0 To UBound(RegData, 1), 0 To 1) For i = 0
To UBound(RegData, 1) For j = 0
To 1
Toto(i, j) = RegData(i, j + 1) If
Toto(i, j) > MaxRegData Then
MaxRegData = Toto(i, j) End If If
Toto(i, j) < MinRegData Then
MinRegData = Toto(i, j) End If Next j Next i
MSChart1.ChartData = Toto With
MSChart1.Plot.Axis(VtChAxisIdY).ValueScale .Auto =
False .Minimum =
0.99 * MinRegData .Maximum =
1.01 * MaxRegData End With ' Colore en bleu clair en utilisant ' l'objet Plot. With MSChart1.Plot.Backdrop ' Aucune couleur n'apparaît
sauf si vous attribuez ' à la propriété Style la valeur
VtFillStyleBrush. .Fill.Style = VtFillStyleBrush .Fill.Brush.FillColor.Set 100, 255, 200 ' Ajoute une bordure. .Frame.Style = VtFrameStyleThickInner ' Définit le style pour afficher un
ombrage. .Shadow.Style = VtShadowStyleDrop End With ' Colore le mur du tracé jaune. With MSChart1.Plot ' Choisit un style continu. .Wall.Brush.Style = VtBrushStyleSolid ' Choisit la couleur jaune. .Wall.Brush.FillColor.Set
255, 255, 0 End With With MSChart1.Plot ' Colore
le bleu de base du tracé. .PlotBase.BaseHeight
= 200
.PlotBase.Brush.Style = VtBrushStyleSolid .PlotBase.Brush.FillColor.Set
0, 0, 255 End With End
Sub |
Quelques résultats d’application.
Conclusion
[1] Dans la suite, lorsque nous parlerons du sous-programme Regression, nous écrirons simplement Regression.
[2] Pour les étudiants ayant des difficultés avec le calcul matriciel, ils pourront se reporter aux divers manuels déjà cités. Un chapitre y est généralement. Ils consulteront avec profit la note de méthode sur les moindres carrés ordinaires.