Introduction à Visual Basic pour Excel

Création d'une macro

Visual Basic est un langage de programmation qui confère à Excel une grande puissance. Il peut être utilisé pour traiter de nombreux problèmes, par exemple le passage des données des comptabilités des entreprises aux estimations de la comptabilité nationale. Nous allons donc présenter quelques-unes de ses fonctionnalités.

Pour utiliser le langage Visual Basic d'Excel, nous devons d'abord créer une macro. Ouvrons donc un classeur Excel et sélectionnons dans le menu le groupe Développeur. Si ce groupe n'apparaît pas dans le menu, nous devons aller dans Fichiers puis dans Options. Dans le cadre qui apparaît cliquons sur Personnaliser le ruban. Dans la partie droite du cadre, il faut cocher l'option Développeur puis cliquer sur OK.

Nous pouvons maintenant aller dans le menu et sélectionner le groupe Développeur. À gauche du menu on trouve les icônes suivants :

Pour créer une macro, plusieurs méthodes sont possibles. La méthode la plus simple consiste à cliquer sur Macros. Apparaît alors le cadre Macro dans lequel nous devons rentrer le nom de la macro que nous voulons créer, puis cliquer sur Créer. Donnons donc à notre première macro le nom essai.

On arrive alors dans l'éditeur Visual Basic. Dans la zone située à droite de l'écran apparaissent les lignes suivantes :

Sub essai()
 
End Sub

C'est entre les instructions Sub essai() et End Sub que devra être écrit notre programme Visual Basic.

La deuxième méthode consiste à cliquer sur l'icône Visual Basic. Apparaît alors l'éditeur Visual Basic. Il se présente sous la forme suivante :

Les macros doivent être créées dans des modules. Il faut donc commencer par créer un module. Pour cela, on peut aller dans le menu et sélectionner Insérer puis module. Le module apparaît alors dans la partie droite. Son nom par défaut est Module1, on peut le changer en allant dans la fenêtre Propriétés située dans le coin inférieur gauche.

On peut alors commencer à écrire une macro dans le module qui est apparu dans la zone de travail située à droite. Tapons donc :

sub essai()

puis la touche Entrée. Nous voyons alors apparaître :

Sub essai()
 
End Sub

Le mot Sub est l'abréviation de Subroutine, c'est-à-dire en français de procédure qui est une autre manière de nommer une macro ou un programme.

Notre premier programme

Notre premier exercice consistera à faire apparaître Bonjour dans la cellule B2. Pour cela nous allons taper l'instruction :
Range("B2") = "Bonjour"
entre les instructions Sub essai et End Sub. Nous obtenons :

En cliquant à l'intérieur du programme puis sur la flèche du menu, nous lançons le programme et, miraculeusement (ou presque !), nous voyons apparaître Bonjour dans la cellule B2 de la feuille Excel.

Nous aurions également pu lancer notre macro depuis le menu de la feuille Excel en allant dans le menu le groupe Développeur puis en cliquant sur Macros. Dans le cadre Macro, sélectionnons le nom de la macro et cliquons sur Exécuter, "Bonjour" apparaît alors.

Expliquons donc comment fonctionne ce programme. Range désigne une plage de cellules de la feuille en cours, c'est-à-dire un ensemble de cellules. Ici, la plage est composé d'une seule cellule et est repérée par ses coordonnées. Notons la présence obligatoire de guillemets, faute de quoi le programme comprendrait que B2 est une variable ayant la valeur zéro. Nous attribuons à la cellule la valeur Bonjour. Là encore la présence de guillemets est indispensable. La plage peut aussi être un ensemble de cellules, par exemple si nous écrivons :

Sub essai()
Range("B2:C5") = "Bonjour"
End Sub

Nous obtenons :

Si nous attribuons un nom à la plage dans la feuille Excel, nous pouvons dans la macro remplacer les coordonnées par le nom de la plage, toujours placé entre guillemets.

Objets, propriétés et méthodes

Des objets

En fait, une plage de cellules est ce que les informaticiens appellent un objet.

Un objet représente un élément du classeur Excel, par exemple une feuille de calcul ou une cellule.

Cet objet possède différentes propriétés que l'on peut modifier à partir de Visual Basic.

Qand nous avons écrit Range("B2:C5") = "Bonjour", nous avons attribué une valeur à la plage de cellules. Nous aurions donc pu écrire plus précisément :

Range("B2:C5").Value = "Bonjour"

Nous aurions obtenu le même résultat. Value est en fait une propriété de l'objet Range mais il n'est pas nécessaire de l'écrire car c'est la propriété par défaut de l'objet Range.

Nous pouvons changer d'autres propriétés de la plage de cellules, par exemple sa couleur :

Range("B2:C5").Interior.ColorIndex = 6

La plage de cellules apparaît alors avec un fond jaune.

Nous avons utilisé ici la propriété Interior de l'objet Range, elle désigne l'intérieur du champ. Mais l'intérieur du champ est lui-même un objet qui a ses propres propriétés. L'une de ces propriétés est ColorIndex qui correspond à un code couleur.

Il est important de noter la manière d'utiliser les objets et leurs propriétés. L'objet est suivi d'un point et de sa propriété. Dans notre exemple, la propriété étant elle-même un objet elle est également suivie d'un point et de sa propriété.

À l'inverse, la propriété d'un objet peut être récupérée et utilisée dans une ligne de code. Par exemple :

Range("D1").Interior.ColorIndex=Range("B2:C5").Interior.ColorIndex

La couleur jaune du champ "B2:C5" a été affectée au champ "D1". Cet exemple montre le rôle du signe =, il permet d'affecter la valeur de la propriété placée à droite du signe = à la propriété placée à sa gauche.

On peut également récupérer la valeur de la propriété ColorIndex et l'afficher dans une cellule. Par exemple :

Range("F3")=Range("B2:C5").Interior.ColorIndex

Le nombre 6 apparaît dans la cellule "F3".

Une autre propriété de l'objet Range est Font qui définit la police des caractères du champ. Font est également un objet ayant ses propres propriétés parmi lesquelles Bold qui définit les caractères gras. Par exemple :

Range("F3:H7").Font.Bold = True

Tous les caractères du champ "F3:H7" apparaissent alors en gras. On peut modifier plusieurs caractères du même objet grâce à l'instruction With qui doit impérativement être suivie de End With. Toutes les instructions modifiant les propriétés doivent être placées entre With et End With, par exemple :

With Range("J5:L20")
    .Interior.ColorIndex = 6
    .Font.Bold = True
End With

De cette manière le fond du champ "J5:L20" est jaune et ses caractères sont gras. Notons que les propriétés doivent être précédées d'un point.

Des collections

