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 , la méthode des moindres carrés ordinaires. Regression s’appuie sur les chapitres 1, 2 et 3 de Matrix in Economics de Clopper Almon (1967). Pour plus de détail sur la méthode elle-même, le lecteur se reportera sur la note Projet Econométrie : Regression.

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 . La construction de la matrice permet l’introduction des données dans Regression, mais il faut aussi récupérer les résultats des calculs contenus dans Regression. La récupération de ces résultats permet de mettre en place des processus de stockage des informations calculées, de les présenter dans des tableaux ou encore des graphiques ou de la stocker. Pour ce faire, il nous faudra préciser ce qui est récupérable dans Regression et suggérer quelques utilisations.

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 que nous devons d’abord construire. Une fois la structure rappelée, nous étudierons comment la construire en fonction des formats des sources de données par exemple. Nous nous efforcerons alors de donner les cas les plus représentatifs, laissant au lecteur le soin de les adapter à ses propres cas. Ce premier travail terminé, nous étudierons de plus près le sous-programme Regression et plus particulièrement les données qui peuvent être récupérées pour d’autres usages. Cette note s’achève sur des exemples d’utilisation.

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 :

                                                                                            (2)

La formulation matricielle de (2) s’écrit

                                                                                                                                (3)

dans laquelle

                                                              (4)

   vecteur colonne des observations de la variables dépendantes ou à expliquer de dimension ,

matrice des observations de variables indépendantes  ou explicatives de dimension

  vecteur colonne des paramètres inconnus de dimension ,

  vecteur colonne des erreurs de dimension .

Le développement des calculs nous amène à voir que la principale relation pour les calculs des moindres carrés ordinaires est :

                                                                                                                        (5)

 est la matrice transposée de ,

est le produit de la transposée de  par ,

est l’inverse de la matrice ci-dessus.[2]

C’est sur la formule (5) qu’est construit le programme.

Il existe de multiples façons d’aborder le problème. est donc obtenu en multipliant la transposée de  par , puis en inversant la matrice précédemment obtenue, le tout post-multiplié par la transposée de et en post-multipliant la matrice résultat par le vecteur .

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 . On l’appelle ainsi parce qu’elle est augmentée d’une ligne sur le côté droit de la matrice définie dans la formule (4).

                                                                                               (5)

La matrice se construit à l’aide de la matrice à laquelle est ajoutée le vecteur colonne . La matrice est la matrice contenant les variables explicatives. Elle contient en première colonne, la constante. La constante est représentée par une succession de 1 dans la colonne 1. Cette constante est un élément important des calculs. Regression ne peut donner des résultats correctes que si elle est présente en première colonne de la matrice.

Regression reçoit , il est nécessaire de la construire. Cette construction est laissée à l’utilisateur. Voyons en les grandes lignes.

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 peuvent provenir de sources très différentes : une ou des bases de données, un ou des fichiers de formats différents. Il alors possible de créer des fonctions qui permettront d’accéder à des structures de données différentes.

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

Loop

'

'------------------------------------------------------------------

' 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,

'   Reading Massachusetts, Chapitre 1-3, pp. 1-57.

'

'   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) = RHO

'   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 RHO As Double              ' RHO

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(NC, NC)

                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(NC, NC)))) - 1)

    '

    ' 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(NC, NC) / NOR) ' Ecart-type de y

    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(NC, NC)))

    '

    ' 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)

'

' RHO et DW

'

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

'

' RHO

'

StatReg(2) = (2 - StatReg(7)) / 2

'

' SEE+1

'

lresid = 0#

For i = 0 To NO

    errp1 = RegData(i, 3) - RHO * lresid

    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 qui est dénommée dans Regression par A. La phase suivante consistera par inverser A. Durant la phase d’inversion, à chaque nouveau pivot, Regression affecte des variables à des vecteurs et des matrices « temporaires ». Regression se termine par le calcul des statistiques et des résidus permettant ainsi de créer les éléments de diagnostic sur la régression.

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  mais aussi de déclarer en tant que variables « Public », les vecteurs et matrices contenant les résultats des calculs. L’encadré 5 contient les déclarations qui sont à faire.

 

 

'

' 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 , il est aussi nécessaire de créer des fonctions ou des sous-programmes qui nous permettront de visualiser les résultats calculés par Regression. Une procédure de visualisation à l’écran, une procédure de graphique et une procédure de création de documents (papier ou Web) constituent les compléments indispensables à l’utilisation de Regression.

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.