Un classeur Excel étant composé de différentes feuilles, il est généralement intéressant de préciser dans quelle feuille on veut envoyer les données. En effet, par défaut, les données sont envoyées dans la feuille active mais, lorsqu'on lance la macro, la feuille active n'est toujours celle que nous voudrions modifier. Aussi, nous pouvons préciser la feuille de travail en la désignant soit par son numéro, soit par son nom. Par exemple, si nous souhaitons écrire Bonjour sur la deuxième feuille nous pouvons écrire soit :

Sub essai()
Sheets(2).Range("B2:C5") = "Bonjour"
End Sub

Soit :

Sub essai()
Sheets("Feuil2").Range("B2:C5") = "Bonjour"
End Sub

Pour Visual Basic, une feuille d'un classeur est un objet et l'ensemble des feuilles du classeur constitue une collection.

Sheets est la collection constituée de l'ensemble des feuilles d'un classeur, Sheets(2) est un objet de la collection Sheets qui représente la deuxième feuille du classeur actif.

Des méthodes

Une méthode est une action portant sur un objet.

Par exemple, la méthode ClearContents efface le contenu d'une cellule ou d'une plage de cellules avec . Ainsi, le programme ci-dessous efface le contenu de la plage "C2:C5" de la deuxième feuille :

Sub essai()
Sheets("Feuil2").Range("B2:C5").ClearContents
End Sub

Si on utilise Clear au lieu de ClearContents, on efface également le format.

Pour trouver la liste des propriétés et des méthodes se rapportant à un objet on peut taper dans l'éditeur Visual Basic le nom de l'objet puis, lorsque l'on tape le point, les propriétés et les méthodes apparaissent dans une liste déroulante. Par exemple :

Dans la liste l'icône désigne une propriété et une méthode.

On peut obtenir une aide sur un objet, une propriété ou une méthode dans l'éditeur Visual Basic en le sélectionnant et en cliquant la touche de fonction F1 du clavier.

Sélectionner des cellules

Un autre moyen de sélectionner une cellule est d'utiliser la propriété Cells qui s'applique soit à une feuille, soit à un champ. Cells(i,j) renvoie une cellule définie par l'intersection d'une ligne et d'une colonne, i désignant un numéro de ligne et j un numéro de colonne.

Par exemple, le programme suivant écrit Bonjour à l'intersection la troisième ligne et de la quatrième colonne de la feuille Feuil1 :

Sub essai()
ThisWorkBook.Sheets("Feuil1").Cells(3,4) = "Bonjour"
End Sub

ThisWorkBook est l'objet correspondant au classeur d'où est lancé le programme.

On peut appliquer Cells non seulement à une feuille mais aussi à une plage de cellules. Par exemple, le programme ci-dessous va écrire "Bonjour" dans la cellule "C4" :

Sub essai()
Sheets("Feuil1").Range("B2:H8").Cells(3, 2) = "Bonjour"
End Sub

En effet, la cellule "C4" est à l'intersection de la troisième ligne et de la deuxième colonne de la plage "B2:H8".

Un langage orienté objet

Visual Basic est un langage orienté objet et l'on voit ici apparaître la logique de sa syntaxe. Sheets est une collection d'objet, Sheets(2) un objet qui possède des plages, les plages sont des objets possédant des caractéristiques.

Il y a une hiérarchie allant du classeur à la cellule. La description va du général au particulier, de la collection à l'objet, de l'objet à ses composantes, chaque élément étant séparé par un point.

Ainsi, nous aurions également pu préciser le nom du classeur. Dans notre exemple il s'appelle Classeur1 et nous pouvons donc écrire :

Sub essai()
Workbooks("Classeur1").Sheets("Feuil2").Range("B2:C5").Value = "Bonjour"
End Sub

Workbooks désigne l'ensemble des classeurs et Workbooks("Classeur2") le classeur qui a pour nom Classeur1.

Pour désigner le classeur contenant la macro, on peut écrire :

ThisWorkbook.Sheets("Feuil2").Range("B2:C5").Value = "Bonjour"

Utiliser des variables

Visual Basic n'est utile que dans la mesure où il peut traiter des informations que lui communique l'utilisateur. Pour cela il utilise des variables où il va stocker les données.

Il est important de savoir que les nombres décimaux entrés dans un programme doivent l'être en utilisant le point comme séparateur décimal et non la virgule.

Par exemple, on doit écrire 12.5 et non 12,5 comme c'est le cas en français.

Nous allons prendre l'exemple d'une macro qui permet de calculer le produit de deux nombres. Supposons donc que nous ayons créé une feuille se nommant Produit et se présentant de la manière suivante :

Nous allons stocker le premier nombre dans une variable que nous appellerons a et le deuxième dans une variable que nous appellerons b. Le résultat sera stocké dans une variable c. La macro Calcul fera le calcul et fera apparaître 90 dans la cellule B3 :

Sub Calcul()
Set f = Workbooks("Classeur1").Sheets("Produit")
a = f.Range("B1")
b = f.Range("B2")
c = a * b
f.Range("B3") = c
End Sub

Dans cette macro nous avons d'abord introduit une variable f. C'est une variable dite variable objet car elle ne représente pas une valeur mais un objet, qui est ici la feuille Produit. Cette variable doit être introduite par l'instruction Set.

Nous introduisons ensuite les deux variables a et b auxquelles nous attribuons les valeurs des cellules B1 et B2. Ces deux variables ne doivent pas être introduites par l'instruction Set car elles sont destinées à contenir des valeurs. Remarquons que f.Range("B1") représente la plage B1 de la feuille f, c'est-à-dire de la feuille Produit. Le produit est ensuite stocké dans la variable c et affiché dans la cellule B3. Notons ici que l'instruction c=a*b n'est pas une équation, elle signifie simplement que le contenu de la partie droite du signe égal est affecté à la variable située à gauche du signe égal, mais on ne pourrait pas écrire, par exemple, c+1=a*b

Les variables peuvent également contenir des textes, par exemple le programme suivant

Sub Calcul()
Set f = Workbooks("Classeur1").Sheets("Produit")
a = f.Range("B1")
b = f.Range("B2")
c = a * b
f.Range("B3") = c
d = "La somme de " & a & " et " & b & " est égale à " & a + b
f.Range("A4") = d
End Sub

donnera :

Dans cette macro & est l'opérateur de concaténation, il permet de combiner des textes et même des textes et des nombres car ceux-ci sont alors convertis en texte.

Déclaration des variables

Il est fortement recommandé de définir les variables en début de programme grâce à l'instruction Dim. Cette instruction doit être suivie du nom de la variable puis de As, puis du type de la variable. Par exemple :

Dim a As Integer

Dim c As Double

Dim d As String * 80

Pour définir une variable de type String, on peut définir sa longueur en la précédant d'une astérisque.

Les différents types de variables sont les suivants :

Boolean

Byte

Char (caractère unique)

Date

Decimal

Double (nombre à virgule flottante double précision)

Integer

Long (entier long)

object

SByte

Short (entier court)

Single (nombre à virgule flottante simple précision)

String (caractères, longueur variable)

UInteger

ULong

User-Defined (structure)

UShort

Incrémentation

Dans le langage Visual Basic, une variable fait référence à un emplacement de la mémoire de l'ordinateur. Lorsqu'on attribue une valeur à une variable en écrivant une égalité, le programme commence par évaluer l'expression qui se situe à droite du signe égal et place le résultat à l'emplacement défini par le nom de la variable qui est à gauche du signe égal. Par exemple, lorsqu'on écrit c=a*b, le programme va chercher le contenu des variables a et b, fait la multiplication et place le résultat dans l'emplacement correspondant à la variable c.

Il est donc possible d'écrire une même variable des deux côtés du signe égal. Cette possibilité est utilisée notamment dans le cas particulièrement important de l'incrémentation. L'incrémentation est une opération qui consiste à ajouter une valeur entière à un compteur. Par exemple, si i désigne une variable entière de valeur 10, on peut écrire :

i = i + 1

Après l'exécution de cette ligne la variable i sera égale à 11.

Les fonctions

Il existe un très grand nombre de fonctions disponibles dans Visual basic pour Excel. Par exemple, on peut utiliser les fonctions mathématiques suivantes :

Fonction
Abs	Retourne la valeur absolue d'un nombre.
Cos	Retourne le cosinus de l'angle spécifié.
Exp	Retourne e (la base des logarithmes népériens) déclenché à la puissance spécifiée.
Log	Retourne le logarithme naturel d'un nombre spécifié ou le logarithme d'un nombre spécifié dans une base spécifiée.
Round	Retourne une valeur Decimal ou Double arrondie à la valeur intégrale la plus proche ou à un nombre de chiffres fractionnaires.
Sin	Retourne le sinus de l'angle spécifié.
Tan	Retourne la tangente de l'angle spécifié.

Par exemple, le programme suivant :

Sub Calcul()
Set f = Workbooks("Classeur1").Sheets("Produit")
f.Range("B1")=Abs(-34.54)
f.Range("B2")=Cos(2.67)
End Sub

Renvoie 34,54 dans la cellule "B1" et -0,890845867 dans la cellule "B2".

On peut également travailler avec les fonctions de la feuille de calcul grâce à Application.WorksheetFunction. Par exemple, le programme suivant renvoie 12,6 dans la cellule "B6" :

Sub Calcul()
Set f = Workbooks("Classeur1").Sheets("Produit")
f.Range("B6") = Application.WorksheetFunction.Max(8.5, 12.6)
End Sub

On remarquera qu'en Visual Basic les nombres doivent être entrés avec le point décimal et que le séparateur est la virgule.

On peut également travailler avec des plages à condition de les définir comme des variables. Par exemple, le programme suivant renvoie la somme des cellules de la plage "B1:B4" dans la cellule "B5" :

Sub Calcul()
Set f = Workbooks("Classeur1").Sheets("Produit")
Set plage = f.Range("B1:B4")
f.Range("B5") = Application.WorksheetFunction.Sum(plage)
End Sub

Visual Basic fournit également des fonctions pour travailler avec des chaînes de caractère. Par exemple :

Fonction	Description
Chr	Retourne le caractère associé au code du caractère spécifié.
Format	Retourne une chaîne mise en forme conformément aux instructions contenues dans une expression String de format.
InStr	Retourne un entier spécifiant la position de début de la première occurrence d'une chaîne à l'intérieur d'une autre.
Left	Retourne une chaîne contenant un nombre spécifié de caractères en partant de la gauche d'une chaîne.
Len	Retourne un entier contenant le nombre de caractères dans une chaîne.
LTrim	Retourne une chaîne contenant une copie d'une chaîne spécifiée sans espaces à gauche.
Mid	Retourne une chaîne contenant un nombre spécifié de caractères d'une chaîne.
Replace	Retourne une chaîne dans laquelle une sous-chaîne spécifiée a été remplacée par une autre sous-chaîne, un nombre de fois déterminé.
Right	Retourne une chaîne contenant un nombre spécifié de caractères depuis la partie droite d'une chaîne.
RTrim	Retourne une chaîne contenant une copie d'une chaîne spécifiée sans espaces à droite.
Space	Retourne une chaîne composée d'un nombre spécifié d'espaces.
Trim	Retourne une chaîne contenant une copie d'une chaîne spécifiée sans espaces à gauche ni à droite.

Par exemple Replace("abcd", b, c) renvoie "accd".

Instructions conditionnelles

IF...THEN

Il est souvent intéressant d'utiliser dans les macros des instructions qui ne seront exécutées que dans certaines circonstances. Cela peut être réalisé grâce à l'instruction IF...THEN. Par exemple, supposons que la feuille Tableau se présente comme ci-dessous et que l'on cherche à recopier dans la deuxième colonne tous les nombres supérieurs à 20.

La macro suivante obtient ce résultat :

Sub Test()
Set f = Sheets("Tableau")
For i = 1 To 6
    If f.Cells(i, 1) > 20 Then
       f.Cells(i, 2) = f.Cells(i, 1)
    End If
Next i
End Sub

Nous obtenons :

Cette macro nous montre la structure de l'instruction IF...THEN. La condition doit être placée après IF et avant THEN. Entre THEN et END IF doivent être placées les instructions qui ne seront exécutées que lorsque la condition sera remplie. Remarquons également comment procède la macro pour recopier une valeur d'une cellule dans une autre cellule, c'est la méthode la plus efficace pour le faire.

Nous pouvons introduire dans la condition des opérateurs comme AND ou OR qui lient des conditions.

La condition Condition1 AND Condition2 est vraie si Condition1 et Condition2 sont vraies toutes les deux.

La condition Condition1 OR Condition2 est vraie si au moins l'une des deux conditions est vraie.

Par exemple, si nous voulons recopier dans la deuxième colonne uniquement les valeurs supérieures à 20 et inférieures à 50, nous pourrions utiliser la macro suivante :

Sub Test()
Set f = Sheets("Tableau")
For i = 1 To 6
    If f.Cells(i, 1) > 20 And f.Cells(i, 1) < 50 Then
       f.Cells(i, 2) = f.Cells(i, 1)
    End If
Next i
End Sub

Nous aurions obtenu :

Si nous avions voulu recopier les nombres inférieurs à 20 ou supérieurs à 30, nous aurions pu utiliser la macro suivante :

Sub Test()
Set f = Sheets("Tableau")
For i = 1 To 6
    If f.Cells(i, 1) < 20 Or f.Cells(i, 1) > 30 Then
       f.Cells(i, 2) = f.Cells(i, 1)
    End If
Next i
End Sub

Nous aurions obtenu :

Nous pouvons ajouter à l'intérieur de la séquence IF...THEN...END IF une clause ELSE afin de spécifier des instructions qui doivent être exécutées quand la condition n'est pas vérifiée. Par exemple, si nous voulons recopier dans la deuxième colonne les nombres supérieurs à 20 et recopier dans la troisième colonne les autres, nous pouvons utiliser la macro suivante :

Sub Test()
Set f = Sheets("Tableau")
For i = 1 To 6
    If f.Cells(i, 1) > 20 Then
       f.Cells(i, 2) = f.Cells(i, 1)
   Else
       f.Cells(i, 3) = f.Cells(i, 1)
    End If
Next i
End Sub

Nous obtenons :

Opérateurs de comparaison

Les instructions conditionnelles utilisent des opérateurs de comparaison, ce sont :

< (Inférieur à)

<= (Inférieur ou égal à)

> (Supérieur à)

>= (Supérieur ou égal à)

= (Égal à)

<> (Différent de)

Opérateurs logiques

Pour combiner des expressions dans des instructions conditionnelles il est possible d'utiliser des opérateurs logiques.

Les opérateurs And, Or et Xor permettent de combiner deux expressions logiques. Ainsi :

Expression1 And Expression2 est vraie lorsque Expression1 et Expression2 sont toutes deux vraies, elle renvoie alors la valeur True.

Expression1 And Expression2 est fausse lorsqu'au moins l'une des deux expressions Expression1 et Expression2 est fausse, elle renvoie alors la valeur False.

Expression1 Or Expression2 est vraie lorsqu'au moins une des deux expressions Expression1 et Expression2 est vraie, elle renvoie alors la valeur True.

Expression1 Or Expression2 est fausse lorsque Expression1 et Expression2 sont toutes deux fausses, elle renvoie alors la valeur False.

Expression1 Xor Expression2 est vraie lorsqu'une seule des deux expressions Expression1 et Expression2 est vraie, elle renvoie alors la valeur True.

Expression1 Xor Expression2 est fausse lorsque les deux expressions Expression1 et Expression2 sont soit toutes deux vraies, soit toutes deux fausses, elle renvoie alors la valeur False.

Exemples :

6 > 4 And 5 > 3 est vrai
6 > 9 And 5 > 3 est faux
6 > 4 Or 5 > 9 est vrai
6 > 9 Or 5 > 9 est faux
6 > 9 Xor 5 > 3 est vrai
6 > 4 Xor 5 > 3 est faux
6 > 9 Xor 5 > 9 est faux

L'opérateur Not effectue une négation sur une expression logique. Par exemple Not 4 > 5 est vrai.

Notons que :

Not (Expression1 And Expression2) équivaut à (Not Expression1) Or (Not Expression2)

Not (Expression1 Or Expression2) équivaut à (Not Expression1) And (Not Expression2)

La valeur logique True équivaut à la valeur numérique -1 et la valeur logique False correspond à 0. Cette équivalence peut parfois être utilisée, par exemple si l'on veut connaître le nombre d'expressions vraies. Ainsi :

Range("G5") = (3 > 2) + (4 > 5) + (3 = 3) + (5 > 9) + (2 > 6)

Le nombre -2 apparaît dans la cellule G5, ce qui signifie que deux expressions sur les 5 sont vraies.

Select Case

On peut utiliser l'instruction Select Case lorsque l'on veut comparer une variable à plusieurs valeurs. L'instruction Select Case doit impérativement être terminée par End Select.

Par exemple :

a = Range("A1")
Select Case a
     Case 3
         Range("B1") = 5 * a
     Case 4
         Range("B1") = 10 * a
     Case 6
         Range("B1") = 20 * a
     Case Else
         Range("B1") = a / 10
End Select

Si le nombre 3 est dans la cellule A1 le programme renvoie 15 dans la cellule B1.
Si le nombre 4 est dans la cellule A1 le programme renvoie 40 dans la cellule B1.
Si le nombre 6 est dans la cellule A1 le programme renvoie 120 dans la cellule B1.
Dans tous les autres cas le programme renvoie dans la cellule B1 le nombre contenu dans la cellule A1 divisé par 10.

On peut également comparer la variable non pas à une mais à plusieurs valeurs. Pour cela on peut utiliser une liste de valeurs séparées par des virgules, un intervalle de valeurs ou un opérateur précédé de Is. Par exemple :

a = Range("A1")
Select Case a
     Case 2, 3.5, 6.2
         Range("B1") = 5 * a
     Case 8 To 10
         Range("B1") = 10 * a
     Case Is > 12
         Range("B1") = 20 * a
     Case Else
         Range("B1") = a / 10
End Select

Travailler avec des boucles

L'une des forces principales des programmes et donc des macros est de permettre de réaliser très simplement des calculs itératifs. Ils utilisent pour cela des boucles.

Next...For

Supposons que nous cherchions à faire la somme des dix nombres de la feuille Somme suivante :

Le programme suivant :

Sub Somme()
Set f = ThisWorkBook.Sheets("Somme")
t = 0
For i = 1 To 10
    a = f.Cells(i, 2)
    t = t + a
Next i
f.Cells(12, 2) = t
End Sub

fait apparaître la somme 549 en cellule B12

Dans cette macro, la variable t qui est destinée à recevoir la somme est d'abord initialisée à zéro, ce qui n'est pas obligatoire dans ce cas précis puisqu'une nouvelle variable est initialisée à zéro, mais c'est une règle de précaution lorsque l'on procède par itérations. La boucle correspond à l'instruction For ... Next. Cette instruction fait appel à une variable de comptage, ici i qui va prendre successivement toutes les valeurs comprises entre 1 et 10. Toutes les instructions comprises entre For et Next seront exécutées successivement pour chaque valeur de i, c'est-à-dire 1, 2, 3 ... 9, 10.

f.Cells(i,2) désigne la cellule située à la ième ligne de la deuxième colonne de la feuille f, c'est-à-dire la feuille Somme. Au début de la boucle, le compteur i prend la valeur 1. f.Cells(i,2) devient f.Cells(1,2) qui a la valeur 50, cette valeur est affectée à la variable a.

À la ligne suivante, dans la partie droite de l'égalité, la variable t vaut 0 car c'est la valeur qui lui a été affectée au début du programme, t+a vaut donc 0+50=50. Cette valeur de 50 est affectée à la variable située à gauche du signe égal, c'est-à-dire t. Le programme arrive ensuite à l'instruction Next i, il donne alors à i la valeur 2 et revient à la première ligne après l'instruction For.

La variable a prend alors la valeur de f.Cells(2,2), c'est-à-dire 100. A la ligne suivante, dans la partie droite, la variable t a la valeur 50 qui lui a été affectée au tour précédent, t+a a donc la valeur 50+100=150. Cette valeur est alors affectée à la variable de la partie gauche, c'est-à-dire t qui devient donc égale à 150. Le programme arrive ensuite à l'instruction Next et donne au compteur i la valeur 2. Il reprend ensuite à la première ligne située après l'instruction Next.

Ce processus va se poursuivre jusqu'à ce que le compteur parvienne à 10. A la fin de la dixième boucle le programme continue au delà de l'instruction Next. La variable t contient alors la somme des 10 nombres de la deuxième colonne de la feuille Somme. Cette somme est affichée dans la cellule correspondant à la douzième ligne de la deuxième colonne de la feuille Somme. Ce programme montre la manière classique de calculer une somme de valeurs avec Visual Basic mais il en existe d'autres.

Do While...Loop

Une autre manière de réaliser des boucles est d'utiliser l'instruction Do While...Loop. Celle-ci va effectuer une boucle tant qu'une condition est vérifiée. Par exemple, nous aurions pu écrire le programme précédent de la manière suivante :

Sub Somme1()
Set f = Sheets("Somme")
t = 0
i = 1
Do While i <= 10
    a = f.Cells(i, 2)
    t = t + a
    i = i + 1
Loop
f.Cells(12, 2) = t
End Sub

Dans cette macro la boucle va de l'instruction Do While à l'instruction Loop et elle est éffectuée tant que la variable i est inférieure ou égale à 10.

For Each...Next

Il est possible également d'utiliser la boucle For Each ... Next en association avec la fonction Array() afin de sélectionner certaines valeurs dans une liste. Par exemple, si nous voulons faire le toatal des lignes 2, 7 et 9, nous pouvons utiliser la macro suivante :

Sub Somme1()
Set f = Sheets("Somme")
t = 0
i = 1
For Each i In Array(2, 7, 9)
    a = f.Cells(i, 2)
    t = t + a
    i = i + 1
Next i
f.Cells(12, 2) = t
End Sub

Nous voyons 161 s'afficher dans la ligne 12.

Nous pouvons également utiliser Array pour une liste de valeurs alphanumériques à condition d'insérer ces valeurs entre guillemets.

Exemple d'application : le modèle keynésien

Nous pouvons utiliser un progamme pour élaborer un modèle keynésien simplifié. Pour cela nous allons considérer les équations de base suivantes :

Production = consommation intermédiaire + consommation finale + investissement

Consommation intermédiaire = tauxCI * production

Valeur ajoutée = production - consommation intermédiaire

Revenu = valeur ajoutée

Consommation finale = tauxCF * revenu + 100

Dans ce modèle, l'investissement est introduit comme une variable exogène, il génère une production qui génère une valeur ajoutée et un revenu. Le revenu génère à son tour une consommation finale qui fait croître la production. La croissance de la production génère alors une croissance de la production. Il s'enclenche donc un phénomène itératif que nous pouvons reproduire dans un programme.

Pour cela dans une feuille nommée Modele nous allons d'abord introduire les variables exogènes, c'est-à-dire tauxCI en B1, tauxCF en B2 et l'investissement en B3.

Commençons par ce programme qui calcule la production, le revenu et la consommation finale à partir des données exogènes sans faire d'itération. Il se présente ainsi :

Sub modele()
Dim tauxCI, tauxCF, Investissement, Production, CI, VA, Revenu, CF As Double
Set f = ThisWorkbook.Sheets("Modele")
'-------------------------------------------------------------------------------
' Saisie des variables exogènes
tauxCI = f.Range("B1")
tauxCF = f.Range("B2")
Investissement = f.Range("B3")
'-------------------------------------------------------------------------------

CI = tauxCI * Production ' CI désigne la consommation intermédiaire
VA = Production - CI ' VA désigne la valeur ajoutée
Revenu = VA
CF = tauxCF * Revenu + 100
Production = CI + CF + Investissement

'-------------------------------------------------------------------------------
' Affichage des résultats
Range("B5") = Production
Range("B6") = CI
Range("B7") = VA
Range("B8") = Revenu
Range("B9") = CF

End Sub

Remarquons que des commentaires peuvent être introduits en les précédant d'une apostrophe.

Introduisons les variables exogènes dans la feuille modèle :
TauxCI =0,6
TauxCF = 0,8
Investissement = 200

Si nous lançons le programme nous trouvons une production de 300 et une consommation finale de 100. Ce résultat est faux car la consommation intermédiaire, le revenu et la consommation finale ont été calculés à partir d'une production initiale de O. Si nous voulons lancer nos itérations nous pouvons introduire une boucle Next...For de la manière suivante :

Sub modele()
Dim tauxCI, tauxCF, Investissement, Production, CI, VA, Revenu, CF As Double
Set f = ThisWorkbook.Sheets("Modele")
'-------------------------------------------------------------------------------
' Saisie des variables exogènes
tauxCI = f.Range("B1")
tauxCF = f.Range("B2")
Investissement = f.Range("B3")
'-------------------------------------------------------------------------------
' Itérations
For i = 1 To 10
    CI = tauxCI * Production ' CI désigne la consommation intermédiaire
    VA = Production - CI ' VA désigne la valeur ajoutée
    Revenu = VA
    CF = tauxCF * Revenu + 100
    Production = CI + CF + Investissement
Next i
'-------------------------------------------------------------------------------
' Affichage des résultats
Range("B5") = Production
Range("B6") = CI
Range("B7") = VA
Range("B8") = Revenu
Range("B9") = CF

End Sub

Dans ce programme nous avons fait 10 itérations. La production calculée à la fin d'une itération est reprise au début de l'itération suivante. Nous trouvons une production de 2121,0 et une consommation intermédiaire de 1187,6, ce qui est faux puisque cette dernière devrait être 2121 × 0,6 = 1272,6

Nous n'avons pas fait assez d'itérations et nous pouvons modifier notre programme en lui faisant faire 1000 itérations. Nous obtenons alors :

Production = 3750
Consommation intermédiaire = 2250
Valeur ajoutée = 1500
Revenu = 1500
Consommation finale = 1300

Nous pouvons vérifier que ces résultats sont corrects. Le problème est que plus le nombre d'itérations est grand et plus l'exécution du progamme prend du temps. Nous pouvons donc introduire un indicateur qui nous montrera si le nombre d'itérations est suffisant. Pour cela, nous pouvons, par exemple, calculer l'écart entre la valeur de la production au début de l'itération et sa valeur à la fin. Modifions donc notre programme de la manière suivante :

Sub modele()
Dim tauxCI, tauxCF, Investissement, Production, CI, VA, Revenu, CF As Double
Set f = ThisWorkbook.Sheets("Modele")
'-------------------------------------------------------------------------------
' Saisie des variables exogènes
tauxCI = f.Range("B1")
tauxCF = f.Range("B2")
Investissement = f.Range("B3")
'-------------------------------------------------------------------------------
' Itérations
For i = 1 To 50
    Prod = Production
    CI = tauxCI * Production ' CI désigne la consommation intermédiaire
    VA = Production - CI ' VA désigne la valeur ajoutée
    Revenu = VA
    CF = tauxCF * Revenu + 100
    Production = CI + CF + Investissement
    Ecart = Production - Prod
Next i
'-------------------------------------------------------------------------------
' Affichage des résultats
Range("B5") = Production
Range("B6") = CI
Range("B7") = VA
Range("B8") = Revenu
Range("B9") = CF
Range("B10") = Ecart

End Sub

Avec ce programme qui fait 50 itérations nous trouvons un écart de 5,04. Si nous faisons 100 itérations l'écart tombe à 0,08.

Plutôt que de tester successivement un certain nombre d'itérations nous pouvons préférer fixer une valeur de l'écart qui nous semble acceptable et utiliser une boucle Do While. Pour cela, il suffit de remplacer dans l'ancien programme la boucle For...Next par une boucle Do While...Loop portant sur la variable Ecart. Si nous souhaitons un écart de 0,01 le programme devient :

Sub modele()
Dim tauxCI, tauxCF, Investissement, Production, CI, VA, Revenu, CF As Double
Set f = ThisWorkbook.Sheets("Modele")
'-------------------------------------------------------------------------------
' Saisie des variables exogènes
tauxCI = f.Range("B1")
tauxCF = f.Range("B2")
Investissement = f.Range("B3")
'-------------------------------------------------------------------------------
' Itérations
Ecart = 1
Do While Ecart > 0.01
    Prod = Production
    CI = tauxCI * Production ' CI désigne la consommation intermédiaire
    VA = Production - CI ' VA désigne la valeur ajoutée
    Revenu = VA
    CF = tauxCF * Revenu + 100
    Production = CI + CF + Investissement
    Ecart = Production - Prod
Loop
'-------------------------------------------------------------------------------
' Affichage des résultats
Range("B5") = Production
Range("B6") = CI
Range("B7") = VA
Range("B8") = Revenu
Range("B9") = CF
Range("B10") = Ecart

End Sub

Dans le programme il a été nécessaire d'initialiser Ecart avec une valeur supérieure à 0,01 pour que la boucle puisse s'effectuer. Nous trouvons :

Production = 3749,89
Consommation intermédiaire = 2249,93
Valeur ajoutée = 1499,95
Revenu = 1499,95
Consommation finale = 1299,96
Ecart = 0,01

Les variables multidimensionnelles

Il est possible de travailler dans Visual Basic avec des variables à plusieurs dimensions. Par exemple, nous pouvons vouloir saisir le tableau ci-dessous dans une variable à deux dimensions.

Pour cela nous devons au préalable utiliser l'instruction Dim qui précise la dimension de la variable. Ainsi, si nous désignons par A la variable dans laquelle nous voulons saisir le tableau, la macro suivante montre comment saisir le tableau dans la variable A pour le recopier ensuite plus bas et transposé en le relisant à partir de A. Le tableau est supposé être écrit dans la feuille Tableau

Sub Multi()
Dim A(5, 2)
Set f = Sheets("Tableau")
For i = 1 To 5
    For j = 1 To 2
       A(i, j) = f.Cells(i, j)
    Next j
Next i
For i = 1 To 5
    For j = 1 To 2
       f.Cells(j + 6, i) = A(i, j)
    Next j
Next i
End Sub

Le résultat sera le suivant :

L'instruction Dim précise que le tableau a 2 dimensions, la première repérée par un indice qui va de 0 à 5, la seconde par un indice qui va de 0 à 2.

Ensuite, nous voyons l'utilisation de boucles imbriquées puisque nous avons deux groupes d'instructions For...Next, la première qui utilise le compteur i, la seconde qui utilise le compteur j. Ces deux boucles doivent être impérativement emboîtées, c'est-à-dire respecter l'ordre suivant :

For i...
...
   For j...
...
   Next j...
...
Next i...

Dans la première partie, la variable A est remplie à partir des cellules de la feuille, dans la seconde partie, les valeurs contenues dans la variable A sont recopiées sur la feuille en décalant les lignes de 6 vers le bas. La transposition se fait extrêmement simplement en intervertissant dans f.Cells(i,j) i par j.

REMARQUE : lorsqu'on utilise Cells(i,j), il peut être intéressant, au moins temporairement, de changer la présentation de la feuille de calcul en faisant apparaître les numéros des colonnes. Pour cela, dans le menu d'Excel, il faut aller au groupe Fichiers, choisir Options, puis Formules et cocher l'option Style de référence L1C1.

Option Base 1

Par défaut, les indices d'un tableau commencent à zéro. Si l'on veut que tous les tableaux commencent avec l'indice 1, il faut indiquer Option Base 1 au tout début du module où se trouve le programme, c'est-à-dire avant tous les programmes.

Si nous voulons qu'un seul tableau commence à l'indice 1, nous pouvons le préciser au niveau de la déclaration Dim, par exemple :

Dim A(1 To 5, 1 To 2)

On peut également commencer avec n'importe quel indice, par exemple :

Dim A(2 To 5, 3 To 6)

Dimensions d'un tableau

Un tableau dont les dimensions sont définies au niveau de sa déclaration est dit de taille fixe. Il existe également des tableaux de taille variable, on les appelle tableaux dynamiques.

Pour déclarer un tableau dynamique par l'instruction Dim il faut utiliser des parenthèses vides, par exemple :

Dim Essai() As Integer

La dimension d'un tableau dynamique doit être définie par l'instruction ReDim. Par exemple :

Dim Essai() As Integer
ReDim Essai(5)
Essai(5) = 10

La première ligne précise que la variable Essai est constituée de nombres entiers, la deuxième donne à la variable la dimension 5, la troisième affecte à la sixième position du tableau Essai, c'est-à-dire Essai(5), la valeur 10.

La taille du tableau peut être redéfinie au cours du programme par l'instruction ReDim, cependant il est important de noter que, dans ce cas, le contenu du tableau est effacé. Si l'on veut conserver le contenu du tableau il faut utiliser l'option Preserve

Lorsque l'on utilise l'option Preserve, on ne peut redimensionner que la dernière dimension du tableau. Par exemple :

Dim Essai() As Integer
ReDim Essai(5,7)
ReDim Preserve Essai(5,9)

Dans ce cas, la dernière ligne porte la dernière dimension du tableau de 7 à 9, l'instruction :

ReDim Preserve Essai(8,7)

aurait fait apparaître un message d'erreur car elle essaye de modifier le première dimension du tableau et non la dernière.

Un tableau peut également être défini comme étant du type Variant, ses dimensions seront alors définies par un tableau ou une matrice qu'on lui affecte.

Par exemple :

Dim B as Variant
B = Array(2, 6, 9, 23, 32)

Si on lui affecte ensuite un tableau de taille différente, sa dimension s'ajustera automatiquement. Par exemple :

Dim A(5,6,8) as Integer
Dim B as Variant
B = Array(2, 6, 9, 23, 32)
B = A

Quand on ne connaît pas la dimension d'un tableau, par exemple parce qu'on l'a défini comme Variant, on peut utiliser les fonctions LBound et UBound. La fonction LBound permet de déterminer les indices les plus bas et la fonction UBound les indices les plus hauts.

Pour utiliser les fonctions LBound et UBound, il faut leur indiquer le nom du tableau et la dimension dont on veut connaître l'indice inférieur ou supérieur. Par exemple :

Dim TabA(5, 2)
UBound(TabA, 1) désigne l'indice supérieur de la première dimension de TabA, il est égal à 5.
UBound(TabA, 2) désigne l'indice supérieur de la seconde dimension de TabA, il est égal à 2.
LBound(TabA, 1) désigne l'indice inférieur de la première dimension de TabA, il est égal à 0.
LBound(TabA, 2) désigne l'indice inférieur de la seconde dimension de TabA, il est égal à 0.

Lorsqu'un tableau n'a qu'une dimension, il suffit de préciser son nom. Par exemple :

UBound(B)=4

Les indices du tableau B vont, en effet, de 0 à 4.

Les tableaux imbriqués

Les cellules d'un tableau peuvent être elles-mêmes des tableaux. Par exemple :

Sub MacroTableau()
Dim Tableau(1 To 3)
a = Array("Madame", "Monsieur")
b = Array(53, 23, 76, 18)
c = Array(1.567, 2.42, 3.57, 4.31, 5.1)
Tableau(1) = a
Tableau(2) = b
Tableau(3) = c
set f=ThisWorkbook.Sheets(1)
For col = LBound(a) To UBound(a)
     f.Cells(1, col + 1) = Tableau(1)(col)
Next col
For col = LBound(b) To UBound(b)
     f.Cells(2, col + 1) = Tableau(2)(col)
Next col
For col = LBound(c) To UBound(c)
     f.Cells(3, col + 1) = Tableau(3)(col)
Next col
End Sub

On obtient :

Dans ce programme, nous avons affecté une matrice à chaque cellule du tableau. Pour le lire, nous devons utiliser, non pas Tableau(i,j) car Tableau n'a qu'une dimension, mais Tableau(i)(j) où i désigne une ligne de Tableau et j la position d'un élément de la matrice insérée dans la ligne i. Les matrices commençant par l'indice 0, Tableau(2)(1) est égal à 23.

L'utilisation d'un tableau imbriqué peut être préférable à un tableau à deux dimensions lorsque les matrices n'ont pas la même dimension.

Le tableau principal est impérativementun tableau unidimensionnel mais il est possible de lui attribuer des matrices pluridimensionnelles. Par exemple dans le programme suivant :

Sub MacroTableau()
Dim TabA(1 To 2)
Dim Tableau(1 To 3)
a = Array("Madame", "Monsieur")
b = Array(53, 23, 76, 18)
c = Array(1.567, 2.42, 3.57, 4.31, 5.1)
d = Array(10, 20, 30, 40)
Tableau(1) = a
Tableau(2) = b
Tableau(3) = c
TabA(1) = Tableau
TabA(2) = d
Set f = ThisWorkbook.Sheets("Essai")
f.Cells(1, 1) = TabA(1)(1)(0)
f.Cells(1, 2) = TabA(1)(1)(1)
f.Cells(1, 3) = TabA(2)(0)
f.Cells(1, 4) = TabA(2)(1)
End Sub

Le programme renvoie :

Application au modèle keynésien simplifié

Dans le modèle keynésien simplifié nous allons introduire plusieurs périodes et changer la fonction de consommation. Nous allons introduire une inertie dans la consommation et supposer qu'à chaque période la consommation finale est une moyenne pondérée entre la consommation finale calculée par l'application d'un taux au revenu de la période et la consommation finale de la période précédente.

Prenons une moyenne simple si bien qu'à chaque période t la consommation finale sera déterminée ainsi :

CF(t) = 0,5 * tauxCF(t) * Revenu(t) + 0,5 * CF(t-1)

Les variables exogènes sont présentées dans le tableau suivant :

Le programme est le suivant :

Sub ModeleTemp()
Dim tauxCI(5), tauxCF(5), Investissement(5) as Double
Dim Production(5), CI(5), VA(5), Revenu(5), CF(5), Ecart(5) As Double
Set f = ThisWorkbook.Sheets("Modele")
'-------------------------------------------------------------------------------
' Saisie des variables exogènes
CF(0) = f.Cells(5, 2)
For t = 1 To 5
    tauxCI(t) = f.Cells(2, t + 2)
    tauxCF(t) = f.Cells(3, t + 2)
    Investissement(t) = f.Cells(4, t + 2)
Next t
'-------------------------------------------------------------------------------
' Itérations
For t = 1 To 5
    Ecart(t) = 1
    Do While Ecart(t) > 0.001
       Prod = Production(t)
       CI(t) = tauxCI(t) * Production(t)
       VA(t) = Production(t) - CI(t)
       Revenu(t) = VA(t)
       CF(t) = 0.5 * tauxCF(t) * Revenu(t) + 0.5 * CF(t - 1)
       Production(t) = CI(t) + CF(t) + Investissement(t)
       Ecart(t) = Production(t) - Prod
   Loop
Next t
'-------------------------------------------------------------------------------
' Affichage des résultats
For t = 1 To 5
    f.Cells(6, t + 2) = Production(t)
    f.Cells(7, t + 2) = CI(t)
    f.Cells(8, t + 2) = VA(t)
    f.Cells(9, t + 2) = Revenu(t)
    f.Cells(5, t + 2) = CF(t)
    f.Cells(10, t + 2) = Ecart(t)
Next t

End Sub

Les résultats apparaissent dans le tableau suivant :

On peut également modifier les exogènes, on obtient par exemple le tableau suivant :

Sous-programmes et fonctions

Sous-programmes

Une procédure peut en appeler une autre. Par exemple, considérons les deux procédures suivantes :

Sub Tripler()
Dim x As Double
Set f = ThisWorkbook.Sheets("essai")
x = f.Range("A1")
f.Range("B1") = 3 * x
Quadrupler
End Sub


Sub Quadrupler()
Dim x As Double
Set f = ThisWorkbook.Sheets("essai")
x = f.Range("A1")
f.Range("C1") = 4 * x
End Sub

Si on entre 10 dans la cellule A1 et si on lance la procédure Tripler on fait apparaître 30 dans la cellule B1 et 40 dans la cellule C1.

On a lancé la procédure Quadrupler depuis la procédure Tripler. Dans notre exemple, la procédure Tripler apparaît donc comme le programme principal et la procédure Quadrupler comme un sous-programme.

On peut simplifier en ne saisissant la valeur contenue dans la cellule A1 que dans la procédure Tripler en procédant ainsi :

Sub Tripler()
Dim x As Double
Set f = ThisWorkbook.Sheets("essai")
x = f.Range("A1")
f.Range("B1") = 3 * x
Quadrupler x
f.Range("C1") = x
End Sub


Sub Quadrupler(y)
Set f = ThisWorkbook.Sheets("essai")
y = 4 * y
End Sub

En lançant la procédure Tripler on obtient le même résultat.

Cette fois, dans la procédure Tripler nous avons passé la variable x en paramètre à la procédure Quadrupler. Pour cela, nous avons introduit un paramètre entre les parenthèses de la procédure Quadrupler et, dans la procédure Tripler nous avons fait suivre Quadrupler par la valeur que nous voulions lui transférer.

Notons qu'il n'est pas nécessaire de reprendre le même nom de variable dans les deux procédures, ce qui permet d'utiliser le même sous-programme avec des variables différentes.

Notons également que dans le sous-programme nous avons supprimé l'instruction Dim car la dimension de la variable transférée est déjà définie dans le programme principal.

Notons enfin que nous avons affiché la valeur quadruplée à partir du programme principal et non du sous-programme car ce dernier a retourné la valeur x quadruplée.

Ainsi, un sous-programme effectue un certain nombre d'actions et modifie la valeur du paramètre qu'on lui passe.

On peut passer à un sous-programme plusieurs paramètres, il suffit pour cela de les séparer par des virgules.

Les sous-programmes sont très utiles pour simplifier la lecture d'un long programme en le décomposant, ils peuvent également être utilisés par plusieurs programmes principaux différents.

À titre d'exemple, le programme ModeleTemp précédent pourrait être décomposé ainsi :

Sub ModeleTemp()
Dim tauxCI(5), tauxCF(5), Investissement(5) As Double
Dim Production(5), CI(5), VA(5), Revenu(5), CF(5), Ecart(5) As Double
Set f = ThisWorkbook.Sheets("Modele")
CF(0) = f.Cells(5, 2)
SaisieExos tauxCI, tauxCF, Investissement
Iterations tauxCI, tauxCF, Investissement, Production, CI, VA, Revenu, CF, Ecart
Affichage Production, CI, VA, Revenu, CF, Ecart
End Sub


Sub SaisieExos(tauxCI, tauxCF, Investissement)
Set f = ThisWorkbook.Sheets("Modele")
For t = 1 To 5
    tauxCI(t) = f.Cells(2, t + 2)
    tauxCF(t) = f.Cells(3, t + 2)
    Investissement(t) = f.Cells(4, t + 2)
Next t
End Sub


Sub Iterations(tauxCI, tauxCF, Investissement, Production, CI, VA, Revenu, CF, Ecart)
For t = 1 To 5
    Ecart(t) = 1
    Do While Ecart(t) > 0.001
       Prod = Production(t)
       CI(t) = tauxCI(t) * Production(t)
       VA(t) = Production(t) - CI(t)
       Revenu(t) = VA(t)
       CF(t) = 0.5 * tauxCF(t) * Revenu(t) + 0.5 * CF(t - 1)
       Production(t) = CI(t) + CF(t) + Investissement(t)
       Ecart(t) = Production(t) - Prod
    Loop
Next t
End Sub


Sub Affichage(Production, CI, VA, Revenu, CF, Ecart)
Set f = ThisWorkbook.Sheets("Modele")
For t = 1 To 5
    f.Cells(6, t + 2) = Production(t)
    f.Cells(7, t + 2) = CI(t)
    f.Cells(8, t + 2) = VA(t)
    f.Cells(9, t + 2) = Revenu(t)
    f.Cells(5, t + 2) = CF(t)
    f.Cells(10, t + 2) = Ecart(t)
Next t
End Sub

Fonctions

Les fonctions se présentent comme des procédures sauf qu'elles renvoient des valeurs et qu'elles peuvent être utilisées dans un programme au même titre que les fonctions mathématiques ou les fonctions de chaîne. Par exemple :

Sub Multi()
Set f = ThisWorkbook.Sheets("essai")
a = Multiplier(10, 5)
f.Range("A1") = a
End Sub


Function Multiplier(x, y)
Multiplier = x * y
End Function

Ce programme renvoie 50 en A1.

Calcul des totaux d'un tableau

Il est souvent nécessaire de calculer dans des programmes les totaux des lignes et des colonnes d'un tableau ainsi que son total général. L'exemple ci-dessous montre comment calculer les totaux du tableau suivant :

Les programmes sont les suivants :

Sub Matrices()
Dim A(1 To 3, 1 To 4) As Double
Dim LigneTot(1 To 4) As Double
Dim ColTot(1 To 3) As Double
Set f = ThisWorkbook.Sheets("Matrices")
For i = 1 To 3
    For j = 1 To 4
       A(i, j) = f.Cells(i + 1, j + 1)
    Next j
Next i
LigneSomme A, LigneTot
For j = 1 To 4
    f.Cells(5, j + 1) = LigneTot(j)
Next j
ColSomme A, ColTot
For i = 1 To 3
    f.Cells(i + 1, 6) = ColTot(i)
Next i
f.Cells(5, 6) = TotMat(A)
End Sub


Sub LigneSomme(Mat, LSomme)
debl = LBound(Mat, 1)
finl = UBound(Mat, 1)
debc = LBound(Mat, 2)
finc = UBound(Mat, 2)
For j = debc To finc
    LSomme(j) = 0
    For i = debl To finl
       LSomme(j) = LSomme(j) + Mat(i, j)
    Next i
Next j
End Sub


Sub ColSomme(Mat, CSomme)
debl = LBound(Mat, 1)
finl = UBound(Mat, 1)
debc = LBound(Mat, 2)
finc = UBound(Mat, 2)
For i = debl To finl
    CSomme(i) = 0
    For j = debc To finc
       CSomme(i) = CSomme(i) + Mat(i, j)
    Next j
Next i
End Sub


Function TotMat(Mat)
debl = LBound(Mat, 1)
finl = UBound(Mat, 1)
debc = LBound(Mat, 2)
finc = UBound(Mat, 2)
TotMat=0
For i = debl To finl
    For j = debc To finc
       TotMat = TotMat + Mat(i, j)
    Next j
Next i
End Function

On obtient :

Auteur : Francis Malherbe