Introduction

Fonctions WLangage et Fonctions TRUE
TEMPORAL REASONING UNIVERSAL ELABORATION
TRUE-WORLD
http://www.true-world.com

Fontions du WLangage et fonctions TRUE - Version 20140301

Le logiciel TRUE utilise la syntaxe WLangage du logiciel Windev 12 (copyright Pcsoft),
dans les procédures des actions, pour calculer dynamiquement les valeurs de retour

Ce fichier d'aide contient les principales fonctions du WLangage.

L'aide en ligne des fonctions Windev est disponible ici:

En Français
http://doc.pcsoft.fr/fr-FR/search.awp?origin=browse&cat=fonctions-wlangage,489

Version gratuite de Windev Express:
http://www.pcsoft.fr/windev/WD-Express.htm

En anglais
http://doc.windev.com/en-US/search.awp?origin=browse&cat=fonctions-wlangage,489

Version gratuite de Windev Express
http://www.windev.com/windev/WD-Express.htm


Fvalue

Fvalue (fonction TRUE)

Utilisation

//Retourne la valeur de transfert d'un flux, qui représente la somme des valeurs transférées par les actions de ce flux.

-Exemple 1
//y est la valeur de retour de la procédure
y = Fvalue("ab")
//y = valeur de transfert du flux ab pour le cycle c courant et le temps t courant

-Exemple 2
//y est la valeur de retour de la procédure
//c est le cycle en cours
//t est l'unité de temps en cours
c_, t_ sont des entiers
c_= 4; t_= 10
SI c_ <= c ET t_ <= t ALORS y = Fvalue("ab",c_,t_)
//y = valeur de transfert du flux ab pour le cycle c_=4 et le temps t_= 10

-Exemple 3
//y est la valeur de retour de la procédure
//nbt est le nombre de temps courant, comptabilisé pour tous les cycles
nbt_ est un entier
nbt_= nbt-10
SI nbt_ > 0 ALORS y = Fvalue("ab",Faux,nbt_)
//y = valeur de transfert du flux ab pour le nombre de temps nbt - 10

Première Syntaxe

Fvalue(<Nom du flux>,[<Cycle>,<Temps>] )

-Détail des paramètres
<Nom du flux> // Chaîne contenant le nom du flux dont on veut obtenir la valeur de transfert.
<Cycle> // Entier optionnel, qui indique pour quel cycle, on veut obtenir la valeur de transfert du flux.
<Temps> // Entier optionnel, qui indique pour quelle unité de temps, on veut obtenir la valeur du flux.
//Si les paramètres <Cycle> et <Temps>, ne correspondent pas à une unité valide, la fonction retournera 0.

Deuxième Syntaxe

Fvalue(<Nom du flux>,[<Faux>,<Nombre de temps>] )

-Détail des paramètres
<Nom du flux> // Chaîne contenant le nom du flux dont on veut obtenir la valeur de transfert.
<Faux> // booléen optionnel, qui indique que le cycle n'est pas pris en compte, et que la valeur du paramètre <Nombre de temps>, doit correspondre au temps relatif, non pas au cycle en cours, mais à tous les cycles, qui correspond à la valeur de la variable nbt.
<Nombre de temps> // Entier optionnel, qui indique pour quelle unité de temps, relative à tous les cycles compilés, on veut obtenir la valeur de transfert du flux.
//Si le paramètre <Nombre de temps> ne correspond pas à une unité de temps valide, la fonction retournera 0.


ZEntiers

Entiers

Type d'entiers

//Le W-Langage propose différents types d'entiers :

//Types, valeur comprise entre
entier // -2 x 109 et 2 x 109 (environ)
entier sur 1 octet // -128 et 127 (incluses)
entier sur 2 octets // -32.768 et 32.767 (incluses)
entier sur 4 octets // -2 x 109 et 2 x 109 (environ)
entier sur 8 octets // -9 x 1018 et 9 x 1018 (environ)
entier sans signe // 0 et 4 x 109
entier sans signe sur 1 octet // 0 et 255 (incluses)
entier sans signe sur 2 octets // 0 et 65.535 (incluses)
entier sans signe sur 4 octets // 0 et 4 x 109 (environ)
entier sans signe sur 8 octets // 0 et 18 x 1018

-Remarque :
//Tous les types avancés (différents du type "Entier") sont conseillés pour l'utilisation des API Windows.

Notes

-Valeur par défaut
//Une variable de type "Entier" déclarée et non initialisée est égale à 0.


ZMonétaires

Monétaires

Le type monétaire

//Un monétaire est un réel codé sur 10 octets.
//Un monétaire peut avoir jusqu'à 24 chiffres significatifs
//(17 maximum pour la partie entière, 6 maximum pour la partie décimale)
//et peut prendre une valeur entre -604 462 909 807 314 587,353 087 et +604 462 909 807 314 587,353 087.

//Le type monétaire est conseillé pour éviter les erreurs d'arrondi dues par le codage binaire des réels.

//Pour les autres calculs, il est préférable d'utiliser des réels, plus rapides.

Notes

-Valeur par défaut
//Une variable de type "Monétaire" déclarée et non initialisée est égale à 0.

-Codage binaire des réels
//Les réels ont tous le même nombre de chiffres significatifs (15).
//Si le résultat d'un calcul sur des réels met en jeu plus de 15 chiffres significatifs,
//ce résultat sera automatiquement arrondi à 15 chiffres significatifs.
//La précision du résultat sera donc plus faible que pour un calcul réalisé avec des monétaires.

-Calculs sur les monétaires
//Tous les calculs utilisant au moins un monétaire seront effectués sous forme monétaire.
//Pour garantir la précision du résultat, toutes les opérandes seront automatiquement converties en monétaire.


ZRéels

Réels

Type de réels

//Le W-Langage propose deux types de réels :

réel //Réel sur 8 octets
//Un réel peut avoir jusqu'à 15 chiffres significatifs.
//La précision des décimales n'est pas assurée.
//Pour effectuer des calculs précis, utilisez le type "Monétaire".

-Valeur d'un réel :
//Valeur minimale : 1.7*10-308
//Valeur maximale : 1.7*10+308

réel sur 4 octets //Réel sur 4 octets
//Un réel sur 4 octets peut avoir jusqu'à 6 chiffres significatifs.
//La précision des décimales n'est pas assurée.
//Pour effectuer des calculs précis, utilisez le type "Monétaire".

-Valeur d'un réel sur 4 octets :
//Valeur minimale : 3.4*10-38
//Valeur maximale : 3.4*10+38

Notes

-Valeur par défaut
//Une variable de type "Réel" déclarée et non initialisée est égale à 0.

-Codage binaire des réels
//Les réels ont tous le même nombre de chiffres significatifs (15).
//Si le résultat d'un calcul sur des réels met en jeu plus de 15 chiffres significatifs,
//ce résultat sera automatiquement arrondi à 15 chiffres significatifs.
//Pour obtenir une précision plus importante, utilisez le type monétaire.


ZLimites

Limites des variables

Limites des variables utilisées dans les procédures des actions

entier sur 1 octet
-128 à 127

entier sans signe sur 1 octet
0 à 255

entier sur 2 octets
-32768 à 32767

entier sans signe sur 2 octets
0 à 65535

entier sur 4 octets
-2147483648 à 2147483647

entier sans signe sur 4 octets
0 à 4294967295

entier sur 8 octets
-9223372036854775808 à 9223372036854775807

entier sans signe sur 8 octets
0 à 18446744073709551615

monétaire
-604462909807314587.353088 à 604462909807314587.353087

chaîne fixe // Taille maximale
32767

chaîne ASCIIZ // Taille maximale
65535

chaîne Pascal // Taille maximale
255


ZAsc

Exemple d'utilisation de la fonction Asc

-Exemple : Diverses conversions

//L'exemple suivant permet de connaître le code ASCII de divers caractères.

CodeASCII = Asc("A") // Retourne 65
CodeASCII = Asc("Barbier") // Retourne 66
CodeASCII = Asc("") // Retourne 0
CodeASCII = Asc("0") // Retourne 48
CodeASCII = Asc("w") // Retourne 119
CodeASCII = Asc("0123") // Retourne 48
CodeASCII = Asc("WinDev") // Retourne 87

Ch = "0123"
CodeASCII = Asc(Ch[[2]]) // Retourne 49 (code ASCII de "1")


Retro-calcul

Nouvelle page
Saisissez ici le texte de la page


Liste des instructions composées

Instructions composées

Les différentes instructions composées sont les suivantes :

Instructions conditionnelles

SELON //Exécution d'une action ou d'une autre en fonction d'une expression

SI //Exécution d'une action ou d'une autre en fonction d'une condition

Instructions répétitives

BOUCLE //Bloc d'instructions répété à l'infini

POUR //Bloc d'instructions répété jusqu'à une valeur limite

TANTQUE //Bloc d'instructions répété en fonction d'une condition

Instruction de branchement

GOTO //Branchement à une étiquette donnée


BOUCLE

Instruction BOUCLE

Utilisation

//Le bloc d'instructions est répété à l'infini. Le nombre d'itérations du bloc d'instructions n'est pas contrôlé, il n'y a pas d'expression à évaluer.

BOUCLE
// lecture d'une ligne du fichier texte
y = x + 10
SI y > 10 ALORS SORTIR
FIN

Syntaxe

BOUCLE
...
SI <Condition> ALORS SORTIR
...
FIN

Détail de la syntaxe

BOUCLE //Signale le début du bloc d'instructions.
SORTIR //Permet de quitter le bloc d'instructions.
FIN //Signale la fin du bloc d'instructions.

Notes

-Code à exécuter
//Le code à exécuter est placé entre les instructions BOUCLE et FIN.

-Sortir d'une boucle
//Plusieurs instructions sont possibles :
RETOUR //Sortie de la boucle et sortie du traitement (ou de la procédure) en cours.
SORTIR //Sortie de la boucle et exécution de la suite du traitement en cours.

-Exécution de l'itération suivante
//Pour exécuter directement l'itération suivante sans terminer le code de l'itération en cours, utilisez //l'instruction CONTINUER :
BOUCLE
.. .
SI <Condition> ALORS CONTINUER // Retour au mot-clé BOUCLE
.. .
FIN


GOTO

Instruction GOTO

Utilisation

//L'instruction GOTO permet d'exécuter un code identifié par une étiquette donnée.
//Important : L'étiquette doit obligatoirement être définie dans le même traitement que l'instruction GOTO.

y = x + 100
SI y = -1 ALORS GOTO négatif
y = y/2

RETOUR

négatif :
y = y/3 ; RETOUR

Syntaxe

...
GOTO <Nom de l'étiquette>
...

<Nom de l'étiquette> :
<Code de l'étiquette>

Détail de la syntaxe

GOTO //Lance l'exécution du code identifié par l'étiquette.
<Nom de l'étiquette> //Nom de l'étiquette dont le code doit être exécuté. Ce nom doit être suivi de ":". Cette étiquette doit se trouver dans le même traitement que l'instruction GOTO.
<Code de l'étiquette> //Code à exécuter lors de l'appel de l'étiquette par GOTO.

Notes

-Code de l'étiquette
//Après exécution du code de l'étiquette, le programme exécute les lignes de code suivant directement l'étiquette.

-Limites
//Limites des étiquettes
//Dans un même traitement (ou procédure), il ne peut pas exister plusieurs étiquettes de même nom.
//Si une étiquette n'est utilisée par aucune instruction GOTO, un warning apparaît lors de la compilation du projet.

-Étiquette et instructions POUR
//L'instruction GOTO ne permet pas d'accéder directement dans le bloc d'instructions d'un POUR.
//Ainsi, ce code provoque une erreur à la compilation :

POUR Indice = 1 A 10
EtiqReprise : Res ++
FIN

GOTO EtiqReprise


POUR

Instruction POUR

Utilisation

//Le bloc d'instructions est répété en modifiant une variable de contrôle puis en la comparant à une valeur limite, avant chaque début du bloc d'instructions.
//Le bloc d'instructions est alors exécuté pour chacune des valeurs que prend successivement la variable de contrôle. la variable de contrôle reçoit la valeur initiale lors de la première entrée dans l'instruction POUR.

POUR Indice = 1 A 10
tableau_[Indice] = MaVariable + 10
FIN

POUR Indice = 10 A 1 PAS -1
tableau_[Indice] = MaVariable + 10
FIN

POUR Indice = 1 A 5
Trace(Indice)
FIN
Trace(Indice) // Indice vaut 6

Syntaxe

POUR <Variable de contrôle> = <Valeur initiale> A <Valeur finale> [PAS <x>]
//...
FIN

Détail de la syntaxe

POUR //Signale le début du bloc d'instructions.
<Variable de contrôle> //Variable simple de type scalaire (entier ou réel).
<Valeur initiale> //Valeur initiale de la variable de contrôle (entier ou réel).
<Valeur finale> //Valeur finale de la variable de contrôle (entier ou réel).
PAS //Pas d'incrémentation (optionnel) de la variable de contrôle (par défaut, 1).
<x> //Valeur (optionnel) du pas d'incrémentation (type identique au type de la variable de contrôle).
FIN //Signale la fin du bloc d'instructions.

Notes

-Code à exécuter
//Le code à exécuter est placé entre les instructions POUR et FIN.

-Pas d'incrémentation
//Le pas d'incrémentation de l'instruction POUR doit être constant. Si le pas d'incrémentation est susceptible de varier à chaque répétition, un warning apparaît lors de la compilation.

-Sortir d'une boucle de type POUR
//Plusieurs instructions sont possibles :
RETOUR // Sortie de la boucle POUR et sortie du traitement (ou de la procédure) en cours.
SORTIR // Sortie de la boucle POUR et exécution de la suite du traitement en cours.

-Exécution de l'itération suivante
//Pour exécuter directement l'itération suivante sans terminer le code de l'itération en cours, utilisez l'instruction CONTINUER :
POUR <Variable de contrôle> = <Valeur initiale> A <Valeur finale> [PAS <x>]
.. .
SI <Condition> ALORS CONTINUER // Retour aUR
.. .
FIN
//Dans ce cas, la variable de contrôle est automatiquement incrémentée.


SELON

Instruction SELON

Utilisation

//L'instruction conditionnelle SELON permet de choisir d'exécuter une action ou une autre en fonction de la valeur d'une expression.

SELON Quantité
CAS 1 : Comment = "3 produits pour le prix d'un"
CAS 2 : Comment = "5 produits pour le prix d'un"
AUTRE CAS : Comment = ""
FIN

SELON Vrai
CAS Valeur = 10 : Trace(10)
CAS 10<Valeur<20 : Trace("Compris")
CAS Valeur>30 : Trace("Sup 30")
FIN

Syntaxe

SELON <Variable de comparaison>
CAS <Expression 1> : <Action 1>
CAS <Expression 2> :
<Action 2.1>
<Action 2.2>
CAS <Expression 3>
<Action 3.1>
<Action 3.2>
<Action 3.3>
CAS <Expression 4>, <Expression 5> : <Action 4>
CAS <Expression 6>, <Expression 7> :
<Action 5>
CAS <Expression 8>, <Expression 9>
<Action 6.1>
<Action 6.2>
//...
[
AUTRE[S] CAS : <Action autres(s) cas>
//ou
AUTRE[S] CAS :
<Action autres(s) cas>
//ou
AUTRE[S] CAS
<Action autres(s) cas>
]
FIN

Détail de la syntaxe

SELON //Signale le début du bloc d'instructions.
<Variable de comparaison> //Variable de comparaison (tout type).
CAS //Différents cas de comparaison.
<Expression N> //Valeur à comparer à la variable de comparaison (type identique à celui de la variable de comparaison).
<Action N> //Action à lancer si l'expression correspondante est égale à la variable de comparaison. Après exécution de cette action, le traitement continue après le mot FIN.
AUTRE[S] CAS
<Action autres(s) cas> //Action à lancer si la variable de comparaison n'est égale à aucune expression (optionnelle).
FIN //Signale la fin du bloc d'instructions.

Notes

-Opérateurs de comparaison
//Si l'instruction conditionnelle SELON contient des opérateurs de comparaison, la <variable de comparaison> doit correspondre au mot-clé Vrai.
//Par exemple :

SELON Vrai
CAS Valeur = 10 : Trace(10)
CAS 10<Valeur<20 : Trace("Compris") CAS Valeur>30 : Trace("Sup 30")
FIN

-Mot-clé AUTRE CAS
AUTRE CAS //doit être la dernière instruction utilisée dans l'instruction conditionnelle SELON.


SI

Instruction SI

Utilisation

//L'instruction conditionnelle SI permet de choisir d'exécuter une action ou une autre en fonction d'une condition.

SI Age > 60 ALORS
PersonneAgée += 1
SINON SI Age > 18 ALORS
PersonneAdulte += 1
SINON SI Age > 4 ALORS
PersonneEnfant += 1
SINON PersonneBébé += 1
FIN

Syntaxe 1 A 4

SI <Condition> ALORS
<Action si condition vraie>
[SINON
<Action si condition fausse> ]
FIN

SI <Condition> ALORS
<Action si condition vraie>
[SINON <Action si condition fausse> ]

SI <Condition> ALORS <Action si condition vraie>
[SINON
<Action si condition fausse> ]
FIN

SI <Condition> ALORS <Action si condition vraie> [SINON <Action si condition fausse>]

-Détail des Syntaxes 1 à 4
SI //Signale le début du bloc d'instructions.
<Condition> //Condition à tester.
ALORS //Lance les actions si la condition est vraie.
<Action si condition vraie> //Action à lancer si la condition est vraie.
SINON //Lance les actions si la condition est fausse (optionnel).
<Action si condition fausse> //Action à lancer si la condition est fausse (optionnelle).
FIN //Signale la fin du bloc d'instructions.

Syntaxe 5

SI <Condition 1> ALORS
<Action si condition 1 vraie>
[SINON SI <Condition 2> ALORS
<Action SI condition 2 vraie>
[SINON SI <Condition 3> ALORS
<Action SI condition 3 vraie>
[...]]]
FIN

-Détail de la syntaxe 5

SI //Signale le début du bloc d'instructions.
<Condition 1> //1ière condition à tester.
ALORS //Lance les actions si la condition précédente est vraie.
<Action si condition 1 vraie> //Action à lancer si la 1ière condition est vraie.
SINON SI //Teste la condition suivante (optionnel) si la condition précédente est fausse.
<Condition 2> //2ième condition à tester (optionnel).
<Action si condition 2 vraie> //Action à lancer si la 2ième condition est vraie et si la 1ière condition est fausse (optionnel).
<Condition 3> //3ième condition à tester.
<Action si condition 3 vraie> //Action à lancer si la 3ième condition est vraie et si la 1ière et la 2ième condition sont fausses.
FIN //Signale la fin du bloc d'instructions.
Notes

-Condition composée
//Les mots-clés ET et OU permettent d'effectuer des opérations logiques et de construire des conditions composées.

//Par exemple :
SI Ville = "Montpellier" ET Civilité = "Monsieur" ALORS
HommeMontpellier ++ // Nombre d'hommes habitant à Montpellier
FIN

SI Ville = "Montpellier" OU Ville = "Marseille" ALORS
MontpellierMarseille ++ // Nombre de clients habitant soit à Montpellier, soit à Marseille
FIN

//Les conditions composées de ET et OU sont évaluées dans leur totalité.

//Par exemple :
A > 10 ET B < 20
//SI la première condition (A > 10) est fausse, la deuxième condition (B < 20) sera tout de même vérifiée.

-SINON sans SI
//Le mot-clé SINON ne peut pas être utilisé sans l'instruction conditionnelle SI correspondante.


TANTQUE

Instruction TANT QUE

Utilisation

//Dans une instruction TANTQUE, l'expression est évaluée à chaque début du bloc d'instructions.

//Tant que l'expression de condition est vraie, le traitement boucle. Il y a sortie du bloc d'instructions lorsque l'expression de condition est fausse.

Nombre = 1234
TANTQUE Nombre > 0
nb = nb + 1
Nombre = Nombre / 10
FIN

Syntaxe

TANTQUE <Condition>
<Action si condition vraie>
FIN

Détail de la syntaxe

TANTQUE //Signale le début du bloc d'instructions.
<Condition> //Condition à tester.
<Action si condition vraie> //Action à lancer si la condition est vraie.
FIN //Signale la fin du bloc d'instructions.

Notes

-Code à exécuter
//Le code à exécuter est placé entre les instructions TANTQUE et FIN.

-Sortir d'une boucle de type TANTQUE
//Plusieurs instructions sont possibles :
RETOUR // Sortie de la boucle TANTQUE et sortie du traitement (ou de la procédure) en cours.
SORTIR // Sortie de la boucle TANTQUE et exécution de la suite du traitement en cours.

-Exécution de l'itération suivante
//Pour exécuter directement l'itération suivante sans terminer le code de l'itération en cours, utilisez l'instruction CONTINUER :
TANTQUE <Condition>
.. .
SI <Condition> ALORS CONTINUER // Retour au mot-clé TANTQUE
.. .
FIN

-Condition composée
//Les mots-clés ET et OU permettent d'effectuer des opérations logiques et de construire des conditions composées.
//Par exemple :
TANTQUE Prix < 100 ET TypeProduit = "AA"
NbreProduit ++ // Nombre de produits dont le prix est inférieur à 100 F et dont le type est "AA"
FIN

TANTQUE Prix < 100 OU Prix > 500
NbreProduit ++ // Nombre de produits dont le prix est compris entre 100 et 500 F
FIN

//Les conditions composées de ET et OU sont évaluées dans leur totalité.
//Par exemple :
A > 10 ET B < 20 //SI la première condition (A > 10) est fausse, la deuxième condition (B < 20) sera tout de même vérifiée.


Liste des instructions simples

Instructions simples

Les différentes instructions simples sont les suivantes :

CONTINUER //Retour directement au début de la prochaine itération sans terminer le code de l'itération en cours

RETOUR //Sortie d'un bloc d'instructions et sortie du traitement (ou de la procédure) en cours

SORTIR //Sortie d'un bloc d'instructions et exécution de la suite du traitement en cours


CONTINUER

Instruction CONTINUER

Utilisation

//L'instruction CONTINUER permet de retourner directement au début de la prochaine itération sans terminer le code de l'itération en cours.

//L'instruction CONTINUER peut être utilisée dans les boucles de type :
POUR
BOUCLE
TANTQUE

Syntaxe

-Instruction POUR
POUR <Variable de contrôle> = <Valeur initiale> A <Valeur finale> [PAS <x>]
.. .
SI <Condition> ALORS CONTINUER
.. .
FIN
//Si la <Condition> est vérifiée :
//Le code suivant l'instruction CONTINUER n'est pas exécuté.
//La boucle est exécutée directement depuis le début de l'instruction POUR.
//La <Variable de contrôle> est incrémentée.

-Instruction BOUCLE
BOUCLE
.. .
SI <Condition> ALORS CONTINUER
.. .
FIN
//Si la <Condition> est vérifiée :
//Le code suivant l'instruction CONTINUER n'est pas exécuté.
//La boucle est exécutée directement depuis le début de l'instruction BOUCLE.

-Instruction TANTQUE
TANTQUE <Condition 1>
.. .
SI <Condition 2> ALORS CONTINUER
.. .
FIN
//Si la <Condition 2> est vérifiée :
//Le code suivant l'instruction CONTINUER n'est pas exécuté.
//La boucle est exécutée directement depuis le début de l'instruction TANTQUE.

-Exemple à ne pas faire :
//Dans ce code, l'utilisation du mot-clé CONTINUER entraîne la non - exécution de l'instruction y++
y=0
TANTQUE y<10
SI y = 5 ALORS CONTINUER
y++
FIN


RETOUR

Instruction RETOUR

Utilisation

//L'instruction RETOUR permet de sortir d'un bloc d'instructions et de sortir du traitement (ou de la procédure) en cours.

//L'instruction RETOUR peut être utilisée dans :
//une procédure.
//une boucle de type POUR.
//une boucle de type BOUCLE.
//une boucle de type TANTQUE.

Syntaxe

//Procédure
SI <Condition> ALORS RETOUR
.. .
FIN

//Instruction POUR
POUR <Variable de contrôle> = <Valeur initiale> A <Valeur finale> [PAS <x>]
SI <Condition> ALORS RETOUR
FIN

//Instruction BOUCLE
BOUCLE
...
SI <Condition> ALORS RETOUR
...
FIN

//Instruction TANTQUE
TANTQUE <Condition 1>
...
SI <Condition> ALORS RETOUR
...
FIN

//Dans tous les cas, si la <Condition> est vérifiée, les opérations effectuées sont les suivantes :
//Sortie du bloc d'instructions.
//Sortie du traitement (ou de la procédure) en cours.

Notes

//Autres instructions permettant de sortir d'une boucle ou d'une procédure
SORTIR //Sortie de la boucle et exécution de la suite du traitement (ou de la procédure) en cours.


SORTIR

Instruction SORTIR

Utilisation

//L'instruction SORTIR permet de sortir d'un bloc d'instructions et d'exécuter la suite du traitement en cours.

//L'instruction SORTIR peut être utilisée dans les boucles de type :

POUR
BOUCLE
TANTQUE

//Remarque : L'instruction SORTIR ne peut pas être utilisée pour sortir d'une procédure. Utilisez les mots clé RETOUR

Syntaxe

//Instruction POUR
POUR <Variable de contrôle> = <Valeur initiale> A <Valeur finale> [PAS <x>]
...
SI <Condition> ALORS SORTIR
...
FIN
<Suite du traitement>

//Instruction BOUCLE
BOUCLE
...
SI <Condition> ALORS SORTIR
...
FIN
<Suite du traitement>

//Instruction TANTQUE
TANTQUE <Condition>
...
SI <Condition> ALORS SORTIR
...
FIN
<Suite du traitement>

//Dans tous les cas, si la <Condition> est vérifiée, les opérations effectuées sont les suivantes :
//Sortie du bloc d'instructions.
//Exécution de la suite du traitement en cours.

Notes

//Autres instructions permettant de sortir d'une boucle
RETOUR //: Sortie de la boucle et sortie du traitement (ou de la procédure) en cours.


Liste des opérateurs

Les différents opérateurs sont les suivants :

Opérateurs logiques
ET, OU , PAS

Opérateurs arithmétiques
+, -, *, /, ++, --, +=, -=

Opérateurs binaires
ETBinaire, OUBinaire , NONBinaire , OuExclusifBinaire

Opérateurs de comparaison
=, ~=, <>, <=, >=, <, >

Opérateurs sur des chaînes de caractères
+, [[, ]]

Opérateurs de ponctuation
( ) [ ], , . : ; .. ... //


Opérateurs arithmétiques

Utilisation

//Les opérateurs arithmétiques sont :

+ // Addition (valeur numérique OU chaîne).
- // Soustraction (valeur numérique).
* // Multiplication.
/ // Division.
++ // Incrémentation (valeur numérique).
-- // Décrémentation (valeur numérique).
+= // Ajout d'une valeur à la variable ou au champ (numérique ou texte).
-= // Soustraction d'une valeur à la variable ou au champ (numérique).

Règles

-Règles de calcul
//Les différents calculs se font sans perte de précision ou tronquage. Les vérifications de débordement sont effectuées au moment de l'affectation du résultat dans une variable.

Notes

-Affichage du résultat
//Il n'est pas possible d'afficher directement le résultat du calcul utilisant les opérateurs suivants :

++ // Incrémentation.
-- // Décrémentation.
+= // Ajout d'une valeur à la variable ou au champ (numérique ou texte).
-= // Soustraction d'une valeur à la variable ou au champ (numérique).

//Ainsi, cet exemple génère une erreur lors de la compilation :
n est un entier = 10
Trace(n+=1)

//Pourafficher le résultat, effectuez les modifications suivantes :
n est un entier = 10
n += 1
Trace(n)

-Équivalence
j ++ //est équivalent à j = j + 1
j -- //est équivalent à j = j - 1
j += 3 //est équivalent à j = j + 3
j -= 3 //est équivalent à j = j - 3

//Il est conseillé d'utiliser le syntaxes :
j ++, j --, j +=, j -= // plus rapides que les syntaxes habituelles.


Opérateurs binaires

Utilisation

//Les opérations sur des valeurs binaires sont uniquement réalisées avec des fonctions du W-Langage.

//Les fonctions sont :

ETBinaire

OUBinaire

NONBinaire

OuExclusifBinaire


Opérateurs de comparaison

Présentation

//Les opérateurs de comparaison peuvent être divisés en plusieurs catégories :

-Egalité
= //Égalité stricte
~= //Égalité souple
~~ //Égalité très souple
[= //Commence par

-Comparaison
<> //Différent
<= //Inférieur ou égal
>= //Supérieur ou égal
< //Strictement inférieur
> //Strictement supérieur

-Intervalle de comparaison
< < //et inversement, strictement compris entre
< <= , <= < //et inversement, compris entre
<= <= //et inversement, compris entre (bornes comprise)

//Les opérateurs de comparaison peuvent être utilisés avec tous les types d'opérandes.
//Le résultat d'une expression de comparaison est de type booléen.

Détail

-Égalité souple et égalité très souple
~= //L'égalité souple (~=) et
~~ // l'égalité très souple (~~),
//agissent uniquement sur les chaînes de caractères (sauf les chaînes fixes).

// Ces opérateurs permettent de :
//ne pas différencier les caractères majuscules des caractères minuscules,
//ne pas tenir compte des espaces situés avant et après la chaîne à tester,
//ne pas tenir compte des caractères accentués minuscules,
//ne pas tenir compte des espaces et des ponctuations à l'intérieur des chaînes (égalité très souple uniquement)

"Dupond" = "DUPOND" // retourne Faux
"Dupond" ~= "DUPOND" // retourne Vrai
" Dupond" ~= "DUPOND" // retourne Vrai
" Dupond" ~= "Dupond" // retourne Vrai
"C'est l'été" ~= "C'est l'ete" // retourne Vrai
"Ent. S.A.R.L" ~~ "Ent SARL" // retourne Vrai

-Egalité et comparaison : Réel contenant plus de 6 décimales de différence
//Le test d'égalité de deux réels est effectué en ne tenant compte que des 6 premières décimales.
// En effet, les erreurs d'Arrondi dues au codage interne des réels nécessitent un test spécifique.
//Ce test doit être réalisé en comparant la différence des deux valeurs à tester avec une valeur de référence.
//Selon le type de votre application, cette valeur peut être égale à 0,00001 ou moins encore.

//Cette gestion d'Arrondi n'est pas spécifique à WinDev. Elle est générale à tous les langages manipulant des réels sous forme binaire.

Diff, R1, R2 sont des réels
Diff = 0.00001
SI Abs(1-(R1/R2)) < Diff ALORS
// R1 et R2 sont égaux
SINON
// R1 et R2 sts
FIN

-Intervalles de comparaison
//Les intervalles de comparaison permettent de simplifier l'écriture de comparaisons complexes. Ainsi, la ligne
SI x > 5 ET x < 10 ALORS ...
//peut être remplacée par
SI 5 < x < 10 ALORS

MonTableau est un tableau de 5 chaînes
I est un entier
MonTableau[1] = "Dupond"
MonTableau[2] = "Aida"
MonTableau[3] = "Parapoline"
MonTableau[4] = "Moulin"
MonTableau[5] = "Foolamour"

POUR I = 1 A 5
SI "B" < MonTableau[I] <= "M" ALORS Trace(MonTableau[I]) // Affiche Dupond et Foolamour
FIN


Opérateurs de ponctuation

Opérateurs divers

Présentation

//Les opérateurs divers regroupent les opérateurs suivants :
( ) //Les parenthèses
[ ] //Les crochets
, //La virgule
: //Les deux points
; //Le point virgule
... //Le triple point
// //La double barre

Détail

-Les parenthèses
//Les parenthèses permettent
//de regrouper les différents éléments d'une opération tout en indiquant l'ordre de priorité. Par exemple :
SI (A-B) * 5 ALORS ....

//d'indiquer les différents paramètres d'une fonction du W-Langage. Par exemple :
Ovalue("Compte",4,2)

-Les crochets
//Les crochets sont des opérateurs d'indexation. Ils permettent de désigner facilement des objets indexés.

//Exemple :
//Elément d'un tableau défini en W-Langage. Exemple :
MonTableau est un tableau de 5 chaînes
MonTableau [1] = "Dupond"

-La virgule
//la virgule permet de séparer :
//différentes déclarations de variables d'un même type effectuées sur une même ligne. Par exemple :
Nom1, Nom2 sont des chaînes

//les différents paramètres d'une fonction du W-Langage. Par exemple :
Ovalue("Compte",4,2)

-Deux points
//Les deux points permettent d'accéder aux membres des objects ou des structures.
//Exemple
x = p:vfrom // vfrom est membre de la structure p

-Le point virgule
//Le point virgule permet de séparer différentes instructions écrites sur la même ligne. Par exemple :
I, J sont des entiers ; MaChaîne est une chaîne

-Triple point
//L'opérateur "..." (triple point) permet de continuer une ligne logique sur la ligne physique suivante. Par exemple :
SI (CodeFamille="LV") ET ...
(CodeFamille="MO") ALORS
// Traitement
FIN

Libellé = "Veuillez saisir le "+ ...
"nom du client."

//la ponctuation suite "..." doit nécessairement être utilisée en fin de ligne et non pas au milieu d'une ligne.
//Aucun caractère ne doit suivre les "..." (mis à part les commentaires).

-La double barre
//la double barre permet de mettre en commentaire le texte suivant ce signe.
//Ce texte ne sera pas pris en compte lors de la compilation du code et lors de l'exécution du projet. Par exemple :
// Effectue une recherche dans une chaîne
// Déclaration
MaChaîne est une chaîne = "WinDev est formidable"
// Test
SI PositMaChaîne, "W")<>0 ALORS
Aresult("trouvé") // Affiche le résultat
FIN


Opérateurs logiques

Opérateur logiques

Utilisation

//Les opérateurs logiques sont :

ET // Multiplication logique.
OU // Addition logique.
PAS // Négation logique.

//Les opérateurs logiques permettent d'effectuer des opérations logiques et de construire des conditions.

SI Ville = "Montpellier" ET Civilité = "Monsieur" ALORS
HommeMontpellier ++ // Nombre d'hommes habitant à Montpellier
FIN

SI Ville = "Montpellier" OU Ville = "Marseille" ALORS
MontpellierMarseille ++ // Nombre de clients habitant soit à Montpellier, soit à Marseille
FIN

Règles

Vrai ET Vrai // retourne Vrai
Vrai ET Faux // retourne Faux
Vrai OU Vrai // retourne Vrai
Vrai OU Faux // retourne Vrai
PAS Vrai // retourne Faux

Notes

-Variable numérique
//Si une variable numérique est manipulée comme un opérateur logique (booléen), "0" est équivalent à Faux. Toute autre valeur est équivalente à Vrai.

//Par exemple, les deux lignes de codes suivantes sont équivalentes :
SI NumTest ALORS ...
SI NumTest <> 0 ALORS ...
//la première Syntaxe (SI NumTest ALORS) doit être préférée à la seconde Syntaxe.

-Variable chaîne
//SI une variable chaîne est manipulée comme un opérateur logique, une Erreur du W-Langage sera générée.
//Par exemple, la Syntaxe :
SI ChTest ALORS //retournera une Erreur lors de l'exécution (mais pas lors de la compilation du projet).

-Priorité
//Les opérateurs ET et OU ont la même priorité. Pour donner des priorités à ces opérateurs, il suffit de mettre des parenthèses.
//Par exemple :
SI (A = 2 ET B > 3) OU (A = 2 ET B < 0) ALORS ...


Opérateurs sur chaînes de caractères

Opérateurs sur chaines de caractères

Utilisation

//Les chaînes de caractères peuvent être manipulées par des fonctions spécifiques du W-Langage ou par les opérateurs +, [[ et ]].

//Les opérateurs sur des chaînes de caractères sont :
+ // Pour concaténer des chaînes.
[[ , ]] //(double crochets ouvrant et double crochets fermant) : Opérateur d'extraction d'une sous-chaîne.
= // Egalité stricte
~= // Egalité souple
[= // Commence par

Texte est une chaîne = "Guide de Programmation"

Texte[[10]] // Retourne "P"
Texte[[10 à 16]] // Retourne "Program"
Texte[[10 à]] // Retourne "Programmation"
Texte[[à 13]] // Retourne "Guide de Prog"
Texte[[10 sur 4]] // Retourne "Prog"
Texte + " de WinDev" // Retourne "Guide de Programmation de WinDev"
SI Texte [= "Guide" ALORS Trace(Texte)

Notes

-Égalité souple et égalité très souple
//L'égalité souple (~=) et l'égalité très souple (~~) agissent uniquement sur les chaînes de caractères (sauf les chaînes fixes). Ces opérateurs permettent de :
//ne pas différencier les caractères majuscules des caractères minuscules,
//ne pas tenir compte des espaces situés avant et après la chaîne à tester,
//ne pas tenir compte des caractères accentués minuscules,
//ne pas tenir compte des espaces et des ponctuations à l'intérieur des chaînes (égalité très souple uniquement)

-L'opérateur [[ et ]]
//L'opérateur [[ et ]] permet d'extraire et de remplacer une sous chaîne.

//Quelques exemples :
CHAINEAEXTRAIRE[[<Position>]] // Extrait un caractère dans une chaîne en fonction de sa position.
CHAINEAEXTRAIRE[[<Position>]] = <Nouvelle chaîne> // Remplace le caractères de la chaîne par la nouvelle chaîne.
CHAINEAEXTRAIRE[[<Début> à <Fin>]] // Extrait une chaîne de caractères dans une chaîne en fonction de ses positions de début et de fin.
CHAINEAEXTRAIRE[[<Début> à]] // Extrait une chaîne de caractères à partir de <Début> jusqu'à la fin de la chaîne.
CHAINEAEXTRAIRE[[à <Fin>]] // Extrait une chaîne de caractères du début de la chaîne jusqu'à <Fin>.
CHAINEAEXTRAIRE[[<Début> sur <Nombre>]] // Extrait un nombre défini de caractères en fonction de la position de début et du nombre de caractères souhaité.

//Attention : Si vous utilisez une procédure manipulant les chaînes avec les opérateurs [[ ]], méfiez - vous de la syntaxe utilisée. Vous pouvez sans le vouloir modifier vos chactères.
//Par exemple, la procédure suivante peut entraîner la modification d'une partie de la chaîne.

-Position dans une chaîne de caractères
//Le premier caractère est en position 1 (et non en position 0).
//La fonction Position retourne la position de départ d'une chaîne de caractères donnée à l'intérieur d'une autre chaîne de caractères.

-Fonctions du W-Langage
//Les chaînes de caractères peuvent également être manipulées grâce aux fonctions de gestion des chaînes de caractères :
Droite
Gauche
Milieu
de gestion des chaînes de caractères


Types de données simples

Principe

//Une variable se définit par son nom et par son type.

//Le type de la variable détermine les valeurs que la variable peut prendre, son encombrement mémoire et les opérations possibles.
//Rappel : chaque type est identifié par un mot-clé du W-Langage. Ces mots-clés sont des mots réservés.

-Type de variables

//Les types "simples" du W-Langage sont les suivants (ces types peuvent être déclarés directement, voir Déclaration de variables) :

booléen // type conseillé pour toutes les opérations logiques où seules deux alternatives sont possibles :
Vrai //(valeur différente de 0)
Faux //(valeur égale à 0)
//Exemple :
b est un booléen

entier // type conseillé pour des calculs réalisés sur des valeurs entières.
//Pour des calculs avancés, le W-Langage propose différents types d'entiers.
//Exemple :
b est un entier

monétaire // type conseillé pour des calculs réalisés sur des valeurs réelles nécessitant une précision garantie des décimales, comme par exemple des valeurs monétaires.
//un monétaire gère 24 chiffres significatifs (17 maximum pour la partie entière, 6 maximum pour la partie décimale). la précision est assurée sur 6 décimales.
//Plus de détails sur les monétaires.
//Exemple :
Mamonnaie est un monétaire

réel // type conseillé pour des calculs simples réalisés sur des valeurs réelles.
//un réel gère 15 chiffres significatifs, par contre la précision des décimales n'est pas garantie.
//la précision des décimales n'est pas assurée. Pour effectuer des calculs précis, utilisez le type "Monétaire".
//POUR des calculs avancés, le W-Langage propose différents types de réels.
//Exemple :
TVA est un réel

chaîne // type conseillé pour la gestion des caractères et des chaînes de caractères.
//Avec ce type, il n'est pas nécessaire de déclarer la longueur de la chaîne. Celle-ci peut varier de façon libre lors de l'Utilisation de la variable.
//Pour une gestion avancée des chaînes de caractères, le W-Langage propose différents types de chaînes.

date, heure, DateHeure, Durée // types conseillés pour la gestion des dates et des heures.
//Le Type "Date" et le type "Heure" permet de manipuler simplement les dates et les heures, et de gérer de manière quasi automatique toutes les conversions.
//Plus de détails sur les Dates et plus de détails sur les Heures.
//Le Type "DateHeure" permet de gérer en une seule fois une date et une heure.
//Plus de détails sur les DateHeures.
//Le Type "Durée" permet de gérer simplement les différences d'heures ou de dat//Plus de détails sur les durées.

Déclaration de variables

-Déclarer une variable
<Nom de la variable> est un(e) <Type>

-Déclarer plusieurs variables
<Nom de la variable 1>, <Nom de la variable 2> sont des <Type>

Détail des Syntaxes

<Nom de la variable> //Nom de la variable à déclarer.
<Type> //Type de la variable, ou commun aux variables déclarées.
//Remarque : Les mots-clés "un", "une" et "des" ne sont pas obligatoires : ce sont des mots d'agrément.

Notes

-Pluriel des types de données
//Tous les types de données peuvent être mis au pluriel. Par exemple entier ou entiers, réel ou réels, ...

-Valeurs limites des types de données
//Si une variable est affectée avec une valeur dépassant les limites de son type :
//aucun message d'erreur ne signale le dépassement de capacité. la valeur de la variable est fausse.


Déclarer un type simple

Utilisation

//Une variable simple est une variable de type scalaire ( entier, booléen, ...), réel ou chaîne de caractères.

Syntaxe

//Déclarer une ou plusieurs variables

<Nom de la variable> est un(e) <Type de la variable>
//ou
<Nom de la variable 1>, <Nom de la variable 2> sont des <Type de la variable>

-Détail de la syntaxe

<Nom de la variable> //Nom de la variable à déclarer.
<Type de la variable> //Type de la variable.
<Type des variables> //Type communs aux variables.Voir les différents types de variables.

//Remarque : Les mots-clés un, une et des ne sont pas obligatoires : ce sont des mots d'agrément.

NomClient est une chaîne
Compteur est un entier
Prix est un réel
i, j, k sont des entiers

-Déclarer et initialiser une variable
<Nom de la variable> est un(e) <Type de la variable> = <Valeur>
//ou
<Nom de la variable> est un(e) <Type de la variable>
<Nom de la variable> = <Valeur>

-Détail de la syntaxe

<Nom de la variable> //Nom de la variable à déclarer.
<Type de la variable> //Type de la variable. Voir les différents types de variables.
<Valeur> //Valeur à affecter à la variable.
//Remarque : Lorsque plusieurs variables du même type sont déclarées et initialisées sur la même ligne, seule la dernière variable est initialisée.

NomClient est une chaîne
NomClient = "Dupond"
Compteur est un entier = 7
i, j, k sont des entiers = 21
// Seul k est initialisé à 21

Limites

-Déclaration de variables de même nom
//Dans un traitement, il est interdit d'utiliser plusieurs variables de même nom (quel que soit le type de ces variables).


Constante

Utilisation

//Les constantes sont des éléments du langage dont la valeur est fixée une fois pour toute. Cette valeur ne peut pas être modifiée au cours du programme.

CONSTANT et CONSTANTE
//Remarque : Les mots-clés CONSTANT et CONSTANTE sont acceptés. Dans cette documentation, seul le mot-clé CONSTANT est utilisé et peut être remplacé par CONSTANTE.

Syntaxe

//Déclarer une ou plusieurs constantes
CONSTANT
<Nom de la constante 1> = <Valeur 1>
<Nom de la constante 2> = <Valeur 2>
FIN

Détail de la syntaxe

CONSTANT //Signale le début des déclarations de constantes.
<Nom de la constante> //Nom de la constante à déclarer.
<Valeur> //Valeur de la constante.
FIN //Signale la fin des déclarations de constantes.

CONSTANT
TauxTVA = 19.6
FIN

Notes

-Déclaration de constantes
//Les constantes doivent être déclarées dans la procédure

Limites

-Déclarer des constantes de même nom
//Dans un même traitement, il n'est pas possible de déclarer plusieurs éléments (variables ou constantes) de même nom.

-Il n'est pas possible de déclarer un membre de type constante dans :
//une structure.
//une variable composée.


Structure

Utilisation

//Une structure est un type de données personnalisé. Une structure regroupe des éléments de types différents.

Syntaxe

-Déclarer une structure
<Nom de la structure> est une structure
<Membres de la structure>
FIN

Détail de la syntaxe
<Nom de la structure> //Nom de la structure à déclarer.
<Membres de la structure> //Déclarations des variables contenues dans la structure. Ces variables sont appelées les membres de la structure.
FIN //Fin de déclaration des variables.

RefProduit est une structure
CodeF est un entier
CodePr est une chaîne fixe sur 10
FIN

-Déclarer une variable de type structure
<Nom de la variable> est une <Nom de la structure>

Détail de la syntaxe
<Nom de la variable> //Nom de la variable de type structure à déclarer.
<Nom de la structure> //Nom d'une structure précédemment déclarée.

RefProduit est une structure
CodeF est un entier
CodePr est une chaîne fixe sur 10
FIN

Fauteuil est une RefProduit

-Manipuler un membre d'une variable de type structure
<Nom de la variable structure>:<Nom du membre de la structure>

Détail de la syntaxe
<Nom de la structure> //Nom de la variable structure à manipuler.
<Nom du membre de la structure> //Nom du membre de la structure à manipuler.

RefProduit est une structure
CodeF est un entier
CodePr est une chaîne fixe sur 10
FIN

Fauteuil est une RefProduit

Fauteuil:CodeF = 7
Fauteuil:CodePr = "Meuble"

Notes

-Déclaration de structures
//SI une structure <Nom de la structure> est déclarée :
//dans le code du projet, il sera possible de déclarer une variable du type <Nom de la structure> dans l'ensemble du projet.
//dans le code de déclaration des globales d'une fenêtre, il sera possible de déclarer une variable du type <Nom de la structure> dans cette fenêtre, dans les champs de cette fenêtre et dans les procédures locales associées.
//dans le code d'ouverture d'un état, il sera possible de déclarer une variable du type <Nom de la structure> dans cet état, dans les champs de cet état et dans les procédures locales associées.
//dans le code de déclaration d'une classe, il sera possible de déclarer une variable du type <Nom de la structure> dans cette classe et dans les méthodes de cette classe.
//dans un traitement, il sera possible de déclarer une variable du type <Nom de la structure> dans ce traitement.

-Type des membres d'une structure
//Les membres d'une structure peuvent être de type :
WIND001000entier //ou sélectionné parmi les entiers avancés.
réel //ou sélectionné parmi les réels avancés.
monétaire
chaîne //ou sélectionné parmi les chaînes avancées.
tableau //tableau "simple", tableau dynamique ou tableau fixe.

-Déclarer un membre de type tableau dans une structure
//Déclarer un membre de type tableau simple :
//Les dimensions du tableau sont fixées des la Déclaration. il est possible de modifier les dimensions du tableau avec la fonction Dimension.

//Déclarer un membre de type tableau dynamique :
//il est nécessaire de définir les dimensions du tableau (c'est-A-dire d'allouer le tableau) avant d'utiliser le tableau.

//Par exemple :
// Déclaration d'une structure
Struct est une structure
x1 est un entier
x2 est un tableau dynamique // Déclaration du tableau
FIN

-Déclaration d'une variable de type structure
MaStruct est une Struct
// Allocation du tableau
MaStruct:x2 = allouer un tableau dynamique de 4,7 entiers
// Utilisation du tableau
MaStruct:x2[1,1] = 25

Limites

-Limites d'une structure
//L'héritage de structure est interdit : une structure ne peut pas hériter d'une autre structure.
//Il n'est pas possible de restreindre l'accès à un membre d'une structure : tous les membres d'une structure sont publics.


Tableau

Utilisation

//Un tableau est un type structuré qui permet de regrouper une série d'éléments de même type. Chaque élément du tableau est accessible directement par son numéro d'ordre.
//un tableau peut être redimensionné au cours du programme grâce à la fonction Dimension.

//Remarque : Le mot-clé Tableau permet de définir un tableau "simple".
//Deux autres types de tableaux "avancés" sont disponibles :
tableau dynamique // Tableau alloué à la demande.
tableau fixe // Tableau de taille fixe.

Syntaxe

-Déclarer un tableau "simple"
<Nom du tableau> est un tableau de <Dimension 1> [par <Dimension 2>]...[par <Dimension 10>] <Type des éléments du tableau>
//ou
<Nom du tableau> est un tableau de <Dimension 1> [,<Dimension 2>]...[,<Dimension 10>] <Type des éléments du tableau>

Détail de la syntaxe

<Nom du tableau> //Nom de la variable tableau à déclarer.
<Dimension 1>...<Dimension 10> //Dimension 1 à 10 du tableau (valeur entière).
<Type des éléments du tableau> //Type des éléments constituant le tableau. Voir les différents types de variables.
//Remarque : Le mot-clé un n'est pas obligatoire : c'est un mot d'agrément.

TableauClient est un tableau de 5 par 7 par 3 entiers
// Équivalent à :
TableauClient est un tableau de 5,7,3 entiers

-Redimensionner le tableau
Dimension(TableauClient,7,9,4)

-Faire référence à un tableau "simple"

//Faire référence à un élément d'un tableau à une dimension :
<Nom du tableau>[Indice1]

//Faire référence à un élément d'un tableau à deux dimensions :
<Nom du tableau>[Indice1, Indice2]
//ou
<Nom du tableau>[Indice1][Indice2]

//Faire référence à un élément d'un tableau à n dimensions :
<Nom du tableau>[Indice1,...,IndiceN]
//ou
<Nom du tableau>[Indice1]...[IndiceN]

Détail de la syntaxe

<Nom du tableau> //Nom du tableau à manipuler.
<Indice1> //Indice de l'élément pour la 1ière dimension.
<Indice2> //Indice de l'élément pour la 2ième dimension.
<IndiceN> //Indice de l'élément pour la Nième dimension (N <= 10).
//Remarque : Il n'est pas possible de manipuler un tableau dans sa totalité. Par exemple, il n'est pas possible d'affecter un tableau avec un autre tableau.

TableauClient[2,5,3] = 47
// Équivalent à TableauClient[2][5][3] = 47

Notes

-Dimension d'un tableau "simple"
Dimension //la fonction Dimension permet de connaître le nombre total d'éléments dans un tableau, redimensionner un tableau.
//Attention : la fonction Dimension ne permet pas de modifier le nombre de dimensions d'un tableau.


Variable composée

Variables composées

Utilisation

//Une variable composée est composée d'éléments (membres) de types différents.

Syntaxe

-Déclarer une variable composée

<Nom de la variable> est composée de
<Membres de la variable composée>
FIN

Détail de la syntaxe

<Nom de la variable> //Nom de la variable composée à déclarer.
<Membres de la variable composée> //Déclarations des variables contenues dans la variable composée. Ces variables sont appelées les membres de la variable composée.
FIN //Fin de déclaration de la variable composée.

RefProduit est composée de
CodeF est un entier
CodePr est une chaîne fixe sur 10
FIN

-Manipuler un membre d'une variable composée

<Nom de la variable>.<Nom du membre>

Détail de la syntaxe

<Nom de la variable> //Nom de la variable composée à manipuler.
<Nom du membre> //Nom du membre à manipuler.

RefProduit.CodeF = 7
RefProduit.CodePr = "Écran"

Notes

-Manipuler une variable composée
//une variable composée peut être utilisée sans faire référence à ses membres.
//Par exemple :
VarCompose est composé de
Membre1 est une chaîne fixe sur 8
Membre2 est une chaîne fixe sur 12
FIN

Ch = VarCompose // Ch est construit en concaténant tous les membres de la variable composée
VarCompose = Ch // Ch est transféré vers la variable composée

-Type des membres d'une variable composée
//Les membres d'une variable composée peuvent être de Type :
entier //(ou sélectionné parmi les entiers avancés).
réel //(ou sélectionné parmi les réels avancés).
monétaire
chaîne fixe, chaîne ASCIIZ OU chaîne Pascal.
tableau //(tableau "simple", tableau dynamique ou tableau fixe).
structure

-Déclarer un membre de type tableau dans une variable composée
//Déclarer un membre de type tableau simple :
//Les dimensions du tableau sont fixées des la Déclaration. il est possible de modifier les dimensions du tableau avec la fonction Dimension.

//Déclarer un membre de type tableau dynamique :
//il est nécessaire de définir les dimensions du tableau (c'est-à-dire d'allouer le tableau) avant d'utiliser le tableau.
//Par exemple :
// Déclaration d'unosée
MaVarComp est composée de
x1 est un entier
x2 est un tableau dynamique // Déclaration du tableau
FIN

-Allocation du tableau
MaVarCom.x2 = allouer un tableau dynamique de 4,7 entiers

-Initialisation du tableau
MaVarCom.x2[1,1] = 25

Limites

-Limites d'une variable composée
//il n'est pas possible de :
//affecter directement une variable composée à une autre variable composée : chaque membre doit être affecté un par un.
//comparer deux variables composées.
//passer une variable composée en paramètre à une procédure.
//définir un héritage dans une variable composée.
//restreindre l'accès à un membre d'une variable composée : tous les membres d'une variable composée doivent être publics.


Manipuler les chaînes de caractères

Manipuler les chaines de caractères

Présentation

//WinDev permet de réaliser plusieurs types d'opérations sur les chaînes de caractères grâce aux fonctions du W-Langage. Il est ainsi possible :
//de manipuler le contenu de la chaîne,
//d'effectuer des conversions et des cryptages.

Manipuler le contenu d'une chaîne

//Les fonctions du W-Langage permettent aussi bien d'extraire des parties d'une chaîne de caractères (fonctions Gauche, Droite ou Milieu par exemple) que d'effectuer des recherches dans une chaîne (fonction Position ou Remplace par exemple).
//Certaines fonctionnalités proposées par les fonctions du W-Langage peuvent aussi être réalisées grâce aux opérateurs sur les chaînes de caractères du W-Langage.

Effectuer des conversions et des cryptages

//Plusieurs fonctions du W-Langage permettent de simplifier les conversions des chaînes de caractères.
//Il est ainsi possible par exemple de :
//convertir une chaîne de caractères en phonétique (fonction Phonétique).

Exemple

//Pour plus de détails, consultez :


Fonctions W-Langage

Fonctions de gesyion des chaînes de caractères

Voir aussi : Opérateurs sur les chaînes de caractères ([[]], + , ...)

AnsiVersOem //Convertit une chaîne de caractères au format ANSI (Windows) en une chaîne de caractères au format OEM (DOS)

Asc //Calcule le code ASCII du caractère spécifié (le code ASCII utilisé correspond à la norme ANSI utilisée par Windows)

Caract //Renvoie le caractère correspondant au code ASCII spécifié (le code ASCII utilisé correspond à la norme ANSI utilisée par Windows)

ChaîneCompare //Compare deux chaînes de caractères

ChaîneConstruit //Construit une chaîne de caractères en fonction d'un format et de paramètres

ChaîneFormate //Formate une chaîne de caractères selon les options choisies

ChaîneOccurrence //Calcule le nombre d'occurrences d'une chaîne de caractères spécifique dans une autre chaîne de caractères

ChaîneRécupère //Récupère une chaîne de caractères à partir d'un format externe (C, etc.)

ChaîneVersDate //Transforme une date sous forme de chaîne de caractères en une date au format AAAAMMJJ

Complète //Renvoie une chaîne de caractères spécifique à une taille déterminée (cette chaîne peut être tronquée ou complétée par des espaces (ou par tout autre caractère) pour atteindre la taille requise)

ComplèteRep //Ajoute si nécessaire le caractère "\" à la fin d'une chaîne de caractères

Crypte //Crypte une chaîne de caractères sous forme binaire ou sous forme ASCII

Décrypte //Décrypte un une chaîne de caractères préalablement cryptée par la fonction Crypte

Droite //Extrait la partie droite d'une chaîne de caractères (c'est-à-dire les derniers caractères)

ExtraitChaîne //Extrait une sous-chaîne d'une chaîne de caractères en fonction d'un séparateur de chaîne donné

Gauche //Extrait la partie gauche d'une chaîne de caractères (c'est-à-dire les premiers caractères)

Inverse //Renvoie pour chaque caractère d'une chaîne de caractères le complément à 255. (la chaîne de caractères est ainsi inversée)

Majuscule //Convertit une chaîne de caractères en majuscules en fonction des paramètres de localisation définis dans Windows

Milieu //Extrait une sous-chaîne d'une chaîd'une position donnée

Minuscule //Convertit une chaîne de caractères en minuscules en fonction des paramètres de localisation définis dans Windows

NumériqueVersChaine //Transforme un numérique (entier, réel ou monétaire) en une chaîne de caractères selon le format spécifié

OemVersAnsi //Convertit une chaîne de caractères au format OEM (DOS) en une chaîne de caractères au format ANSI (Windows)

Phonétique //Détecte si deux chaînes de caractères sont phonétiquement semblables (selon la phonétique française)

Position //Recherche la position d'une chaîne de caractères dans une autre chaîne de caractères

PositionOccurrence //Recherche la X ème position d'une chaîne de caractères dans une autre chaîne de caractères

Remplace //Remplace toutes les occurrences d'un mot présent dans une chaîne par un autre mot

Répète //Concatène N répétitions d'une même chaîne de caractères

SansAccent //Transforme les caractères accentués d'une chaîne de caractères en caractères non accentués

SansEspace //Renvoie une chaîne de caractères sans les espaces situés à gauche et à droite

Taille //Renvoie la taille d'une chaîne de caractères (nombre de caractères)

Val //Renvoie la valeur numérique d'une chaîne de caractères (il est ainsi possible d'effectuer des calculs numériques sur des chaînes de caractères)


Manipuler les dates

Manipuler des dates et des heures

Présentation

//WinDev met à votre disposition de nombreux moyens pour manipuler les dates et les heures dans vos applications :
//Les champs de saisie de type Date ou de type Heure.
//Les rubriques de fichier de type Date ou de type Heure.
//Les variables de type Date, Heure, DateHeure et Durée.
//Les propriétés sur les variables de type Date, Heure, DateHeure et Durée.
//Les fonctions du W-Langage de gestion des dates et des heures.

Différentes façons de manipuler les dates et les heures

//Selon le type de manipulation effectuée sur les dates et les heures, il peut être plus efficace d'utiliser les variables ou les fonctions du W-Langage.

-Les fonctions du W-Langage sont conseillées :
//Pour le formatage des dates et des heures ainsi que pour les opérations de conversion (conversion d'une date en entier, etc.).
//Pour obtenir des informations sur les dates et les heures (validité de la date ou de l'heure, obtenir le jour en toutes lettres, etc.).

-L'utilisation des variables est conseillée :
//Pour tous les calculs effectués sur les dates et les heures (différence, calcul de durée, etc.).
//Pour les extractions de partie de date ou d'heure (jour, mois, année, etc.).

Manipuler les dates ou les heures présentes dans des champs de saisie

//Il est possible de manipuler les valeurs présentes dans les champs de saisie avec les variables de type Date ou Heure.
//Il suffit d'affecter la variable avec le contenu du champ.

DateDébut est une date
DateDébut = ChampDate // Affectation de la variable avec le contenu du champ

Exemple

//WinDev 7.5 est livré en standard avec deux exemples de manipulation des dates et des heures :
//WD7 Calculs sur dates et heures
//WD7 Calendrier
//Pour plus de détails, consultez :
Les fonctions de gestion des dates et des heures
Les types Date , Heure , DateHeure et Durée


Fonctions de gestion des dates et des heures

ChaîneVersDate //Transforme une date sous forme de chaîne de caractères en une date au format AAAAMMJJ

ChaîneVersDurée //Transforme une durée sous forme de chaîne de caractères en une durée utilisable par une variable de type Durée.

DateDifférence //Calcule la différence de jours entre deux dates

DateDuJour //Renvoie ou modifie la date système

DateHeureDifférence //Calcule la différence entre deux dates et heures

DateHeureParDéfaut //Permet de définir la valeur par défaut des variables de type Date, Heure, et DateHeure.

DateSys //Renvoie ou modifie la date système

DateValide //Teste la validité d'une date comprise entre le 01 janvier 0001 et le 31 décembre 9999

DateVersChaine //Formate la date spécifiée au format spécifié

DateVersEntier //Transforme une date en un entier

DuréeVersChaîne //Formate la durée spécifiée au format spécifié.

EntierVersDate //Transforme un entier en une date au format AAAAMMJJ

EntierVersHeure //Transforme un entier en une heure au format HHMMSSCC

EntierVersJour //Renvoie le jour de la semaine correspondant à la date spécifiée

EntierVersJourEnLettre //Renvoie le jour de la semaine en toutes lettres correspondant à la date spécifiée

EntierVersMoisEnLettre //Renvoie le mois en toutes lettres correspondant à la date spécifiée

EntierVersNuméroDeSemaine //Renvoie le numéro de la semaine dans l'année correspondant à la date spécifiée

HeureDifférence //Calcule la différence entre deux heures (en centièmes de seconde)

HeureSys //Renvoie ou modifie l'heure système

HeureValide //Teste la validité d'une heure

HeureVersChaine //Formate l'heure passée en paramètre selon le format HH:MM:SS:CC

HeureVersEntier //Transforme une heure en un entier

Maintenant //Renvoie ou modifie l'heure système

NuméroDeSemaine //Renvoie le numéro de la semaine dans l'année correspondant à la date spécifiée


Fonctions Euro

Fonctions de gestion de l'Euro

Conversion de valeurs

eChangeDevise //Convertit une devise en une autre devise
eVersDevise //Convertit une valeur exprimée en Euro en une autre devise
eVersEuro //Convertit en Euro une valeur exprimée dans une devise spécifique

Devise affichée ou mémorisée par défaut

eDeviseAffParDéfaut //Identifie ou modifie la devise d'affichage utilisée par défaut
eDeviseMemParDéfaut //Identifie ou modifie la devise de mémorisation utilisée par défaut

Différence d'arrondi

eDifférenceArrondi //Renvoie la différence d'arrondi entre la valeur affichée d'un champ de type "Monétaire + Euro" et le champ associé permettant un double affichage

Caractéristiques des devises

eInitDevise //Ajoute ou modifie les caractéristiques d'une devise dans la table de correspondance des devises
eNomDevise //Renvoie le libellé d'une devise
eTauxDeChange //Renvoie la valeur du taux de change d'une devise


Manipulez vos fichiers XLS

Présentation

//Le W-langage met à votre disposition des fonctions pour gérer vos fichiers de type ".XLS". Grâce à ces fonctions, vous pouvez récupérer l'ensemble des données saisies sous Excel.
//Ces fonctions permettent de :
// manipuler des fichiers ".XLS" : ouverture et fermeture.
// obtenir des informations sur vos fichiers ".XLS" présentes sur la première page du classeur : donnée d'une cellule, nombre de lignes, nombre de colonnes, type de colonne, titre de colonne (voir schéma).
// connaître la version d'Excel utilisée.
// identifier les erreurs survenues lors des différentes manipulations sur un fichier ".XLS".

Exemples

//Pour plus de détails, consultez :


Fonctions XLS

Manipulations des fichiers XLS

xlsFerme //Ferme un fichier XLS

xlsOuvre //Ouvre un fichier XLS

xlsOuvreExport //Ouvre un fichier XLS situé dans le répertoire Export du modèle

Récupération des données

xlsDonnée //Récupère les données d'une cellule d'un fichier XLS

xlsNbColonne //Renvoie le nombre de colonnes d'un fichier XLS

xlsNbLigne //Renvoie le nombre de lignes d'un fichier XLS


Présentation

Manipulez les fichiers externes

Présentation

//WinDev met à votre disposition des fonctions pour gérer des fichiers externes depuis vos applications WinDev.
//Un fichier externe est un fichier à accès direct, appelé également par abus de langage "fichier texte". Les fichiers externes peuvent être de tout type (".TXT", ".INI", ...). Les fichiers externes peuvent contenir :
//des caractères lisibles (sous forme de chaîne de caractères),
//des caractères non lisibles (sous forme binaire).

//Attention : Il ne faut pas confondre fichier externe et fichier Hyper File. Les fichiers Hyper File sont des fichiers de données au format WinDev et doivent être manipulés avec les fonctions Hyper File.
//WinDev vous propose trois groupes de fonctions permettant de manipuler :
//le contenu de vos fichiers externes,
//les fichiers présents sur vos disques (copie de fichier par exemple),
//les répertoires de vos disques (création d'un répertoire par exemple).

Manipulations du contenu des fichiers externes

//WinDev vous permet de :
//créer, d'ouvrir et de fermer vos fichiers externe.
//gérer le blocage de vos fichiers externe.
//lire le contenu de vos fichiers externes : lecture d'une ligne ou d'un bloc d'octets (caractères).
//écrire dans vos fichiers externes : écriture d'une ligne, d'une chaîne de caractères ou d'une portion de mémoire.
//se déplacer dans vos fichiers externe.

-Exemple
//Votre programme gère un fichier de type ".INI" de taille supérieure à 64 Ko. La taille de ce fichier ".INI" est trop importante pour manipuler ce fichier avec les fonctions INI. Utilisez les fonctions des fichiers externes pour manipuler ce fichier.
//Pour récupérer le contenu de ce fichier : lisez le contenu du fichier et affectez ces informations lus dans une portion de mémoire.
//Pour modifier le contenu de ce fichier : ajoutez diverses informations dans ce fichier à une position donnée.
//Ce fichier nécessite d'être partiellement bloqué pour une mise à jour : bloquez ce fichier. Ce fichier sera uniquement accessible par l'application qui bloque le fichier.

Manipulation de fichiers

//WinDev vous permet de :
//compresser et crypter des fichiers.
//connaître les caractéristiques des fichiers.
//modifier et obtenir le nom et le chemin des fichiers.
//comparer le contenu de plusieurs fichiers.
//lister les fichiers d'un répertoire en lançant une procédure effectuant un traitement pour chaque fichier.

-Exemple

//Votre programme gère des fichiers de taille importante contenant des informations confidentielles. Cryptez et compressez ces fichiers avant de les transférer sur votre réseau.
//Effectuez une recherche sur vos fichiers et exécutez une procédure spécifique sur les fichiers trouvés.

Manipulation de disques et de leurs répertoires

//WinDev permet de :
//obtenir des informations sur les répertoires et sur les disques accessibles.
//maépertoires.

Exemple

//Pour plus de détails, consultez :


Gestion des fichiers externes et des répertoires

Fonctions et gestion des fichiers externes

Manipulations du contenu des fichiers externes

-Opérations de base

fChargeTexte //Charge le contenu d'un fichier texte dans tout champ ou variable texte (variable de type chaîne, champ de saisie d'une fenêtre, un champ libellé d'un état, ...)
fCrée //Crée une nouveau fichier externe
fFerme //Ferme un fichier externe
fOuvre //Ouvre un fichier externe

-Blocage

fBloque //Bloque entièrement ou partiellement un fichier externe
fDébloque //Débloque entièrement ou partiellement un fichier externe

-Lecture et écriture

fEcrit //Écrit une chaîne de caractères ou une portion de mémoire dans un fichier externe
fEcritLigne //Écrit une ligne dans un fichier externe
fLit //Lit le contenu d'un fichier externe pour l'affecter ou non dans une portion de mémoire
fLitLigne //Lit une ligne dans un fichier externe
fSauveTexte //Crée et remplit un fichier texte avec le contenu d'un champ texte ou d'une variable texte (variable de type chaîne, champ de saisie d'une fenêtre, un champ libellé d'un état, ...)

-Déplacement dans un fichier externe

fPositionne //Renvoie et modifie la position en cours dans un fichier externe

Manipulation des fichiers

-Caractéristiques d'un fichier

fAttribut //Identifie ou modifie les attributs d'un fichier
fDate //Renvoie ou modifie les différentes dates d'un fichier (date de création, de modification ou d'accès)
fHeure //Renvoie ou modifie les différentes heures d'un fichier : heure de création, de modification ou d'accès
fTaille //Renvoie la taille d'un fichier en octets

-Chemin et nom d'un fichier

fCheminCourt //Renvoie le chemin complet court d'un fichier ou d'un répertoire
fCheminLong //Renvoie le chemin complet long d'un fichier ou d'un répertoire
fCopieFichier //Copie un fichier
fExtraitChemin //Renvoie les différents éléments d'un chemin : disque, répertoire(s), nom et extensio
fFichierTemp //Renvoie le nom d'un fichier temporaire unique
fListeFichier //Liste les fichiers d'un répertoire (et les fichiers des sous-répertoires du répertoire) et retourne le nombre de fichiers listés. Pour chaque fichier trouvé, fListeFichier lance automatiquement une procédure spécifique
fNomCourt //Renvoie le nom court d'un fichier ou d'un répertoire
fNomLong //Renvoie le nom long d'un fichier ou d'un répertoire
fRenomme //Modifie le nom d'un fichier
fSupprime //Supprime un fichier accessible depuis le poste en cours

Manipulation des répertoires

-Informations sur le disque ou sur un répertoire

fRepEnCours //Identifie ou modifie le répertoire en cours
fRepExe //Renvoie le nom du répertoire à partir duquel l'exécutable en cours est lancé.

-Manipulation d'un répertoire

ComplèteRep //Ajoute, si nécessaire, le caractère "\" à la fin d'une chaîne de caractères. Cette fonction est utile pour la construction de noms de fichiers complets en cas d'incertitude sur le format du chemin (par exemple si l'utilisateur saisit un chemin de fichier).
fRep //Recherche un fichier ou un répertoire


Fonctions financières

FinAmortissement //Crée une matrice d'amortissement pour le montant d'un emprunt à un taux d'intérêt constant pour une durée définie

FinAmortissementDégressif //Calcule la valeur de l'amortissement d'un bien pour une période spécifique grâce à la formule de l'amortissement décroissant à taux fixe

FinAmortissementLinéaire //Calcule la valeur de l'amortissement linéaire d'un bien pour une période donnée

FinErreur //Renvoie le numéro de la dernière erreur due à une fonction financière

FinIntérêtPériode //Évalue pour une période donnée le montant des intérêts dus pour un emprunt remboursé par des versements périodiques constants avec un taux d'intérêt constant

FinNbVersement //Renvoie le nombre de versements nécessaires pour rembourser un capital selon un taux

FinTauxIntérêt //Évalue le taux d'intérêt pour un emprunt donné sur une période avec des versements constants

FinValActuelle //Renvoie la valeur actuelle d'un investissement

FinValActuelleNette //Renvoie la valeur actuelle nette d'un investissement basé sur des flux financiers non constants

FinValFuture //Renvoie la valeur future d'un investissement (remboursements périodiques constants avec un taux d'intérêt constant)

FinValRemboursement //Renvoie le montant de chaque remboursement périodique d'un investissement à remboursement et à taux d'intérêt constants


Les matrices

Présentation

//WinDev met à votre disposition des fonctions qui permettent de manipuler les matrices.
//Les matrices sont un outil mathématique permettant de simplifier, et de résoudre de nombreux problèmes. Les calculs sur les matrices sont utilisés dans de nombreux domaines : économie, physique, ...
//Dans ces domaines, les problèmes rencontrés peuvent souvent se mettre sous la forme d'un système d'équations. Le résultat de ce système d'équations peut être calculé grâce aux matrices.

Définition

//Une matrice est un ensemble ordonné de "n p" nombres, généralement représenté sous forme d'un tableau de n lignes et p colonnes.
//Les nombres composant la matrice sont les éléments de la matrice. Chaque élément est identifié par sa ligne et sa colonne. Une valeur est associée à chaque élément.

//Dans cette matrice, n=2 lignes, et p=4 colonnes. La valeur de l'élément (ligne 2 , colonne 3) est 7

//La dimension (ou taille) de la matrice correspond au nombre de lignes et au nombre de colonnes de la matrice considérée.
//WinDev permet de gérer dynamiquement la taille de vos matrices. En effet, lors de sa création, une matrice est vide : elle contient 0 ligne, et 0 colonne. C'est une matrice de dimension 0 x 0. Il suffit d'initialiser un élément en ligne n et colonne p, pour que la taille de la matrice devienne n x p. Par exemple, après l'initialisation d'un élément en ligne 6 et colonne 12, la taille de la matrice devienne 6 x 12.

Comment manipuler les matrices ?

//Pour gérer vos matrices, WinDev vous propose 20 fonctions du W-Langage. Ces fonctions permettent de :
-manipuler les matrices : création, copie, inversion, compression, suppression.
-initialiser les éléments des matrices.
-lire la valeur des éléments des matrices.
-effectuer divers calculs sur les matrices : addition, multiplication, transposée, déterminant, ...
-obtenir diverses informations sur les matrices : nombre de lignes, nombres de colonnes, ...

Exemple

-Pour plus de détails, consultez :


Fonctions de gestion des matrices

Voir aussi : Les matrices

Manipulations d'une matrice

MatCompresse //Compresse la place mémoire occupée par une matrice

MatCopie //Crée la copie d'une matrice

MatCrée //Crée une matrice

MatInverse //Inverse une matrice carrée

MatSupprime //Supprime une matrice existante

Initialisations des éléments d'une matrice

MatEcrit //Écrit un élément dans une matrice

MatRemplit //Initialise tous les éléments d'une matrice d'une taille donnée

Lecture de la valeur des éléments d'une matrice

MatLit //Lit la valeur d'un élément d'une matrice

MatLitColonne //Lit la valeur de tous les éléments d'une colonne d'une matrice

MatLitLigne //Lit la valeur de tous les éléments d'une ligne d'une matrice

Calcul sur une matrice

MatAdditionne //Additionne deux matrices de même dimension

MatDéterminant //Calcule le déterminant d'une matrice carrée

MatMultiplie //Multiplie deux matrices

MatRéelAdditionne //Additionne une valeur à chaque élément d'une matrice

MatRéelMultiplie //Multiplie chaque élément d'une matrice par une valeur

MatTranspose //Calcule la transposée d'une matrice

Informations sur une matrice

MatExiste //Teste l'existence d'une matrice en mémoire

MatNbColonne //Renvoie le nombre de colonnes d'une matrice

MatNbLigne //Renvoie le nombre de lignes d'une matrice

Gestion des erreurs sur une matrice

MatErreur //Identifie le type de la dernière erreur due à une fonction de gestion de matrices


Les statistiques

Présentation

//WinDev met à votre disposition des fonctions permettant de réaliser différentes statistiques.
//Les statistiques sont calculées à partir de matrices. Les valeurs prises en compte pour le calcul des statistiques sont les valeurs des éléments d'une matrice. Les séries de valeurs correspondent à une ligne (ou une colonne) d'une matrice.

//Par exemple, les valeurs de la ligne 1 de cette matrice sont 3, 2, 4, 5 et 6.

Exemple

-Pour plus de détails, consultez :


Fonctions statistiques

Voir aussi : Les statistiques

StatCorrélation //Calcule le coefficient de corrélation entre deux séries de valeurs

StatCovariance //Calcule la covariance entre deux séries de valeurs

StatEcartMoyen // Calcule la moyenne des écarts absolus des valeurs par rapport à leur moyenne arithmétique

StatEcartType //Calcule l'écart type d'une série de valeurs

StatEcartTypeP //Calcule l'écart type d'une série complète de valeurs

StatErreur //Calcule le numéro de la dernière erreur due à une fonction statistique

StatMax //Calcule la valeur maximale d'une série de valeurs

StatMin //Calcule la valeur minimale d'une série de valeurs

StatMoyenne //Calcule la moyenne arithmétique, géométrique ou harmonique d'une série de valeurs

StatSomme //Calcule le cumul d'une série de valeurs

StatVariance //Calcule la variance d'une série de valeurs

StatVarianceP //Calcule la variance d'une série complète de valeurs


Fonctions binaires

Fonctions de gestion des valeurs binaires

ETBinaire //Renvoie le résultat du ET logique (bit à bit) entre deux valeurs

NONBinaire //Renvoie le résultat du NON logique (bit à bit) d'une valeur

OUBinaire //Renvoie le résultat du OU logique (bit à bit) entre deux valeurs

OuExclusifBinaire //Renvoie le résultat du OU Exclusif logique (bit à bit) entre deux valeurs


Liste des fonctions SQL

Fonctions SQL du Langage

SQLAssocie //Associe automatiquement chaque colonne du résultat de la requête à un champ ou une variable de l'application

SQLAvance //Passe à la ligne suivante (c'est-à-dire l'enregistrement suivant) du résultat de la requête

SQLBloque //Bloque soit la table de données dans sa totalité, soit les enregistrements sélectionnés par la requête

SQLChangeConnexion //Modifie la connexion en cours

SQLCol //Récupère le contenu de la colonne spécifiée dans le résultat de la requête, pour la ligne en cours (parcours du résultat d'une requête de type SQLPremier / SQLSuivant)

SQLColonne //Récupère le nom (et le type) des colonnes d'une table

SQLConnecte //Connecte l'application en cours à une base de données à interroger par SQL

SQLDéconnecte //Ferme la connexion en cours et libère l'espace mémoire utilisé par la connexion

SQLDernier //Positionne sur la dernière ligne du résultat de la requête

SQLExec //Nomme et exécute une requête SQL

SQLExecWDR //Exécute une requête SQL créée avec l'éditeur de requêtes de WinDev

SQLFetch //Passe à la ligne suivante (c'est-à-dire l'enregistrement suivant) du résultat de la requête

SQLFerme //Déclare la fin d'exécution d'une requête et libère les ressources mémoires allouées lors de l'exécution de la requête

SQLFormatColonne //Renvoie les différents types de colonnes supportés par la source de données

SQLInfoGene //Initialise les différentes variables SQL avec les informations relatives à la dernière requête exécutée

SQLListeSource //Liste les sources de données déclarées sur un site local

SQLListeTable //Liste toutes les tables ODBC accessibles avec le système de base de données connecté

SQLLitCol //Récupère de contenu de la colonne spécifiée dans le résultat de la requête, pour la ligne en cours

SQLLitMémo //Récupère de contenu d'une colonne de type Mémo dans le résultat de la requête, pour la ligne en cours

SQLLitMémoTexte //Récupère de contenu d'une colonne de type Mémo texte dans le résultat de la requête, pour la ligne en cours

SQLModifie //Modifie le contenu d'une ligne de résultat de la requête

SQLPositionne //Positionne directement sur la ligne de résultat spécifiée de la requête

SQLPrécédent //Positionne sur la ligne précédente du résultat de la requête

SQLPremier //Positionne sur la première ligne du résultat de la requête

SQLReqExiste //Teste l'existence d'une requête

SQLSuivant //Positionne sur la ligne suivante du résultat de la requête

SQLTable //Transfère directement le résultat d'une requête dans une table mémoire, avec possibilitartiel (récupération du résultat par blocs de lignes)

SQLTransaction //Débute, valide ou annule une transaction :
//soit sur les fichiers d'une base de données ouverte par la fonction SQLConnecte
//soit sur les fichiers d'une base de données ouverte par une connexion (OLE DB ou Accès Natif) décrite sous l'éditeur d'analyses, ou par la fonction HOuvreConnexion.


Gestion des zones mémoires

Les fonctions de gestions des zones mémoires

Création, ajout, modification et suppression

MemAjoute //Ajoute un élément dans une zone mémoire

MemCrée //Crée une zone mémoire

MemModifie //Modifie un élément dans une zone mémoire

MemSupprime //Supprime un élément dans une zone mémoire

MemSupprimeTout //Vide et supprime une zone mémoire

Récupération de valeurs

MemRécupère //Récupère la valeur de retour d'un élément dans une zone mémoire

MemValClé //Renvoie la valeur ajoutée ou modifiée (par les fonctions MemAjoute ou MemModifie) de l'élément en cours dans une zone mémoire

Positionnement

MemDernier //Positionne sur le dernier élément d'une zone mémoire et renvoie la valeur de retour de cet élément

MemEnCours //Renvoie l'indice de l'élément en cours

MemEnDehors //Permet de savoir si le parcours effectué sur la zone de mémoire est en dehors de la zone de mémoire

MemPositionne //Positionne la zone mémoire sur un élément

MemPrécédent //Positionne sur l'élément précédent d'une zone mémoire et renvoie la valeur de retour de cet élément

MemPremier //Positionne sur le premier élément d'une zone mémoire et renvoie la valeur de retour de cet élément

MemSuivant //Positionne sur l'élément suivant d'une zone mémoire et renvoie la valeur de retour de cet élément

Autres fonctionnalités

MemExiste //Teste l'existence d'une zone de mémoire

MemOccurrence //Renvoie le nombre d'éléments présents dans une zone de mémoire

MemRecherche //Recherche un élément dans une zone mémoire

MemTrie //Trie les éléments présents dans une zone mémoire

MemTrouvé //Vérifie si l'élément recherché a été trouvé


Fonctions mathématiques

-Fonctions de base

Abs //Calcule la valeur absolue d'une expression numérique ou d'une expression numérique (entière ou réelle)

Arrondi //Calcule la valeur arrondie d'une valeur numérique selon le nombre de décimales précisé

EstImpair //Identifie un nombre impair

EstPair //Identifie un nombre pair

Max //Renvoie la plus grande des valeurs passées en paramètre

Min //Renvoie la plus petite des valeurs passées en paramètre

Modulo //Retourne le reste d'une division entière

PartieDécimale //Renvoie la partie décimale d'un nombre

PartieEntière //Renvoie la partie entière d'un nombre

Puissance //Élève un nombre à une puissance

Racine //Calcule la racine d'un nombre

-Fonctions trigonométriques

ArcCosinus //Calcule l'arc cosinus d'une valeur numérique (entière ou réelle)

ArcSinus //Calcule l'arc sinus d'une valeur numérique (entière ou réelle)

ArcTang //Calcule l'arc tangente d'une valeur numérique (entière ou réelle)

Cosinus //Calcule le cosinus d'un angle

CoTang //Calcule la co-tangente d'un angle

Exp //Calcule l'exponentielle (inverse du logarithme népérien) d'une valeur numérique

Ln //Calcule le logarithme népérien (inverse de l'exponentielle) d'une valeur numérique

Log //Calcule le logarithme d'une valeur numérique

Sinus //Calcule le sinus d'un angle

Tang //Calcule la tangente d'un angle

-Fonctions diverses

Hasard //Renvoie un nombre aléatoire

InitHasard //Initialise le générateur de nombres aléatoires

NumériqueVersChaine //Renvoie une chaîne de caractères correspondant au nombre passé en paramètre selon le format décrit


Liste des fonctions TRUE

Aresult // affiche une chaîne de caractère dans une fenêtre " Résultats "

Fvalue // retourne la valeur de transfert d'un flux,
//qui représente la somme des valeurs transférées par les actions de ce flux

Mvalue // retourne la valeur d'un stock miroir

Options // initialise une ou plusieurs fonctionnalités, qui seront prises en compte à l'issue de l'exécution de la procédure

Svalue // retourne la valeur d'un stock

ValueRead // récupère la valeur d'une pseudo variable globale

ValueWrite // mémorise une valeur dans une pseudo variable

ReStartAt // initialise un rétro-calcul

ReStartStat // renseigne sur l'état du rétro-calcul

Liste des fonctions ajoutées au W-Langage
Pour plus d'information, consultez le manuel utilisateur : "Manuel Part 05 - Actions"

SetGlobalProcedure //déclare une procédure globale
CallGlobalProcedure //appelle une procédure globale

Rand //renvoie un nombre aléatoire compris en 0 et 1/32767
Srand //initialise le noyau des nombres aléatoires pour la fonction Rand
NormalMS //renvoie un nombre aléatoire selon la loi de distribution normale( Mean,Sigma)
NormalMSMM //renvoie un nombre aléatoire selon la loi de distribution normale(Mean,Sigma,Min,Max)
NormalMM //renvoie un nombre aléatoire selon la loi de distribution normale(Min,Max)
MeanSigma //calcul Mean et Sigma en fonction de Min et Max

DentDeScieN //génère un signal en dent de scie ( décroissant )
DentDeScieN //génère un signal en dent de scie ( décroissant )
Sign //retourne le signe d'une variable
Triangle //génère un signal triangulaire
TriangleCos //génère un signal triangulaire déphasé
TriangleS //génère un signal triangulaire

WithLookUp //retourne une d'une valeur d'entrée recherchée dans un tableau de points


Abs

Utilisation

//Renvoie la valeur absolue d'une valeur numérique ou d'une expression numérique (entière ou réelle).

-Récupération de la valeur absolue
ResValeurAbsolue = Abs(-16.23) // Renvoie 16.23
ResValeurAbsolue = Abs(4.51+16.23) // Renvoie 20.74

Syntaxe

<Résultat> = Abs(<Numérique>)

-Détail des paramètres

<Résultat> //Entier ou réel, Valeur absolue recherchée.
<Numérique> // Expression numérique, entier ou réel, Expression numérique ou valeur numérique à manipuler.

Notes

-Séparateur décimal
//Le séparateur décimal des nombres réels est celui défini dans le panneau de configuration de Windows.

-Précision des réels
//Si le paramètre passé à la fonction est un réel, le résultat est toujours un réel sur 8 octets.
//Si le paramètre passé à la fonction est un réel sur 4 octets, le résultat sera considéré comme un réel sur 8 octets, ce qui peut provoquer la présence de décimales superflues lors des affichages. Par exemple :

rValeur est un réel sur 4 octets = -1.70

Trace(Abs(rValeur)) // affiche 1.700000047684

//Pour éviter ce genre de problème, utilisez soit des réels sans préciser la taille, soit des monétaires.


ArcCosinus

Utilisation

//Renvoie l'arc cosinus d'une valeur numérique (entière ou réelle).

// Récupération de l'arc cosinus de 0.5
ResArcCosinus = ArcCosinus(0.5)
// Renvoie 60

Syntaxe

<Résultat> = ArcCosinus(<Valeur numérique>)

-Détail des paramètres

<Résultat> // Réel, Arc cosinus (angle en degré du cosinus) de la valeur numérique spécifiée, compris dans l'intervalle [0,180].
<Valeur numérique> // entier ou réel, Valeur numérique (Cosinus) A manipuler. Cette valeur doit être comprise dans l'intervalle [-1,1]. Dans le CAS contraire, une Erreur du W-Langage est générée.


ArcSinus

Utilisation

//Renvoie l'arc sinus d'une valeur numérique (entière ou réelle).

// Récupération de l'arc sinus de 0.5
ResArcSinus = ArcSinus(0.5)
// Renvoie 30

Syntaxe

<Résultat> = ArcSinus(<Valeur numérique>)

-Détail des paramètres

<Résultat> // Réel, Arc sinus (angle en degré du sinus) de la valeur numérique spécifiée, compris dans l'intervalle [-90,90].
<Valeur numérique> // Entier ou réel, Valeur numérique (sinus) à manipuler. Cette valeur doit être comprise dans l'intervalle [-1,1]. Dans le cas contraire, une erreur du W-Langage est générée.


ArcTang

Utilisation

//Renvoie l'arc tangente d'une valeur numérique (entière ou réelle).

// Récupération de l'arc tangente de 12
ResTang = ArcTang(12)
// Renvoie 85,2363583093

Syntaxe

<Résultat> = ArcTang(<Valeur numérique>)

-Détail des paramètres

<Résultat> // Réel, Arc tangente (angle en degré de la tangente) de la valeur numérique spécifiée, compris dans l'intervalle [-90,90] bornes exclues.
<Valeur numérique> // Entier ou réel, Valeur numérique (tangente) à manipuler.


Aresult

Aresult (fonction TRUE)

Utilisation

//affiche une chaîne de caractère dans une fenêtre " Résultats ".

-Exemple 1

//y est la valeur de retour de la procédure
y=100 * (50/35.6)
Aresult( 0,"y = ", y, " = valeur de y dans l'action Action 1" )

-Exemple 2

ch1,ch2 est une chaîne
ch1="Bonjour, nous sommes le "
ch2=", il est "
Aresult( 0,ch1,DateSys(),ch2,HeureSys() )
//Datesys() renvoie la date, Heuresys() renvoie l'heure

-Exemple 3

Aresult(2,"Ok")

Syntaxe

Aresult(<Numéro de la fenêtre Résultats>,<Texte1>,[<Texte2>],[<Texte3>],... )

-Détail des paramètres

<Numéro de la fenêtre Résultats> // Entier . Numéro de la fenêtre " Résultats ".
<Texte1> // Chaîne de caractères contenant le message à afficher. Ce paramètre est obligatoire.
<Texte2,...> // Chaîne de caractères optionnelle contenant la suite du message à afficher.paramètre


Arrondi

Utilisation

//Renvoie la valeur arrondie d'une valeur numérique selon le nombre de décimales précisé.

// Récupération de la valeur arrondie de -16.238167
ResArrondi = Arrondi(-16.238167,2)
// Renvoie 16.24

Syntaxe

<Résultat> = Arrondi(<Valeur numérique> [,<Nombre de décimales>])

-Détail des paramètres

<Résultat> // Entier ou réel, Valeur arrondie de la valeur numérique spécifiée.
<Valeur numérique> // Réel ou monétaire, Valeur numérique à arrondir. Le type monétaire est conseillé pour obtenir des résultats fiables.
<Nombre de décimales> // Entier optionnel, Nombre de décimales à retourner. Si ce paramètre n'est pas précisé, aucune décimale n'est retournée.

Notes

-Valeur numérique
//Si <Valeur numérique> est comprise entre :
//0 et 0.49 : le nombre est arrondi à 0. Par exemple, 3.2 est arrondi à 3 (aucune décimale).
//0.5 et 0.99 : le nombre est arrondi à 1. Par exemple, 3.7 est arrondi à 4 (aucune décimale).

-Séparateur décimal
//Le séparateur décimal des nombres réels est "." (point).


Asc

Exemple

Utilisation

//Calcule le code ASCII du caractère spécifié. Le code ASCII utilisé correspond à la norme ANSI utilisée par Windows.

CodeASCII = Asc("A") // Retourne 65
CodeASCII = Asc("Barbier") // Retourne 66

Syntaxe

<Résultat> = Asc(<chaîne de caractères>)

-Détail des paramètres

<Résultat> // Entier, code ASCII recherché (compris entre 0 et 255).

<chaîne de caractères> // Caractère ou chaîne de caractères
//Caractère dont le code ASCII doit être calculé. Si ce paramètre correspond à :
//une chaîne vide, <Résultat> sera égal à 0.
//une chaîne de caractères, <Résultat> sera égal au code ASCII du premier caractère.

Notes

-Extraction de chaîne
//L'extraction de chaîne (par les opérateurs [[ et ]]) peut être utilisée pour convertir un caractère présent
//à une position quelconque dans une chaîne.

-Par exemple :
Asc(Ch[[N]]) // retourne la valeur ASCII du Nième caractère de la chaîne "Ch".


Caract

Utilisation

//Renvoie le caractère correspondant au code ASCII spécifié. Le code ASCII utilisé correspond à la norme ANSI utilisée par Windows.

CaractASCII = Caract(49) // Retourne "1"
CaractASCII = Caract(87) // Retourne "W"

Syntaxe

<Résultat> = Caract(<Code ASCII>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, Caractère correspondant au code ASCII précisé.
<Code ASCII> // Entier, Valeur à convertir (comprise entre 0 et 255). Si la valeur n'est pas conforme, une erreur du W-Langage est générée.

Notes

-Éviter l'utilisation de Caract
//Les constantes pré-définies suivantes permettent d'éviter l'utilisation de la fonction Caract :
RC = Caract(13) + Caract(10) // Retour chariot
TAB = Caract(9) // tabulation
ESC = Caract(27) // échappement
ESP = Caract(160) // espace insécable


ChaîneCompare

Utilisation

//Compare deux chaînes de caractères selon des critères spécifiques.

MaChaîne1 est une chaîne = "WinDev est formidable"
MaChaîne2 est une chaîne = "WinDev 7 est formidable"
Résultat est un entier = ChaîneCompare(MaChaîne1, MaChaîne2)
// Résultat = -1

Syntaxe

<Résultat> = ChaîneCompare(<Première chaîne>, <Seconde chaîne> [, <Options>])

-Détail des paramètres

<Résultat> // Entier
0 // si les chaînes de caractères sont égales,
-1 // si <Première chaîne> est inférieure à <Seconde chaîne>,
1 // si <Première chaîne> est supérieure à <Seconde chaîne>.

<Première chaîne> // Chaîne de caractères (avec guillemets), chaîne de caractères à comparer.

<Seconde chaîne> // Chaîne de caractères (avec guillemets), chaîne de caractères à comparer.

<Options> // Constante (ou combinaison de constantes) optionnelle, options de comparaison :
ccOrdreLexicographique //Comparaison des chaînes de caractères selon l'ordre lexicographique (par exemple, le caractère 'é' est compris entre les caractères 'e' et 'f')
ccNormal //(par défaut), comparaison normale, similaire aux opérateurs de comparaison du type <, <=, >, >=, =, ...
ccSansAccent //Comparaison sans tenir compte des accents
ccSansCasse //Comparaison sans tenir compte de la casse des caractères dans les chaînes à comparer (majuscules/minuscules)
ccSansEspace //Comparaison sans tenir compte des espaces avant et après les chaînes de caractères à comparer
ccSansPonctuationNiEspace //Comparaison sans tenir compte de la ponctuation ni des espaces

Notes

-Équivalences entre la fonction ChaîneCompare et les opérateurs de comparaison

-Opérateur = :
//L'opérateur = est équivalent au code suivant :
ChaîneCompare(<Chaîne1>, <chaîne 2>, ccNormal)

-Opérateur ~= :
//L'opérateur ~= est équivalent au code suivant :
ChaîneCompare(<Chaîne1>, <chaîne 2>, ccSansCasse + ccSansAccent + ccSansEspace)

-Opérateur ~~ :
//L'opérateur ~~ est équivalent au code suivant :
ChaîneCompare(<Chaîne1>, <chaîne 2>, ccSansCasse + ccSansAccent + ccSansEspace + ccSansPonctuationNiEspace)

//Pour plus de détails sur les opérateurs de comparaison, consultez les Opérateurs de comparaison.


ChaîneConstruit

Utilisation

//Construit une chaîne de caractères en fonction d'un format et de paramètres.

MaChaîne1 est une chaîne
MaChaîne1 = "Le fichier %1 ne peut pas être ouvert par" + ...
"l'utilisateur %2. Le fichier %1 n'est pas accessible."
Résultat est une chaîne = ChaîneConstruit(MaChaîne1, "Exemple", "Tintin")

Syntaxe

<Résultat> = ChaîneConstruit(<Format> [, <Premier paramètre> [, <Second paramètre> [, ...]]])

-Détail des paramètres

<Résultat> // Chaîne de caractères, chaîne résultat : les caractères %X ont été remplacés par les paramètres indiqués.

<Format> // Chaîne de caractères (avec guillemets), chaîne de caractères contenant des paramètres optionnels (caractères %1 à %n).

<Premier paramètre>, <Second paramètre>, ... // Chaîne de caractères optionnelle (avec guillemets)
//Paramètres à insérer dans la chaîne de caractères formatée. Le <Premier paramètre> remplacera le caractère %1, le <Second paramètre> remplacera le caractère %2, etc. Le nombre de paramètres spécifiés doit être identique ou supérieur au nombre de paramètres utilisés dans la chaîne de caractères <Format>. Si la chaîne de caractères <Format> contient plus de paramètres, les paramètres supplémentaires seront remplacés par des chaînes vides.


ChaîneFormate

Utilisation

//Formate une chaîne de caractères selon les options choisies.

MaChaîne1 est une chaîne = "WinDev est formidable"
MaChaîne1 = ChaîneFormate(MaChaîne1, ccMajuscule)

Syntaxe

<Résultat> = ChaîneFormate(<chaîne>, <Options>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, chaîne formatée selon les critères choisis.

<chaîne> // Chaîne de caractères (avec guillemets), chaîne de caractères à formater.

<Options> // Constante ou combinaison de constantes, options de formatage :
ccMajuscule //Passe la chaîne de caractères en majuscules (y compris les caractères accentués)
ccMinuscule //Passe la chaîne de caractères en minuscules
ccSansAccent //Format sans accent
ccSansEspace //Enlève les espaces avant et après la chaîne de caractères
ccSansPonctuationNiEspace //Enlève la ponctuation et les espaces


ChaîneOccurrence

Utilisation

//Calcule le nombre d'occurrences d'une chaîne de caractères spécifique (en respectant les critères de recherche) dans une autre chaîne de caractères.

Res = ChaîneOccurrence("anastasia", "a") // Renvoie 4
Res = ChaîneOccurrence("toto titi tito", "to") // Renvoie 3
Res = ChaîneOccurrence("grille pain", "X") // Renvoie 0

ChaîneOccurrence("Le merle est dans le chêne", "le") // renvoie 2
ChaîneOccurrence("Le merle est dans le chêne","le", MotComplet) // renvoie 1
ChaîneOccurrence("Le merle est dans le chêne","le", SansCasse) // renvoie 3
ChaîneOccurrence("Le merle est dans le chêne","le", SansCasse + MotComplet) // renvoie 2

Syntaxe

<Résultat> = ChaîneOccurrence(<chaîne source>, <chaîne A rechercher> [, <Options>])

-Détail des paramètres

<Résultat> // Entier, Nombre d'occurrences ou 0 si aucune occurrence n'existe ou si la <Chaîne à rechercher> correspond à une chaîne vide ("").
<chaîne source> // Chaîne de caractères, Texte dans lequel les occurrences de <Chaîne à rechercher> doivent être recherchées.
<chaîne A rechercher> // Chaîne de caractères, Texte à rechercher dans la <Chaîne source>.
<Options> // Constante (ou combinaison de constantes) optionnelle

-Options de recherche :

MotComplet //Recherche un mot complet, c'est-à-dire entouré de caractères de ponctuation ou d'espaces.
SansCasse //Recherche sans tenir compte de la casse des caractères (majuscules/minuscules)


ChaîneVersDate
Saisissez ici le texte de la page


ChaîneVersDurée

Nouvelle page
Saisissez ici le texte de la page


Complète

Utilisation

//Renvoie une chaîne de caractères spécifique de taille déterminée. Cette chaîne peut être tronquée ou complétée par des espaces (ou par un autre caractère) pour atteindre la taille requise.

Complète("Alain", 8) // Renvoie "Alain "
Complète("Alain", 8, "A") // Renvoie "AlainAAA"
Complète("Alexandre", 4) // Renvoie "Alex"

Syntaxe

<Résultat> = Complète(<chaîne A compléter>, <Taille> [, <Caractère>])

-Détail des paramètres

<Résultat> // Chaîne de caractères
//chaîne de caractères à la taille spécifiée, complétée ou tronquée.
//Si <Chaîne à compléter> a une taille inférieure à <Taille>,
//la chaîne est complétée à droite par des espaces ou par des caractères si le paramètre <Caractère> est spécifié.
//Si <Chaîne à compléter> a une taille supérieure à <Taille>, la chaîne est tronquée à droite (équivalent à la fonction Gauche).

<chaîne A compléter> // Chaîne de caractères
//Chaîne de caractères initiale à compléter ou à tronquer.
//Cette chaîne de caractères n'est pas modifiée.

<Taille> // Entier, nouvelle taille de la chaîne de caractères (supérieure ou égale à 0).

<Caractère> // Caractère, caractère utilisé pour compléter la chaîne.
//Par défaut, ce caractère correspond à un espace.

Notes

-Divers
//Si le paramètre <Taille> est inférieur à 0, une erreur du W-Langage est générée.
//Par convention, le premier indice d'une chaîne de caractères est 1.


CompleteRep

Nouvelle page
Saisissez ici le texte de la page


Confirmer

Utilisation

//Affiche un message dans une boîte de dialogue standard proposant les réponses "Oui", "Non","Annuler" et renvoie la réponse de l'utilisateur.

//Pour fermer la fenêtre, l'utilisateur doit valider un des boutons.

Résultat est un entier
Résultat = Confirmer("Modifications non enregistrées.","Voulez-vous sauvegarder ?")
SI Résultat = Oui ALORS
SauveFiche() // Traitement de sauvegarde
SINON
SI Résultat = Annuler ALORS
RepriseSaisie() // Choix Annuler
SINON // Résultat = Non
Ferme() // Sortie de la fenêtre
FIN
FIN

Syntaxe

<Résultat> = Confirmer([<Bouton sélectionné>], <Texte> [, <Ligne 2> ... [, <Ligne n>]])

-Détail des paramètres

<Résultat> // Constante de type entier, identifie le bouton sélectionné par l'utilisateur :
Non //0, l'utilisateur a choisi le bouton [NON]
Oui //1, l'utilisateur a choisi le bouton [OUI]
Annuler //2, l'utilisateur a choisi le bouton [ANNULER]
<Bouton sélectionné> // Constante optionnelle de type entier

//Bouton sélectionné par défaut dans la boîte de dialogue :
Non //0, bouton [NON] sélectionné par défaut
Oui //(par défaut), 1, bouton [OUI] sélectionné par défaut
Annuler //2, bouton [ANNULER] sélectionné par défaut

<Texte> // Chaîne de caractères, texte à afficher.

<Ligne 2> ... <Ligne n> // Chaînes de caractères optionnelles, texte affiché sur les lignes suivantes.

Notes

-Caractéristiques de la boîte de dialogue
//Le titre de la boîte de dialogue correspond au titre de la fenêtre en cours.
//Le message est cadré à gauche.
//Les libellés des boutons dépendent de la langue d'exécution de Windows.
//Le nombre maximum de caractères affichés est limité à 4096.
//Si une chaîne plus grande est passée en paramètre, elle sera tronquée.
//L'icone affiché (point d'exclamation) ne peut pas être modifié.

-Saut de lignes dans la boîte de dialogue
//La chaîne pré-définie RC (Retour Chariot) peut être utilisée pour forcer le passage à la ligne suivante.
//Par exemple :
Confirmer("La fiche XXX a été modifiée." + RC +...
"Voulez-vous la sauver avant de quitter ?")
//est équivalent à :
Confirmere XXX a été modifiée.",...
"Voulez-vous la sauver avant de quitter ?")


DateDifférence

Nouvelle page
Saisissez ici le texte de la page


DateDuJour

Nouvelle page
Saisissez ici le texte de la page


DateHeureDifférence

Nouvelle page
Saisissez ici le texte de la page


DateHeureParDéfaut

Nouvelle page
Saisissez ici le texte de la page


DateSys

Nouvelle page
Saisissez ici le texte de la page


DateValide

Nouvelle page
Saisissez ici le texte de la page


DateVersChaine

Nouvelle page
Saisissez ici le texte de la page


DateVersEntier

Nouvelle page
Saisissez ici le texte de la page


DateVersJour

Nouvelle page
Saisissez ici le texte de la page


DateVersJourEnLettre

Nouvelle page
Saisissez ici le texte de la page


DateVersMoisEnLettre

Nouvelle page
Saisissez ici le texte de la page


DateVersNuméroDeSemaine

Nouvelle page
Saisissez ici le texte de la page


Décrypte

Nouvelle page
Saisissez ici le texte de la page


Cosinus

Utilisation

//Calcule le cosinus d'un angle.

// Calcul du cosinus de 60
ResCosinus = Cosinus(60)
// Renvoie 0.5

Syntaxe

<Résultat> = Cosinus(<Angle>)

-Détail des paramètres

<Résultat> // Réel, Cosinus de l'angle spécifié.
<Angle> // Entier ou réel, Angle (en degrés) à manipuler.
//Ce paramètre peut avoir une valeur quelconque : le calcul du cosinus est effectué "modulo 360".


Cotang

Utilisation

//Calcule la co-tangente d'un angle.

// Calcul de la co-tangente de 20
ResCoTangente = CoTang(20)
// Renvoie 2.74747741945

Syntaxe

<Résultat> = CoTang(<Angle>)

-Détail des paramètres

<Résultat> // Réel, co-tangente de l'angle spécifié.

<Angle> // Entier ou réel, angle (en degrés) à manipuler.
//Si ce paramètre est égal à 0°, 180° ou -180°, une erreur du W-Langage est générée.


Dimension

Exemple

Utilisation

//Renvoie la taille d'une variable (chaîne, numérique, tableau, ...) ou re-dimensionne un tableau dynamique.

-Re-dimensionner un tableau dynamique
MonTab est un tableau dynamique de 5 par 3 entiers
...
-Re-dimensionner le tableau
Dimension(MonTab, 8, 6)

Syntaxe

//Récupérer la taille d'une variable
<Résultat> = Dimension(<Nom de la variable>)

-Détail du paramètre
<Résultat> // Entier, Taille recherchée.

-Selon les types de la variable

-chaîne Pascal
Ch est une chaîne Pascal sur 10
Aresult(Dimension(Ch)) // 10, Nombre de caractères utiles de la chaîne

-chaîne ASCIIZ
Ch est une chaîne ASCIIZ sur 10
Aresult(Dimension(Ch)) // 9 car 0 binaire à la fin, Nombre de caractères utiles de la chaîne

-Variable composée
//Somme des tailles en octets de chaque composante

-tableau
Tab1 est un tableau de 3 chaînes
Aresult(Dimension(Tab1)) // Affiche 3
Tab2 est un tableau de 5 par 3 entiers
Aresult(Dimension(Tab1)) // Affiche 15 = 5 * 3, Nombre d'éléments total du tableau

-Autres
//Taille en octets

<Nom de la variable> // chaîne de caractères, Nom de la variable (variable de type quelconque).

Re-dimensionner un tableau dynamique

Dimension(<Nom du tableau>, <Dimension 1>, ..., <Dimension N>)

-Détail des paramètres

<Nom du tableau> // Chaîne de caractères, Variable correspondant au tableau dynamique.
<Dimension 1> ... <Dimension N> // Entier, Nouvelles dimensions du tableau. Attention : le nombre de dimensions du tableau ne peut pas être modifié, ni le type des éléments. Un tableau à 2 dimensions reste à 2 dimensions.


DonneIdentifiant

Utilisation

//Calcule un identifiant unique de type entier pour un exécutable donné. Ces données ne sont pas mémorisées : elles sont perdues dès la fin de l'exécution de l'application.

// Obtenir un numéro d'ordre
i = DonneIdentifiant()

Syntaxe

<Résultat> = DonneIdentifiant()

-Détail des paramètres
<Résultat> // Entier, identifiant.
// Le premier appel à la fonction DonneIdentifiant renvoie 1, le second 2, etc.


Droite

Utilisation

//Extrait la partie droite d'une chaîne de caractères (c'est-à-dire les derniers caractères).

Droite("Le coucou", 6) // Renvoie "coucou"
Droite("ABC", 50) // Renvoie "ABC"
Droite(" AZELMA") // Renvoie "AZELMA"

Syntaxe

<Résultat> = Droite(<chaîne source> [, <Longueur>])

-Détail des paramètres

<Résultat> // chaîne de caractères, partie Droite spécifiée de <chaîne source>.
//Correspond à <chaîne source> si le paramètre <Longueur> est supérieur à la taille de <chaîne source>.

//EOT si le paramètre <Longueur> est négatif.
//Une erreur du W-Langage est générée (erreur non fatale).
//Pour plus de détails sur l'erreur, utilisez la fonction ErreurInfo.

<chaîne source> // chaîne de caractères, chaîne de caractères dont il faut extraire la partie Droite. Cette chaîne n'est pas modifiée.

<Longueur> // entier optionnel, Nombre de caractères à extraire.
//Si ce paramètre n'est pas précisé, <Résultat> correspond à <Chaîne Source> sans les espaces à gauche.


DuréeVersChaine

Nouvelle page
Saisissez ici le texte de la page


eChangeDevise

Nouvelle page
Saisissez ici le texte de la page


eInitDevise

Nouvelle page
Saisissez ici le texte de la page


eNomDevise

Nouvelle page
Saisissez ici le texte de la page


EntierVersDate

Nouvelle page
Saisissez ici le texte de la page


EntierVersHeure

Nouvelle page
Saisissez ici le texte de la page


EntierVersJour

Nouvelle page
Saisissez ici le texte de la page


EntierVersJourEnLettre

Nouvelle page
Saisissez ici le texte de la page


EntierVersMoisEnLettre

Nouvelle page
Saisissez ici le texte de la page


EntierVersNuméroDeSemaine

Nouvelle page
Saisissez ici le texte de la page


Erreur

Utilisation

//Affiche un message d'erreur personnalisé dans une fenêtre d'erreur système.
//Pour fermer la fenêtre, l'utilisateur doit valider le bouton OK.

Erreur("Ce code client n'existe pas : vous devez le créer")

Syntaxe

Erreur(<Texte> [, <Ligne 2> ... [, <Ligne n>]])

-Détail des paramètres

<Texte> // Chaîne de caractères, Texte à afficher.
<Ligne 2> ... <Ligne n> // Chaînes de caractères optionnelles, Texte affiché sur les lignes suivantes.

Notes

-Caractéristiques de la boîte de dialogue
//Le message est cadré à gauche.
//Le libellé du bouton dépend de la langue d'exécution de Windows.
//Le nombre maximum de caractères affichés est limité à 4096. Si une chaîne plus grande est passée en paramètre, elle sera tronquée.
//L'icone affiché (croix blanche) ne peut pas être modifié.

//La chaîne pré-définie RC (Retour Chariot) peut être utilisée pour forcer le passage à la ligne suivante. Par exemple :

Erreur("La fiche XXX a été modifiée." + RC +"Voulez-vous la sauver avant de quitter ?")
//est équivalent à :
Erreur("La fiche XXX a été modifiée.","Voulez-vous la sauver avant de quitter ?")


ErreurDétectée

Utilisation

//ErreurDétectée est une variable pré-définie du W-Langage indiquant le résultat de la dernière fonction W-Langage utilisée.
//ErreurDétectée correspond à :
Faux //si la dernière fonction W-Langage utilisée a réussi.
Vrai //si la dernière fonction W-Langage utilisée a provoqué une erreur non fatale.

-Remarque
//Des informations concernant l'erreur rencontrée peuvent être récupérées grâce aux fonctions ErreurInfo ou HErreurInfo.

nFichier est un entier
nFichier = fOuvre("C:\MesRépertoires\Fichier.txt", foLectureEcriture)
SI nFichier <> -1 ET ErreurDétectée=Faux ALORS
...
SINON
Erreur(ErreurInfo())
FIN

Notes

-Erreur fatale
//Pour gérer les erreurs fatales, utilisez QUAND EXCEPTION.
//Les erreurs fatales non-gérées provoquent l'arrêt immédiat de l'application. Un message d'erreur est automatiquement affiché. Ce message peut être paramétré lors de la création de l'exécutable (option "Projet .. Créer l'exécutable").


ErreurInfo

Utilisation

//Récupère des informations sur la dernière erreur d'une fonction d'une composante de WinDev.

-Attention :
//La fonction ErreurInfo doit être utilisée immédiatement après l'appel à la fonction qui a échoué. En effet, l'appel à une autre fonction du W-Langage peut ré-initialiser et modifier le compte-rendu de ErreurInfo.

// Ouverture du fichier de présentation
nIdFichier est un entier = fOuvre(NomFichier, foLecture)
// Vérification de l'ouverture du fichier
SI nIdFichier = -1 ALORS
Aresult("Impossible d'ouvrir le fichier : " + NomFichier, ErreurInfo())
RENVOYER Faux
FIN

Syntaxe

<Résultat> = ErreurInfo([<Type information>])

-Détail des paramètres

<Résultat> // Chaîne de caractères ou entier, information demandée.
//Une chaîne vide si aucune erreur n'est survenue ou si l'information demandée n'est pas disponible.

<Type information> // Constante, information à renvoyer.

errCode //Code de l'erreur
errComplet //Toutes les informations de l'erreur (ligne de l'erreur, traitement en cours, ...)
errMessage //(valeur par défaut), Message complet de l'erreur
errRésumé //Résumé de l'erreur
errInfo //Informations complémentaires
errInfoDebug //Informations spécifiques au débogage du problème rencontré.
//Ces informations ne doivent être affichées et communiquées qu'en cas de demande expresse de PC SOFT.
//Dans le cas de l'exécution d'une requête par OLE DB, cette option permet de récupérer le code de la requête SQL réellement exécutée sur la base de données.
errPendant //Nom de la fonction W-Langage qui a provoqué l'erreur
errElément //Nom de l'objet associé au traitement en cours lors de l'erreur
errTraitement //Nom du traitement en cours lors de l'erreur
errLigne //Numéro de la ligne de l'erreur
errFichier //Nom logique du fichier associé à l'erreur
errNumEnr //Numéro de l'enregistrement associé à l'erreur
errRubrique //Nom de la rubrique associée à l'erreur
errWDD //Nom complet du WDD associé à l'erreur
errFIC //Nom complet du fichier de données (.FIC) associé à l'erreur
errNDX //Nom complet du fichier d'index (.NDX) associé à l'erreur
errMMO //Nom complet du fichier mémo (MMO) associé à l'erreur
errLiaison //Nom de la liaison associée à l'erreur
errCodeSystème //Numéro de l'erreur système (si elle existe)
ème //Message d'erreur système (si elle existe)


EstImpair

Utilisation

//Identifie un nombre impair.

// Nombre impair ?
ResImpair = EstImpair(65) // Renvoie Vrai
ResImpair = EstImpair(5 + 11) // Renvoie Faux

Syntaxe

<Résultat> = EstImpair(<Nombre>)

-Détail des paramètres

<Résultat> // Booléen, Vrai si le nombre spécifié est impair, Faux dans le cas contraire.
<Nombre> // Expression numérique entière ou entier, Expression numérique entière ou entier à identifier.


EstPair

Utilisation

//Identifie un nombre pair.

// Nombre pair ?
ResPair = EstPair(66) // Renvoie Vrai
ResPair = EstPair(6 + 13) // Renvoie Faux

Syntaxe

<Résultat> = EstPair(<Nombre>)

-Détail des paramètres

<Résultat> // Booléen, Vrai si le nombre spécifié est pair, Faux dans le cas contraire.
<Nombre> // Expression numérique entière ou entier, Expression numérique entière ou entier à identifier.

Notes

-Chiffre zéro
//Le chiffre zéro est considéré comme étant un chiffre pair.


eTauxDeChange

Nouvelle page
Saisissez ici le texte de la page


ETBinaire

Utilisation

//Renvoie le résultat du ET logique (bit à bit) entre deux valeurs.

// Récupération du ET logique
ResETBinaire = ETBinaire(6, 6) // Renvoie 6
ResETBinaire = ETBinaire(6, 2) // Renvoie 2

Syntaxe

<Résultat> = ETBinaire(<Valeur 1>, <Valeur 2>)

-Détail des paramètres

<Résultat> // Entier, Résultat du ET logique.
<Valeur 1> // Entier, Première valeur à tester.
<Valeur 2> // Entier, Seconde valeur à tester.

Notes

-Calcul bit à bit
//ETBinaire effectue le calcul bit à bit entre <Valeur1> et <Valeur2> selon la table suivante :

0 1
0 0 0
1 0 0


eVersDevise

Nouvelle page
Saisissez ici le texte de la page


eVersEuro

Nouvelle page
Saisissez ici le texte de la page


Exp

Utilisation

//Calcule l'exponentielle (inverse du logarithme népérien) d'une valeur numérique.

// Calcul de l'exponentielle de 5
ResExponentielle = Exp(5)
// Renvoie 148.413159103

Syntaxe

<Résultat> = Exp(<Valeur numérique>)

-Détail des paramètres

<Résultat> // Réel, Exponentielle recherchée.
<Nombre> // Entier ou réel, Valeur numérique à manipuler.


ExtraitChaîne

Utilisation

//Extrait une sous-chaîne d'une chaîne de caractères en fonction d'un séparateur de chaîne donné.

-Quelques exemples d'utilisation :
//extraire une donnée lue dans un fichier externe,
//extraire les informations retournées par HListeFichier ou HListeClé,
//extraire une donnée d'une liste comportant des données différentes sur une même ligne.

Ch est une chaîne = "ABC" + TAB + "" + TAB + "" + TAB + "DEF"
ExtraitChaîne(Ch, 1) // Renvoie "ABC"
ExtraitChaîne(Ch, 2) // Renvoie ""
ExtraitChaîne(Ch, 3) // Renvoie ""
ExtraitChaîne(Ch, 4) // Renvoie "DEF"
ExtraitChaîne(Ch, 5) // Renvoie EOT

Syntaxe

<Résultat> = ExtraitChaîne(<chaîne initiale>, <Rang> [, <Séparateur> [<Sens de parcours>]])

-Détail des paramètres

<Résultat> // Chaîne de caractères, Correspond à :
//La sous-chaîne comprise entre le séparateur de rang <Rang> - 1 et le séparateur de rang <Rang> si <Sens de parcours> n'est pas précisé ou est égal à DepuisDébut.
//La sous-chaîne comprise entre le séparateur de rang <Rang> - 1 et le séparateur de rang <Rang> à partir de la fin de la chaîne si <Sens de parcours> correspond à DepuisFin.
//La <Chaîne initiale> en totalité si la <Chaîne initiale> ne contient pas de <Séparateur> et si <Rang> est égal à 1.
//La constante EOT si <Rang > est plus grand que le nombre de séparateurs contenus dans la chaîne.
<chaîne Initiale> // Chaîne de caractères, Chaîne de caractères (taille maximale : 2 Go) contenant la chaîne à extraire.
<Rang> // Entier, Numéro d'ordre du séparateur. Par exemple, si le séparateur est TAB et si <Rang> est égal à 2, la chaîne extraite sera comprise entre le premier et le second TAB.
<Séparateur> // Chaîne de caractères, Chaîne permettant de délimiter les sous-chaînes. Si ce séparateur n'est pas précisé, le séparateur par défaut est TAB. Cette chaîne n'est pas incluse dans le résultat.
<Sens de parcours> // Constante optionnelle, Sens du parcours de la recherche :
DepuisDébut //(par défaut), Recherche effectuée du premier caractère de la chaîne vers le dernier
DepuisFin //Recherche effectuée du dernier caractère de la chaîne vers le premier


fBloque

Nouvelle page
Saisissez ici le texte de la page


fChargeTexte

Nouvelle page
Saisissez ici le texte de la page


fCheminCourt

Nouvelle page
Saisissez ici le texte de la page


fCheminLong

Nouvelle page
Saisissez ici le texte de la page


fCopieFichier

Nouvelle page
Saisissez ici le texte de la page


fCrée

Nouvelle page
Saisissez ici le texte de la page


fDate

Nouvelle page
Saisissez ici le texte de la page


fDébloque

Nouvelle page
Saisissez ici le texte de la page


fEcrit

Nouvelle page
Saisissez ici le texte de la page


fEcritLigne

Nouvelle page
Saisissez ici le texte de la page


fExtraitChemin

Nouvelle page
Saisissez ici le texte de la page


fFerme

Nouvelle page
Saisissez ici le texte de la page


fFichierTemp

Nouvelle page
Saisissez ici le texte de la page


fHeure

Nouvelle page
Saisissez ici le texte de la page


FinAmortissement

Exemple

Utilisation

//Crée une matrice d'amortissement pour le montant d'un emprunt à un taux d'intérêt constant pour une durée définie.
// Matrice d'amortissement pour un emprunt de type "In Fine" de 25 000 F
// à un taux d'intérêt constant de 5% sur une durée de 6 ans
ResAmortissement = FinAmortissement("MatriceAmort", finInFine, 25000, 5, 6)

Syntaxe

<Résultat> = FinAmortissement(<Nom de la matrice>, <Type d'amortissement> [,<Capital> [,<Taux> [,<Durée>]]])

-Détail des paramètres

<Résultat> // Booléen,
Vrai // si la matrice d'amortissement a été créée,
Faux // dans le cas contraire.

<Nom de la matrice> // Chaîne de caractères, Nom de la matrice d'amortissement.
//Cette matrice est automatiquement créée lors du calcul de l'amortissement.
//Cette matrice est composée de 5 colonnes.
//Chaque colonne correspond à une information particulière :

// Numéro de colonne, contenu
// 1, Année
// 2, Reste à rembourser
// 3, Intérêt
// 4, Amortissement
// 5, Annuités

<Type d'amortissement> // Constante, Indique le type d'amortissement :

finInFine //Remboursement "In Fine" : Pendant toute la durée de l'emprunt, l'emprunteur verse uniquement les intérêts dus, le principal étant remboursé la dernière année.

finAmortissementConstant //Amortissement constant : Chaque année, la valeur de l'amortissement réalisé est fixe; les autres paramètres sont calculés en conséquence.

finAnnuitéConstante //Annuité constante : Chaque année, l'emprunteur verse au prêteur la même somme, incluant le principal et l'intérêt.

<Capital> // Réel ou monétaire optionnel, Capital total emprunté.

<Taux> // Réel optionnel, Taux d'intérêt de l'emprunt exprimé en pourcentage (1 par défaut). Par exemple, pour un taux d'emprunt de 5%, ce paramètre sera égal à 5.

<Durée> // Réel optionnel, Durée du remboursement de l'emprunt exprimée en années (1 par défaut).

Notes

-Matrice d'amortissement
//L'existence de la matrice n'est pas vérifiée. Si la matrice existait auparavant, cette matrice est écrasée. Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Le contenu de la matrice peut ensuite être lu grâce aux fonctions suivantes :

MatLit // Lit la valeur d'un élément d'une matrice.
MatLitColonnela valeur de tous les éléments d'une colonne d'une matrice.
MatLitLigne // Lit la valeur de tous les éléments d'une ligne d'une matrice.

Gestion des erreurs

//La fonction FinAmortissement retourne Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


FinAmortissementDégressif

Exemple

Utilisation

//Calcule la valeur de l'amortissement d'un bien pour une période spécifique, grâce à la formule de l'amortissement décroissant à taux fixe.

// Valeur d'amortissement d'un bien acheté 25 000 F dont la valeur
// résiduelle sera de 15 000 F après une durée de 6 ans.
ResAmortissement = FinAmortissementDégressif(25000, 15000, 6)

Syntaxe

<Résultat> = FinAmortissementDégressif(<Coût d'acquisition>, <ValeurRésiduelle>, <Durée> [,<Période> [,<Nombre de mois (année 1)>]])

-Détail des paramètres

<Résultat> // Réel ou monétaire, Valeur de l'amortissement pour la <Période> donnée ou 0 si l'amortissement est nul.
<Coût d'acquisition> // Réel ou monétaire, Coût d'acquisition du bien. Ce coût ne peut pas être nul.
<Valeur résiduelle> // Réel ou monétaire, Valeur résiduelle du bien au terme de la durée d'amortissement.
<Durée> // Réel, Nombre de périodes durant lesquelles le bien est amorti. Cette durée ne peut pas être nulle.
<Période> // Entier optionnel, Période pour laquelle l'amortissement doit être calculé (1 par défaut).
<Nombre de mois (année 1)> // Entier optionnel, Nombre de mois de la première année d'amortissement (1 par défaut). Ce nombre doit être compris entre 0 et 12.

Notes

-Amortissement à taux fixe
//La méthode de l'amortissement à taux fixe consiste à calculer l'amortissement d'un bien à l'aide d'un taux constant sur les différentes périodes d'amortissement.
//Ce taux est appliqué pour chaque période à la valeur actuelle du bien. La valeur actuelle du bien correspond à :
<Coût d'acquisition> - <Total amortissement>
//où
<Total amortissement> //représente les amortissements cumulés des périodes précédentes.

//Ce taux est calculé en fonction de la valeur résiduelle, du coût d'acquisition du bien et de la durée de l'amortissement.
//Le calcul de la valeur de l'amortissement pour la première année comme celui pour la dernière année est spécifique :
//pour la première année, seul le nombre de mois amortis est pris en compte (<Nombre de mois (année 1)>);
//pour la dernière année, le nombre de mois amortis correspond à :
//12 - <Nombre de mois (année 1)>.

-Remarque :
//Si le nombre de mois de la première année est égal à 12, cette année est comprise dans la durée.

-Gestion des erreurs
//Attention : La fonction FinAmortissementDégressif ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction WINDEV_RTFLIENDEBrreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


FinAmortissementLinéaire

Exemple

Utilisation

//Calcule la valeur de l'amortissement linéaire d'un bien pour une période donnée.

// Valeur d'amortissement d'un bien acheté 25 000 F dont la
// valeur résiduelle sera de 15 000 F après une durée de 6 ans.
ResAmortissement = FinAmortissementLinéaire(25000, 15000, 6)

Syntaxe

<Résultat> = FinAmortissementLinéaire(<Coût d'acquisition>, <ValeurRésiduelle>, <Durée>)

-Détail des paramètres

<Résultat> // Réel ou monétaire, Valeur de l'amortissement ou 0 si l'amortissement est nul.
<Coût d'acquisition> // Réel ou monétaire, Coût d'acquisition du bien. Ce coût ne peut pas être nul.
<Valeur résiduelle> // Réel ou monétaire, Valeur résiduelle du bien au terme de la durée d'amortissement.
<Durée> // Réel, Nombre de périodes durant lesquelles le bien est amorti. Cette durée ne peut pas être nulle.

Notes

-Amortissement linéaire
//Lors d'un amortissement linéaire, la valeur de l'amortissement est la même pour chaque période d'amortissement du bien.

-Gestion des erreurs
//Attention : La fonction FinAmortissementLinéaire ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction FinErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


FinErreur

Exemple

Utilisation

//Renvoie le numéro de la dernière erreur due à une fonction Finxxx (fonctions financières).
// Identification du type d'erreur
ResErreur = FinErreur()

Syntaxe

<Résultat> = FinErreur()

-Détail du paramètre

<Résultat> // Entier, Numéro de la dernière erreur due à une fonction financière :

-Numéro, type d'erreur, fonctions concernées
//0, pas d'erreur : toutes les fonctions
//1, la durée ne peut pas être nulle : FinAmortissementDégressif, FinAmortissementLinéaire
//2, la matrice est vide : FinValActuelleNette
//3, le taux ne peut pas être nul : FinValActuelle, FinValFuture
//4, la période ne peut pas être plus grande que la durée : FinIntérêtPériode
//5, le type d'amortissement n'est pas correct : FinAmortissement
//6, la somme de remboursement est nulle : FinNbVersement
//7, incohérence dans les données : FinTauxIntérêt, FinNbVersement
//8, le coût d'acquisition ne peut pas être nul : FinAmortissementDégressif, FinAmortissementLinéaire
//9, la matrice n'existe pas : FinValActuelleNette
//10, valeurs maximales dépassées : Toutes les fonctions
//11, calcul impossible (division par zéro) : FinAmortissement, FinIntérêtPériode, FinValActuelle, FinValActuelleNette, FinValRemboursement
//12, nombre de remboursements infini : FinNbVersement
//13, le taux n'a pas été trouvé : FinTauxIntérêt
//14, la période est supérieure à la durée : FinAmortissementDégressif
//15, nombre de mois de la première année non compris entre 0 et 12 : FinAmortissementDégressif

Notes

-Libellé de l'erreur
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la consta


FinIntérêtPériode

Exemple

Utilisation

//Évalue pour une période donnée le montant des intérêts dus pour un emprunt remboursé par versements périodiques constants avec un taux d'intérêt constant.

// Montant des intérêts dus pour la deuxième année d'un emprunt.
// Cet emprunt est de 25 000 F avec un taux d'intérêt de 5% sur 6 ans.
ResIntérêtPériode = FinIntérêtPériode(25000, 5, 2, 6)

Syntaxe

<Résultat> = FinIntérêtPériode([<Capital> [,<Taux> [,<Période> [,<Durée>]]]])

-Détail des paramètres

<Résultat> // Réel ou monétaire, Montant des intérêts recherchés. Ce montant peut être :
//négatif : un paiement (ou décaissement) doit alors être effectué;
//positif : un encaissement doit alors être effectué.

<Capital> // Réel ou monétaire optionnel, Montant de l'emprunt (0 par défaut).

<Taux> // Réel optionnel, Taux d'emprunt exprimé en pourcentage (1 par défaut). Par exemple, pour un taux d'emprunt de 5%, ce paramètre sera égal à 5.

<Période> // Entier optionnel, Période pour laquelle le montant des intérêts doit être calculé (1 par défaut).

<Durée> // Réel optionnel, Nombre de périodes de l'emprunt (1 par défaut).

Notes

-Unité temporelle
//Les calculs peuvent être réalisés en prenant en compte des mois ou des années.
//Il suffit que les paramètres <Taux>, <Durée> et <Période> correspondent à la même unité temporelle.
//Ainsi, pour obtenir le montant des intérêts dus au cinquième mois d'un emprunt de 3 ans,
//avec un taux d'intérêt annuel de 5%, il est possible d'utiliser :
//soit des unités exprimées en mois (pour un remboursement mensuel par exemple) :
<Durée> = 3 x 12 mois = 36
<Période> = 5
<Taux> = 5% / 12

//soit des unités exprimées en années (pour un remboursement annuel par exemple) :
<Durée> = 3 ans
<Période> = 5/36
<Taux> = 5%

-Gestion des erreurs
//Attention : La fonction FinIntérêtPériode ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction FinErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


FinNbVersement

Exemple

Utilisation

//Renvoie le nombre de versements nécessaires pour rembourser un capital selon un taux.

// Nombre de versements nécessaires : le montant des versements est de 7 500 F,
// le taux d'intérêt est de 5% et le montant emprunté est de 42 000 F.
ResNbVersement = FinNbVersement(-7500, 5, 42000)

Syntaxe

<Résultat> = FinNbVersement([<Valeur d'un versement> [,<Taux> [,<Capital>]]])

-Détail des paramètres

<Résultat> // Réel, Nombre de versements à réaliser. Ce nombre peut être :
//négatif : un paiement (ou décaissement) doit alors être effectué;
//positif : un encaissement doit alors être effectué.

<Valeur d'un versement> // Réel ou monétaire optionnel, Valeur d'un versement (0 par défaut).
//Pour un remboursement, cette valeur doit être négative.

<Taux> // Réel optionnel, Taux d'emprunt exprimé en pourcentage (1 par défaut).
//Par exemple, pour un taux d'emprunt de 5%, ce paramètre sera égal à 5.

<Capital> // Réel ou monétaire optionnel, Montant de l'emprunt (1 par défaut).

Notes

-Gestion des erreurs
//Attention : La fonction FinNbVersement ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction FinErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


FinTauxIntérêt

Exemple

Utilisation

//Évalue le taux d'intérêt pour un emprunt donné sur une période avec des versements constants.
//Remarque : Le taux d'intérêt obtenu est supposé constant sur la période.

//Taux d'intérêt pour un emprunt de 25 000 F.
//Six versements de 5 000 F sont nécessaires au remboursement de l'emprunt.

ResTauxIntérêt = FinTauxIntérêt(6, -5000, 25000)

Syntaxe

<Résultat> = FinTauxIntérêt(<Nombre de remboursements nécessaires> [,<Valeur d'un remboursement> [,<Capital>]])

-Détail des paramètres

<Résultat> // Réel ou monétaire, Taux d'intérêt recherché.
<Nombre de remboursements nécessaires> // Réel ou monétaire, Nombre total de remboursements à effectuer.
<Valeur d'un remboursement> // Réel optionnel, Valeur d'un remboursement (0 par défaut). Cette valeur doit être négative.
<Capital> // Réel ou monétaire optionnel, Montant de l'emprunt (1 par défaut).

Notes

-Gestion des erreurs
//Attention : La fonction FinTauxIntérêt ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction FinErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


FinValActuelle

Exemple

Utilisation

//Renvoie la valeur actuelle d'un investissement.
//Rappel : La valeur actuelle correspond à la somme que représente aujourd'hui un ensemble de remboursements futurs.
//Par exemple, lorsque vous faites un emprunt, le montant de l'emprunt représente la valeur actuelle pour le prêteur.

// Valeur actuelle d'un investissement. La valeur de remboursement est de 5 000 F.
// Cet investissement doit rapporter 50 000 F par an pendant 10 ans.
// Le taux d'intérêt est de 8%.
ResValActuelle = FinValActuelle(-5000, 50000, 10, 8)

Syntaxe

<Résultat> = FinValActuelle([<Valeur d'un remboursement> [,<Valeur future> [,<Nombre de périodes> [,<Taux> [,<Début>]]]]])

-Détail des paramètres

<Résultat> // Réel ou monétaire, Valeur actuelle de l'investissement.

<Valeur d'un remboursement> // Réel ou monétaire optionnel, Valeur du remboursement pour chaque période (0 par défaut).
//Ce remboursement est identique pour toute la durée de l'opération. Cette valeur doit être négative.

<Valeur future> // Réel ou monétaire optionnel, Valeur future (valeur capitalisée).
//Il s'agit du montant après le dernier paiement (0 par défaut).

<Nombre de périodes> // Entier optionnel, Nombre total de périodes de l'investissement (1 par défaut).

<Taux> // Réel optionnel, Taux d'intérêt de l'investissement exprimé en pourcentage (1 par défaut).
//Par exemple, pour un taux d'investissement de 5%, ce paramètre sera égal à 5. Ce taux ne peut pas être nul.

<Début> // Booléen optionnel,
Vrai //si les paiements doivent être effectués en début de période (valeur par défaut),
Faux //si les paiements doivent être effectués en fin de période.

Notes

-Unité temporelle
//Les calculs peuvent être réalisés en prenant en compte des mois ou des années.
//Il suffit que les paramètres <Taux> et <Période> correspondent à la même unité temporelle.
//Ainsi, pour obtenir la valeur actuelle d'un emprunt sur 4 ans, remboursable mensuellement,
//avec un taux d'intérêt annuel de 10%, il est possible d'utiliser des unités exprimées en mois :
<Période> = 4*12
<Taux> = 10% / 12

-Gestion des erreurs
//Attention : La fonction FinValActuelle ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction FinErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction _RTFLIENFIN001001 avec la constante errMessage.


FinValActuelleNette

Exemple

Utilisation

//Renvoie la valeur actuelle nette d'un investissement. Cet investissement est basé sur des flux financiers non constants.
//Rappel : La valeur actuelle nette correspond à la valeur à la date du jour d'une série de décaissements (valeurs négatives) et d'encaissements (valeurs positives) futurs.

-Remarque : D'un point de vue financier, un investissement sera estimé rentable si sa VAN (Valeur Actuelle Nette) est positive.

// Valeur actuelle nette d'un investissement. Le taux d'intérêt est de 8%.
Res = FinValActuelleNette(8, "Matrice")

Syntaxe

<Résultat> = FinValActuelleNette(<Taux>, <Nom de la matrice> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]])

-Détail des paramètres

<Résultat> // Réel ou monétaire, Valeur actuelle nette de l'investissement.

<Taux> // Réel, Taux d'intérêt de l'investissement exprimé en pourcentage (1 par défaut).
//Par exemple, pour un taux d'investissement de 5%, ce paramètre sera égal à 5. Ce taux ne peut pas être nul.

<Nom de la matrice> // Chaîne de caractères optionnelle, Nom de la matrice (défini avec la fonction MatCrée) contenant les encaissements et les décaissements entraînés par l'investissement.

<Numéro de la ligne/colonne> // Entier optionnel, Numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel,
Vrai //(par défaut) si la série de valeurs correspond à une colonne de matrice,
Faux //si la série de valeurs correspond à une ligne de matrice.

Notes

-Élément de la matrice
//La ligne ou la colonne de matrice analysée par la fonction FinValActuelleNette doit être composée des éléments suivants :

//Numéro de ligne/colonne, Contenu
//1, montant investi (décaissé) : négatif
//2, revenu de l'année 1 : encaissée ou décaissé
//3, revenu de l'année 2 : encaissée ou décaissé
//.....
//N-1, revenu de l'année N-2 : encaissée ou décaissé
//N, revenu de l'année N-1 : encaissée ou décaissé

-Gestion des erreurs
//Attention : La fonction FinValActuelleNette ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction FinErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


FinValFuture

Exemple

Utilisation

//Renvoie la valeur future d'un investissement.
//Les remboursements sont périodiques et constants.
//Le taux d'intérêt est constant.

// Valeur future d'un investissement. Le capital initial est 100 000 F.
// 3 000 F sont versés chaque mois pendant 2 ans. Le taux d'intérêt est de 8%.
ResValFuture = FinValFuture(-100000, -3000, 24, 8)

Syntaxe

<Résultat> = FinValFuture([<Capital initial> [,<Dépôt périodique> [,<Nombre de périodes> [,<Taux> [,<Début>]]]]])

-Détail des paramètres

<Résultat> // Réel ou monétaire, Valeur future de l'investissement.

<Capital initial> // Réel ou monétaire optionnel, Capital initial (0 par défaut).

<Dépôt périodique> // Réel ou monétaire optionnel, Dépôt périodique (0 par défaut).
//Cette valeur est fixe pendant toute la durée de l'opération.
//En principe, ce montant comprend le capital et les intérêts.

<Nombre de périodes> // Entier optionnel, Nombre total de périodes pour l'opération (1 par défaut).

<Taux> // Réel optionnel, Taux d'intérêt de l'investissement exprimé en pourcentage (1 par défaut).
//Par exemple, pour un taux d'investissement de 5%, ce paramètre sera égal à 5. Ce taux ne peut pas être nul.

<Début> // Booléen optionnel,
Vrai //si les paiements doivent être effectués en début de période (valeur par défaut),
Faux //si les paiements doivent être effectués en fin de période.

Notes

-Unité temporelle
//Les calculs peuvent être réalisés en prenant en compte des mois ou des années.
//Il suffit que les paramètres <Taux> et <Période> correspondent à la même unité temporelle.

//Ainsi, pour des remboursements mensuels d'un emprunt sur durée de cinq ans au taux d'intérêt annuel de 8%, utilisez :
<Taux> = 8% / 12,
<Nombre de périodes> = 5*12

//Si, pour le même emprunt, vos remboursements sont annuels, utilisez :
<Taux> = 8%,
<Nombre de périodes> = 5

//Pour tous les paramètres, les décaissements sont représentés par un nombre négatif alors que les encaissements sont représentés par un nombre positif.

-Gestion des erreurs
//Attention : La fonction FinValFuture ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction FinErreur.
//Le libellé de l'erreur peut être à la fonction ErreurInfo avec la constante errMessage.


FinValRemboursement

Exemple

Utilisation

//Renvoie le montant de chaque remboursement périodique pour un investissement à remboursement et à taux d'intérêt constants.
//Remarque : La valeur renvoyée par FinValRemboursement comprend le remboursement principal et les intérêts.

// Montant des remboursements périodiques. Le capital initial est 100 000 F.
// Les remboursement sont effectués chaque mois pendant 2 ans.
// Le taux d'intérêt est de 8%.
Res = FinValRemboursement(100000, 24, 8)

Syntaxe

<Résultat> = FinValRemboursement([<Capital initial> [,<Nombre de périodes> [,<Taux>]]])

-Détail des paramètres

<Résultat> // Réel ou monétaire, Valeur future de l'investissement.

<Capital initial> // Réel ou monétaire optionnel, Capital initial (0 par défaut).
//Ce paramètre indique le montant sur lequel le calcul doit être effectué.
//Dans le cas "classique" d'un emprunteur, ce capital est emprunté et correspond donc à une valeur négative.
//Si ce paramètre est positif, le calcul est réalisé pour un prêteur.
//La valeur retournée est négative : cette valeur correspond à la somme à verser.

<Nombre de périodes> // Entier optionnel, Nombre total de périodes pour l'opération (1 par défaut).

<Taux> // Réel optionnel, Taux d'intérêt de l'investissement exprimé en pourcentage (1 par défaut).
//Par exemple, pour un taux d'investissement de 5%, ce paramètre sera égal à 5.

Notes

-Unité temporelle
//Les calculs peuvent être réalisés en prenant en compte des mois ou des années.
//Il suffit que les paramètres <Taux> et <Période> correspondent à la même unité temporelle.

//Ainsi, pour des remboursements mensuels d'un emprunt sur une durée de quatre ans au taux d'intérêt annuel de 12%, utilisez :
<Taux> = 12% / 12,
<Nombre de périodes> = 4*12

//Si, pour le même emprunt, vos remboursements sont annuels, utilisez :
<Taux> = 12%,
<Nombre de période> = 4

//Pour tous les paramètres, les décaissements sont représentés par un nombre négatif alors que les encaissements sont représentés par un nombre positif.

-Gestion des erreurs
//Attention : La fonction FinValFuture ne retourne pas de code d'Erreur .
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction FinErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


fListeFichier

Nouvelle page
Saisissez ici le texte de la page


fLit

Nouvelle page
Saisissez ici le texte de la page


fLitLigne

Nouvelle page
Saisissez ici le texte de la page


fNomCourt

Nouvelle page
Saisissez ici le texte de la page


fNomLong

Nouvelle page
Saisissez ici le texte de la page


fOuvre

Nouvelle page
Saisissez ici le texte de la page


fPositionne

Nouvelle page
Saisissez ici le texte de la page


fRenomme

Nouvelle page
Saisissez ici le texte de la page


fRep
Saisissez ici le texte de la page


fRepCrée

Nouvelle page
Saisissez ici le texte de la page


fSauveTexte

Nouvelle page
Saisissez ici le texte de la page


fSupprime

Nouvelle page
Saisissez ici le texte de la page


fTaille

Nouvelle page
Saisissez ici le texte de la page


fRepEncours

Nouvelle page
Saisissez ici le texte de la page


ZFinAmortissement

Exemple d'utilisation de la fonction FinAmortissement

-Matrice d'amortissement

//Le code suivant permet de retourner une matrice d'amortissement.
//Le type d'amortissement est sélectionné par l'utilisateur grâce à des sélecteurs (SelectTypeAmort).

// Déclaration des variables
Res est un booléen
TypeAmort est un entier // Récupère le type d'amortissement
i,t,Montant,Taux,Durée est un entier

Montant=1000;Taux=10;Durée=12

// Récupération du type d'amortissement
t=1
SELON t
CAS 1 : TypeAmort = finInFine
CAS 2 : TypeAmort = finAmortissementConstant
CAS 3 : TypeAmort = finAnnuitéConstante
FIN

// Calcul de l'amortissement
Res = FinAmortissement("Matrice", TypeAmort, Montant, Taux, Durée)

// Erreur de calcul ?
SI Res = Faux ALORS
Aresult(ErreurInfo(errMessage)); RETOUR // Affichage du message d'erreur
FIN

// Affichage de la matrice dans une table mémoire
POUR i = 1 A MatNbLigne("Matrice") ALORS
Aresult(MatLitLigne("Matrice", i))
FIN


Gauche

Utilisation

//Extrait la partie gauche d'une chaîne de caractères (c'est-à-dire les premiers caractères).

Gauche("Le coucou", 6) // Renvoie "Le cou"
Gauche("ABC", 50) // Renvoie "ABC"
Gauche("AZELMA ") // Renvoie "AZELMA"

Syntaxe

<Résultat> = Gauche(<chaîne source> [, <Longueur>])

-Détail des paramètres

<Résultat> // Chaîne de caractères
//Partie gauche spécifiée de <Chaîne source>.
//Correspond à <Chaîne source> si le paramètre <Longueur> est supérieur à la taille de <Chaîne source>.
//EOT si le paramètre <Longueur> est négatif. Une erreur du W-Langage est générée (erreur non fatale). Pour plus de détails sur l'erreur, utilisez la fonction ErreurInfo.

<chaîne source> // Chaîne de caractères, //Chaîne de caractères dont il faut extraire la partie gauche.
//Cette chaîne n'est pas modifiée.

<Longueur> // Entier optionnel, Nombre de caractères à extraire.
//Si ce paramètre n'est pas précisé, <Résultat> correspond à <Chaîne Source> sans les espaces à droite.


Hasard

Utilisation

//Renvoie un nombre aléatoire.

-Récupération d'un réel compris entre 0 et 1
ResHasard = Hasard()

-Récupération d'un entier compris entre 1 et 33
ResHasard = Hasard(33)

-Récupération d'un entier compris entre 7 et 21
ResHasard = Hasard(7, 21)

Syntaxe

-Récupérer un nombre aléatoire compris entre 0 et 1
<Résultat> = Hasard()
-Détail du paramètre
<Résultat> // Réel, Nombre aléatoire compris entre 0 et 1.

-Récupérer un nombre aléatoire compris entre 1 et une valeur
<Résultat> = Hasard(<Borne maximale>)
-Détail des paramètres
<Résultat> // Entier, Nombre aléatoire compris entre 1 et une valeur spécifiée.
<Borne maximale> // Entier, Borne maximale du nombre retourné (valeur comprise entre 1 et 2 147 483 647).

-Récupérer un nombre aléatoire compris entre deux valeurs
<Résultat> = Hasard(<Borne minimale>, <Borne maximale>)
-Détail des paramètres
<Résultat> // Entier, Nombre aléatoire compris entre deux valeurs spécifiées.
<Borne minimale> // Entier, Borne minimale du nombre retourné (valeur comprise entre 0 et 2 147 483 647).
<Borne maximale> // Entier, Borne maximale du nombre retourné (valeur comprise entre 0 et 2 147 483 647).

Notes

-Noyau aléatoire
//Le "noyau" dans lequel le nombre aléatoire est "choisi" peut être initialisé par la fonction InitHasard.
//Si la fonction InitHasard n'est pas appelée, les valeurs aléatoires générées par la fonction Hasard seront les mêmes à chaque exécution du programme.


HeureDifférence

Nouvelle page
Saisissez ici le texte de la page


HeureSys

Nouvelle page
Saisissez ici le texte de la page


HeureValide

Nouvelle page
Saisissez ici le texte de la page


HeureVersChaîne

Nouvelle page
Saisissez ici le texte de la page


HeureVersEntier

Nouvelle page
Saisissez ici le texte de la page


Info

Utilisation

//Affiche un message personnalisé dans une fenêtre d'information système.

//Pour fermer la fenêtre, l'utilisateur doit valider le bouton OK.

Nom_utilisateur est une chaîne = "Florence"
Info("Bonjour" + Nom_utilisateur + RC + "Bienvenue !")

Syntaxe

Info(<Texte> [, <Ligne 2> ... [, <Ligne n>]])

-Détail des paramètres

<Texte> // chaîne de caractères, Texte A afficher.
<Ligne 2> ... <Ligne n> // chaînes de caractères optionnelles, Texte affiché sur les lignes suivantes.

Notes

-Caractéristiques de la boîte de dialogue
//Le titre de la boîte de dialogue correspond au titre de la fenêtre en cours.
//Le message est cadré à gauche.
//Le libellé du bouton dépend de la langue d'exécution de Windows.

-Saut de lignes dans la boite de dialogue
//La chaîne pré-définie RC (Retour Chariot) peut être utilisée pour forcer le passage à la ligne suivante. Par exemple :
Info("La fiche XXX a été modifiée." + RC +...
"Voulez-vous la sauver avant de quitter ?")
//est équivalent à :
Info("La fiche XXX a été modifiée.",...
"Voulez-vous la sauver avant de quitter ?")


InitHasard

Utilisation

//Initialise le générateur de nombres aléatoires.

// Initialisation du générateur de nombres aléatoires
InitHasard()

Syntaxe

InitHasard([<n>])

-Détail du paramètre

<n> // entier, nombre de base du générateur de nombres aléatoires.
//Si ce paramètre n'est pas spécifié, le générateur de nombres aléatoires se base sur l'heure système (centièmes de secondes).

Notes

-Nombre aléatoire
//Si la fonction InitHasard n'est pas appelée, les valeurs aléatoires générées par la fonction Hasard seront les mêmes à chaque exécution du programme.

//Des appels à InitHasard très rapprochés dans le temps donneront des séquences identiques car InitHasard utilise l'heure système pour générer des suites de nombres aléatoires.


Ln

Utilisation

//Calcule le logarithme népérien (inverse de l'exponentielle) d'une valeur numérique.

// Calcul du logarithme népérien de 12
ResLogNépérien = Ln(12)
// Renvoie 2.48490664979

Syntaxe

<Résultat> = Ln(<Valeur numérique>)

-Détail des paramètres

<Résultat> // réel, Logarithme népérien recherché.
<Valeur numérique> // entier ou réel, Valeur numérique à manipuler.
//Si ce paramètre est un nombre négatif ou nul, une erreur du W-Langage est générée.


Log

Utilisation

//Calcule le logarithme décimal d'une valeur numérique.

// Calcul du logarithme de 10
ResLogarithme = Log(10)
// Renvoie 1

Syntaxe

<Résultat> = Log(<Valeur numérique>)

-Détail des paramètres

<Résultat> // Réel, Logarithme décimal recherché.
<Valeur numérique> // Entier ou réel, Valeur numérique à manipuler.
//Si ce paramètre est un nombre négatif ou nul, une erreur du W-Langage est générée.


Majuscule

Utilisation

//Convertit une chaîne de caractères en majuscules en fonction des paramètres de localisation définis dans Windows.

Majuscule("abcd") // Renvoie "ABCD"
Majuscule("pépère") // Renvoie "PEPERE"
Majuscule("ça !") // Renvoie "ÇA !"

Syntaxe

<Résultat> = Majuscule(<chaîne de caractères>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, Chaîne de caractères en majuscules.
<chaîne de caractères> // Chaîne de caractères, Chaîne de caractères à passer en majuscules.

Notes

-Règles de conversion
//Les lettres minuscules non accentuées sont converties en majuscules non accentuées.
//Les lettres minuscules accentuées sont converties en majuscules non accentuées.
//Les lettres majuscules non accentuées restent en majuscules non accentuées.
//Les lettres majuscules accentuées restent en majuscules accentuées.

-Divers
//Les "blancs" sont conservés.


MatAdditionne

Exemple

Utilisation

//Additionne deux matrices de mêmes dimensions (même nombre de lignes et même nombre de colonnes).

// Addition de deux matrices
ResAddition = MatAdditionne("MaMatrice1", "MaMatrice2", "MaMatriceRésultat")

Syntaxe

<Résultat> = MatAdditionne(<Nom de la 1ère matrice>, <Nom de la 2ème matrice>, <Nom de la matrice résultat>)

-Détail des paramètres

<Résultat> // Booléen,
Vrai //si l'addition a été effectuée,
Faux //dans le cas contraire.

<Nom de la 1ère matrice> // Chaîne de caractères, Nom de la première matrice à additionner, défini avec la fonction MatCrée.

<Nom de la 2ème matrice> // Chaîne de caractères, Nom de la seconde matrice à additionner, défini avec la fonction MatCrée.

<Nom de la matrice résultat> // Chaîne de caractères, Nom de la matrice contenant le résultat de l'addition. Cette matrice est automatiquement créée lors de l'addition des deux matrices.

Notes

-Existence de la matrice Résultat
//L'existence de la matrice n'est pas vérifiée. Si la matrice existait auparavant, cette matrice est écrasée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Matrices identiques
//Si le <Nom de la 1ère matrice> est identique au <Nom de la 2ème matrice>, la matrice résultat contient le double de la matrice d'origine.

-Soustraction de matrices
//Pour soustraire une matrice à une autre matrice, il suffit de :
//multiplier la matrice à soustraire par -1 avec la fonction MatRéelMultiplie,
//additionner la matrice obtenue à la première matrice.

-Gestion des erreurs
//La fonction MatAdditionne renvoie Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


MatCompresse

Exemple

Utilisation

//Compresse la place mémoire occupée par une matrice.
//Remarque : La compression est nécessaire si vous manipulez une matrice importante sur laquelle de nombreux calculs ont été effectués. Si cette matrice comporte plusieurs colonnes et/ou lignes nulles, la compression permet de réduire sensiblement la taille mémoire de la matrice.

-Compression d'une matrice
MatCompresse("MaMatrice")

Syntaxe

MatCompresse(<Nom de la matrice>)

-Détail du paramètre

<Nom de la matrice> // Chaîne de caractères, Nom de la matrice à compresser, défini avec la fonction MatCrée.

Notes

-Existence de la matrice à compresser
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//Attention : La fonction MatCompresse ne retourne pas de résultat.
//Pour savoir si des erreurs ont été générées par la compression, utilisez la fonction MatErreur sur cette matrice.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


MatCopie

Exemple

Utilisation

//Crée la copie d'une matrice. La nouvelle matrice a les mêmes dimensions que la matrice de base. Tous les éléments de la matrice d'origine sont copiés dans la nouvelle matrice.

// Copie d'une matrice
ResCopie = MatCopie("MaMatrice", "MaMatriceCopie")

Syntaxe

<Résultat> = MatCopie(<Nom de la matrice A copier>, <Nom de la matrice copiée>)

-Détail des paramètres

<Résultat> // Booléen,
Vrai // si la matrice a été copiée,
Faux // dans le cas contraire.

<Nom de la matrice A copier> // Chaîne de caractères, Nom de la matrice à copier, défini avec la fonction MatCrée.

<Nom de la matrice copiée> // Chaîne de caractères, Nom de la matrice copiée.
//Cette matrice est automatiquement créée lors de la copie.

Notes

-Existence de la matrice copiée
//L'existence de la matrice n'est pas vérifiée.
//Si la matrice existait auparavant, cette matrice est écrasée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//La fonction MatCopie renvoie Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


MatCrée

Exemple

Utilisation

//Crée une matrice de 0 ligne et 0 colonne.

// Création d'une matrice
ResCréation = MatCrée("MaMatrice")

Syntaxe

<Résultat> = MatCrée(<Nom de la matrice>)

-Détail des paramètres

<Résultat> // Booléen
Vrai //si la matrice a été créée,
Faux //dans le cas contraire.

<Nom de la matrice> // Chaîne de caractères, Nom de la matrice à créer.
//Ce nom sera utilisé dans toutes les fonctions de gestion des matrices.

Notes

-Existence de la matrice
//L'existence de la matrice n'est pas vérifiée.
//Si la matrice existait auparavant, cette matrice est écrasée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//La fonction MatCrée renvoie Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


MatDéterminant

Exemple

Utilisation

//Calcule le déterminant d'une matrice carrée (nombre de lignes égal au nombre de colonnes).

// Calcul du déterminant d'une matrice
ResDéterminant = MatDéterminant("MaMatrice")

Syntaxe

<Résultat> = MatDéterminant(<Nom de la matrice>)

-Détail des paramètres

<Résultat> // Réel, Déterminant de la matrice.
//Si cette valeur est égale à 0, le déterminant de la matrice est nul.

<Nom de la matrice> // Chaîne de caractères, Nom de la matrice à manipuler, défini avec la fonction MatCrée.

Notes

-Existence de la matrice
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//Attention : La fonction MatDéterminant ne retourne pas de code d'erreur.
//Pour savoir si des erreurs ont été générées par le calcul du déterminant, utilisez la fonction MatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


MatEcrit

Exemple

Utilisation

//Écrit un élément dans une matrice.

// Affectation du 6 à l'élément (ligne 2, colonne 2)
ResEcriture = MatEcrit("MaMatrice", 6, 2, 2)

Syntaxe

<Résultat> = MatEcrit(<Nom de la matrice>, <Valeur>, <Ligne de l'élément>, <Colonne de l'élément>)

-Détail des paramètres

<Résultat> // Booléen
Vrai //si l'écriture a été effectuée, Faux dans le cas contraire.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à manipuler, défini avec la fonction MatCrée.

<Valeur> // Réel, valeur donnée à l'élément spécifié.

<Ligne de l'élément> // Entier, ligne de l'élément à initialiser.

<Colonne de l'élément> // Entier, colonne de l'élément à initialiser.

Notes

-Existence de la matrice
//Une matrice doit exister avant de pouvoir être remplie.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Taille de la matrice
//La taille de la matrice est gérée dynamiquement.
//Si les coordonnées (ligne et colonne) de l'élément à insérer dans la matrice sont supérieures à la dimension de la matrice (largeur totale de la matrice et hauteur totale de la matrice), l'élément est ajouté à la position indiquée.
//Dans ce cas, la matrice est complétée par des zéros.

//Par exemple :
MatEcrit("MonArchive", 9, 2, 4)

-Gestion des erreurs
//La fonction MatEcrit renvoie Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


MatErreur

Exemple

Utilisation

//Identifie le type de la dernière erreur due à une fonction Matxxx (fonctions de gestion des matrices).

// Identification du type d'erreur
ResErreur = MatErreur("MaMatrice")

Syntaxe

<Résultat> = MatErreur(<Nom de la matrice>)

-Détail des paramètres

<Résultat> // Entier, 0 si aucune erreur n'est survenue sur la matrice ou un code d'erreur (valeur supérieure à 0) dans le cas contraire.
<Nom de la matrice> // Chaîne de caractères, nom de la matrice manipulée, défini avec la fonction MatCrée.

Notes

-Code d'erreur
//Les codes d'erreur pouvant survenir sur une matrice sont :
8 // Pas assez de mémoire disponible.
9 // La position demandée est en dehors de la matrice.
10 // Le nom de la matrice est invalide.
11 // Les matrices ont des dimensions différentes.
12 // Le déterminant est nul. Impossible de calculer l'inverse de la matrice.

-Attention :
//Les erreurs 9, 10 et 11 génèrent une erreur du W-Langage.
//L'application est alors arrêtée.

-Existence de la matrice
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.


MatExiste

Exemple

Utilisation

//Teste l'existence d'une matrice en mémoire.

// Teste l'existence de la matrice
ResExiste = MatExiste("MaMatrice")

Syntaxe

<Résultat> = MatExiste(<Nom de la matrice>)

-Détail des paramètres

<Résultat> // booléen
Vrai //si la matrice existe en mémoire,
Faux //dans le cas contraire.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à tester, défini avec la fonction MatCrée.

Notes

-Existence d'une matrice en mémoire
//Une matrice peut être créée de plusieurs façons :
//par la fonction MatCrée,
//en copiant une matrice (fonction MatCopie),
//en additionnant deux matrices (fonction MatAdditionne),
//en multipliant deux matrices (fonction MatMultiplie),
//en créant la matrice transposée (fonction MatTranspose),
//en créant la matrice inverse (fonction MatInverse).

-Une matrice peut être supprimée :
//par la fonction MatSupprime,
//à la fermeture de l'application.

-Gestion des erreurs
//La fonction MatExiste renvoie Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


MatInverse

Exemple

Utilisation

//Inverse une matrice carrée.

-Remarque :
//La matrice inverse ne peut être calculée que :
//à partir d'une matrice carrée (nombre de lignes égal au nombre de colonnes),
//si le déterminant (renvoyé par MatDéterminant) n'est pas nul.

-Inversion d'une matrice carrée
ResInversion = MatInverse("MaMatrice", "MaMatriceInversée")

Syntaxe

<Résultat> = MatInverse(<Nom de la matrice A inverser>, <Nom de la matrice inversée>)

-Détail des paramètres

<Résultat> // Booléen
Vrai //si l'inversion a été effectuée,
Faux //dans le cas contraire.

<Nom de la matrice A inverser> // Chaîne de caractères, nom de la matrice à inverser, défini avec la fonction MatCrée.

<Nom de la matrice inversée> // Chaîne de caractères, nom de la matrice inversée. Cette matrice est automatiquement créée lors de l'inversion.

Notes

-Existence de la matrice inversée
//L'existence de la matrice n'est pas vérifiée.
//Si la matrice existait auparavant, cette matrice est écrasée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Matrices identiques
//Une erreur du W-Langage est générée si le <Nom de la matrice à inverser> et le <Nom de la matrice inversée> sont identiques.

-Gestion des erreurs
//La fonction MatInverse renvoie Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


MatLit

Exemple

Utilisation

//Lit la valeur d'un élément d'une matrice.

-Rappel :
//Un élément d'une matrice est identifié par sa ligne et sa colonne.

// Lecture de l'élément (ligne 3, colonne 5)
ResLecture = MatLit("MaMatrice", 3, 5)

Syntaxe

<Résultat> = MatLit(<Nom de la matrice>, <Ligne de l'élément>, <Colonne de l'élément>)

-Détail des paramètres

<Résultat> // Réel, valeur de l'élément lu.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à lire, défini avec la fonction MatCrée.

<Ligne de l'élément> // Entier, numéro de la ligne de l'élément à lire.

<Colonne de l'élément> // Entier, numéro de la colonne de l'élément à lire.

Notes

-Existence de la matrice
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//Attention : La fonction MatLit ne retourne pas de code d'erreur.
//Pour savoir si des erreurs ont été générées par la lecture d'un élément, utilisez la fonction MatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


MatLitColonne

Exemple

Utilisation

//Lit la valeur de tous les éléments d'une colonne d'une matrice.

// Lecture des éléments de la colonne 5
ResLectureColonne = MatLitColonne("MaMatrice", 5)

Syntaxe

<Résultat> = MatLitColonne(<Nom de la matrice>, <Colonne A lire> [,[<Taille totale d'un élément>][.<Nombre de décimales>]<Format d'un élément>])

-Détail des paramètres

<Résultat> // Chaîne de caractères, valeur de tous les éléments de la colonne spécifiée, sous la forme :
<ValeurElément1>+TAB+<ValeurElément2>+TAB+...+TAB+<ValeurElémentN>

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à lire, défini avec la fonction MatCrée.

<Colonne A lire> // Entier, numéro de la colonne à lire.

<Taille totale d'un élément> // Entier optionnel, taille totale d'un élément.
//Cette taille comprend le signe, le séparateur des milliers, le point décimal, l'exposant, les parties entières et décimales de la valeur de l'élément.
//Si l'élément a plus de <Taille totale d'un élément> chiffres, la <Taille totale d'un élément> est augmentée.
//Si l'élément a moins de <Taille totale élément> chiffres, la chaîne de caractères <Résultat> est complétée par des espaces.
//Si la <Taille totale d'un élément> n'est pas précisée, la valeur de l'élément lu aura la taille de sa partie significative.
//La <Taille totale d'un élément> ne doit pas dépasser 100.
//Si la <Taille totale d'un élément> vaut 0, la valeur de l'élément aura la taille de sa partie significative.

<Nombre de décimales> // Entier optionnel, nombre de décimales à lire.
//Ce paramètre commence toujours par un point (".").
//La dernière décimale sera arrondie.
//Ce paramètre n'a d'effet que pour les notations flottantes ("f") et exponentielles ("e" et "E").
//Si le <Nombre de décimales> est plus grand que la <Taille totale d'un élément>, le paramètre <Taille totale d'un élément> n'est pas pris en compte.

<Format d'un élément> // Caractère optionnel, format de présentation d'un élément :
//d : la valeur de l'élément est sous la forme d'un entier signé. Les chiffres après la virgule sont tronqués et le paramètre <Nombre de décimales> n'est pas pris en compte.
//e ou E : la valeur de l'élément est sous la forme d'une notation exponentielle avec 1 chiffre avant le point décimal, <Nombre de décimales> chiffres après le point décimal et au moins 2 chiffres dans l'exposant.

Notes

-Existenc
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Taille de <Résultat>
//Attention : la taille de la chaîne de caractères obtenue dans <Résultat> est limitée à 260 caractères.
//Si la colonne de la matrice contient plus de caractères, la chaîne contenue dans <Résultat> ne contiendra que les 260 premiers caractères.

-Extraction d'une valeur d'un élément de <Résultat>
//Pour extraire une ou plusieurs valeurs d'éléments de la chaîne de caractères <Résultat>, utilisez la fonction ExtraitChaîne.

-Gestion des erreurs
//Attention : La fonction MatLitColonne ne retourne pas de code d'erreur.
//Pour savoir si des erreurs ont été générées par la lecture des éléments d'une colonne, utilisez la fonction MatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


MatLitLigne

Exemple

Utilisation

//Lit la valeur de tous les éléments d'une ligne d'une matrice.

// Lecture des éléments de la ligne 5
ResLectureLigne = MatLitLigne("MaMatrice", 5)

Syntaxe

<Résultat> = MatLitLigne(<Nom de la matrice>, <Ligne A lire> [,[<Taille totale d'un élément>][.<Nombre de décimales>]<Format d'un élément>])

-Détail des paramètres

<Résultat> // Chaîne de caractères, valeur de tous les éléments de la ligne spécifiée, sous la forme :
<ValeurElément1>+TAB+<ValeurElément2>+TAB+...+TAB+<ValeurElémentN>

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à lire, défini avec la fonction MatCrée.

<Ligne A lire> // Entier, numéro de la ligne à lire.

<Taille totale d'un élément> // Entier optionnel, taille totale d'un élément.
//Cette taille comprend le signe, le séparateur des milliers, le point décimal, l'exposant, les parties entières et décimales de la valeur de l'élément.
//Si l'élément a plus de <Taille totale d'un élément> chiffres, la <Taille totale d'un élément> est augmentée.
//Si l'élément a moins de <Taille totale élément> chiffres, la chaîne de caractères <Résultat> est complétée par des espaces.
//Si la <Taille totale d'un élément> n'est pas précisée, la valeur de l'élément lu aura la taille de sa partie significative.
//La <Taille totale d'un élément> ne doit pas dépasser 100.
//Si la <Taille totale d'un élément> vaut 0, la valeur de l'élément aura la taille de sa partie significative.

<Nombre de décimales> // Entier optionnel, nombre de décimales à lire.
//Ce paramètre commence toujours par un point (".").
//La dernière décimale sera arrondie.
//Ce paramètre n'a d'effet que pour les notations flottantes ("f") et exponentielles ("e" et "E").
//Si le <Nombre de décimales> est plus grand que la <Taille totale d'un élément>, le paramètre <Taille totale d'un élément> n'est pas pris en compte.

<Format d'un élément> // Caractère optionnel, format de présentation d'un élément :
//d : la valeur de l'élément est sous la forme d'un entier signé. Les chiffres après la virgule sont tronqués et le paramètre <Nombre de décimales> n'est pas pris en compte.
//e ou E : notation exponentielle avec 1 chiffre avant le point décimal, <Nombre de décimales> chiffres après le point décimal et au moins 2 chiffres dans l'exposant.

Notes

-Existence de la matrice
//L'existence dest pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Taille de <Résultat>
//Attention : la taille de la chaîne de caractères obtenue dans <Résultat> est limitée à 260 caractères.
//Si la ligne de la matrice contient plus de caractères, la chaîne contenue dans <Résultat> ne contiendra que les 260 premiers caractères.

-Extraction d'une valeur d'un élément de <Résultat>
//Pour extraire une ou plusieurs valeurs d'éléments de la chaîne de caractères <Résultat>, utilisez la fonction ExtraitChaîne.

-Gestion des erreurs
//Attention : La fonction MatLitLigne ne retourne pas de code d'erreur.
//Pour savoir si des erreurs ont été générées par la lecture des éléments d'une ligne, utilisez la fonction MatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


MatMultiplie

Exemple

Utilisation

//Multiplie deux matrices.

// Multiplication de deux matrices
ResMultplie = MatMultiplie("MaMatrice1", "MaMatrice2", "MaMatriceRésultat")

Syntaxe

<Résultat> = MatMultiplie(<Nom de la 1ère matrice>, <Nom de la 2ème matrice>, <Nom de la matrice résultat>)

-Détail des paramètres

<Résultat> // Booléen
Vrai //si la multiplication a été effectuée,
Faux //dans le cas contraire.

<Nom de la 1ère matrice> // Chaîne de caractères, nom de la première matrice à multiplier, défini avec la fonction MatCrée.

<Nom de la 2ème matrice> // Chaîne de caractères, nom de la seconde matrice à multiplier, défini avec la fonction MatCrée.

<Nom de la matrice résultat> // Chaîne de caractères, nom de la matrice contenant le résultat de la multiplication.
//Cette matrice est automatiquement créée lors de la multiplication des deux matrices.

Notes

-Multiplication de matrices
//Pour multiplier deux matrices, le nombre de colonnes de la première matrice doit être égal au nombre de lignes de la seconde matrice.
//L'élément (ligne i, colonne j) de la matrice résultat est obtenu en multipliant la ième ligne de la première matrice par la jème colonne de la seconde matrice.
//Il est possible de multiplier une matrice par elle-même. Pour cela, utilisez le même nom de matrice pour le <Nom de la 1ère matrice> et le <Nom de la 2ème matrice>.

-Existence de la matrice résultat
//L'existence de la matrice n'est pas vérifiée.
//Si la matrice existait auparavant, cette matrice est écrasée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//La fonction MatMultiplie renvoie Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


MatNbColonne

Exemple

Utilisation

//Renvoie le nombre de colonnes d'une matrice.

//Le nombre de colonnes d'une matrice varie dynamiquement.
//Il correspond au nombre de colonnes initialisées.
//Le nombre de colonnes peut varier après l'utilisation des fonctions :
MatEcrit
MatRemplit

// Nombre de colonnes ?
ResNbColonne = MatNbColonne("MaMatrice")

Syntaxe

<Résultat> = MatNbColonne(<Nom de la matrice>)

-Détail des paramètres

<Résultat> // Entier, nombre de colonnes dans la matrice spécifiée.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à manipuler, défini avec la fonction MatCrée.

Notes

-Existence de la matrice
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//Attention : La fonction MatNbColonne ne retourne pas de code d'erreur.
//Pour savoir si des erreurs ont été générées par le renvoie du nombre de colonne, utilisez la fonction MatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


MatNbLigne

Exemple

Utilisation

//Renvoie le nombre de lignes d'une matrice.

//Le nombre de lignes d'une matrice varie dynamiquement.
//Il correspond au nombre de lignes initialisées.
//Le nombre de lignes peut varier après l'utilisation des fonctions :
MatEcrit
MatRemplit

// Nombre de lignes ?
ResNbLigne = MatNbLigne("MaMatrice")

Syntaxe

<Résultat> = MatNbLigne(<Nom de la matrice>)

-Détail des paramètres

<Résultat> // Entier, nombre de lignes dans la matrice spécifiée.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à manipuler, défini avec la fonction MatCrée.

Notes

-Existence de la matrice
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//Attention : La fonction MatNbLigne ne retourne pas de code d'erreur.
//Pour savoir si des erreurs ont été générées par le renvoie du nombre de lignes, utilisez la fonction MatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


MatRéelAdditionne

Exemple

Utilisation

//Additionne une valeur à chaque élément d'une matrice. Cette addition est réalisée directement dans la matrice spécifiée.

// Addition de la valeur 3 à une matrice
MatRéelAdditionne("MaMatrice", 3)

Syntaxe

MatRéelAdditionne(<Nom de la matrice>, <Valeur>)

-Détail des paramètres

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à manipuler, défini avec la fonction MatCrée.

<Valeur> // Réel, valeur à ajouter à la matrice.

Notes

-Existence de la matrice
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//Attention : La fonction MatRéelAdditionne ne retourne pas de code d'erreur.
//Pour savoir si des erreurs ont été générées, utilisez la fonction ErreurInfo avec la constante errMessage.


MatRéelMultiplie

Exemple

Utilisation

//Multiplie chaque élément d'une matrice par une valeur.
//Cette multiplication est réalisée directement dans la matrice spécifiée.

// Multiplication des éléments de la matrice par la valeur 3
MatRéelMultiplie("MaMatrice", 3)

Syntaxe

MatRéelMultiplie(<Nom de la matrice>, <Valeur>)

-Détail des paramètres

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à manipuler, défini avec la fonction MatCrée.

<Valeur> // Réel, valeur utilisée pour la multiplication.

Notes

-Diviser tous les éléments d'une matrice
//Pour diviser tous les éléments d'une matrice par une valeur donnée, multipliez la matrice par : 1/<Valeur>.

-Existence de la matrice
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//Attention : La fonction MatRéelMultiplie ne retourne pas de code d'erreur.
//Pour savoir si des erreurs ont été générées par la multiplication, utilisez la fonction MatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


MatRemplit

Exemple

Utilisation

-Initialise tous les éléments d'une matrice d'une taille donnée.
//Si la matrice est plus grande, seuls les éléments spécifiés seront remplis.

-Remplissage d'une matrice de 2 lignes, 3 colonnes avec le nombre 5
ResRemplissage = MatRemplit("MaMatrice", 5, 2, 3)

-Initialisation de tous les éléments d'une matrice avec la valeur 5.
//Cette matrice est composée de 2 lignes et de 3 colonnes :
ResRemplissage = MatRemplit("MaMatrice", 5, 2, 3)

-Initialisation des éléments d'une matrice de la ligne 1 à 2 et de la colonne 1 à 3 avec la valeur 5.
//Seule une partie de la matrice est initialisée :
ResRemplissage = MatRemplit("MaMatrice", 5, 2, 3)

Syntaxe

<Résultat> = MatRemplit(<Nom de la matrice>, <Valeur>, <Nombre de lignes>, <Nombre de colonnes>)

-Détail des paramètres

<Résultat> // Booléen
Vrai //si le remplissage a été effectué,
Faux //dans le cas contraire.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à remplir, défini avec la fonction MatCrée.

<Valeur> // Réel, valeur donnée à l'ensemble des éléments de la matrice.

<Nombre de lignes> // Entier, nombre de lignes à remplir.

<Nombre de colonnes> // Entier, nombre de colonnes à remplir.

Notes

-Existence de la matrice
//Une matrice doit exister afin de pouvoir être remplie.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Gestion des erreurs
//La fonction MatRemplit renvoie Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


MatSupprime

Exemple

Utilisation

//Supprime une matrice existante.
//La suppression d'une matrice inutilisée (ou nulle) dans une application permet de libérer la place mémoire utilisée par cette matrice.

-Remarque :
//Toutes les matrices utilisées dans une application sont systématiquement supprimées à la fermeture de l'application.

// Suppression d'une matrice
MatSupprime("MaMatrice")

Syntaxe

MatSupprime(<Nom de la matrice>)

-Détail du paramètre

<Nom de la matrice> // Chaîne de caractères, nom de la matrice à supprimer, défini avec la fonction MatCrée.

Notes

-Existence de la matrice à supprimer
//L'existence de la matrice n'est pas vérifiée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.
//Si la matrice n'existe pas, la fonction MatSupprime n'a aucune action.


MatTranspose

Exemple

Utilisation

//Calcule la transposée d'une matrice.
//La transposée d'une matrice est obtenue en écrivant les lignes en colonnes.
//Si la matrice source est une matrice de n lignes et de m colonnes, alors la matrice transposée est une matrice de m lignes et de n colonnes.

// Transposée d'une matrice
ResTranspose = MatTranspose("MaMatrice", "MaMatriceTransposée")

Syntaxe

<Résultat> = MatTranspose(<Nom de la matrice A transposer>, <Nom de la matrice transposée>)

-Détail des paramètres

<Résultat> // Booléen,
Vrai //si la transposée été calculée,
Faux //dans le cas contraire.

<Nom de la matrice A transposer> // Chaîne de caractères, nom de la matrice à transposer, défini avec la fonction MatCrée.

<Nom de la matrice transposée> // Chaîne de caractères, nom de la matrice transposée.
//Cette matrice est automatiquement créée lors du calcul de la transposée.

Notes

-Existence de la matrice transposée
//L'existence de la matrice n'est pas vérifiée.
//Si la matrice existait auparavant, cette matrice est écrasée.
//Pour vérifier l'existence d'une matrice, utilisez la fonction MatExiste.

-Matrices identiques
//Une erreur du W-Langage est générée si le <Nom de la matrice à transposer> et le <Nom de la matrice transposée> sont identiques.

-Gestion des erreurs
//La fonction MatTranspose renvoie Faux en cas d'erreur.
//Pour connaître le libellé de l'erreur, utilisez la fonction ErreurInfo avec la constante errMessage.


Max

Utilisation

//Renvoie la plus grande des valeurs passées en paramètre.

// Plus grande valeur ?
ResMax = Max(10, 15, 20) // Renvoie 20
ResMax = Max("Z", "A") // Renvoie "Z"

Syntaxe

<Résultat> = Max(<Valeur 1>, <Valeur 2> [,<Valeur N>])

-Détail des paramètres

<Résultat> // Chaîne de caractères, entier ou réel, la plus grande des valeurs passées en paramètre.

<Valeur 1>/<Valeur 2>/<Valeur N> // Chaîne de caractères, entier ou réel, valeurs à comparer.


MemAjoute

Utilisation

//Ajoute un élément dans une zone mémoire.

// Ajoute la valeur de la rubrique Client.Nom dans la zone mémoire "ZoneMem"
// La valeur retournée sera le numéro d'enregistrement de cette rubrique
MemAjoute("ZoneMem", Client.Nom, HNumEnr(Client))

Syntaxe

MemAjoute(<Nom de la zone mémoire>, <Valeur ajoutée>, <Valeur de retour>)

-Détail des paramètres

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

<Valeur ajoutée> // Chaîne de caractères, entier ou réel, valeur ajoutée dans la zone mémoire.
//Cette valeur correspond à l'argument de tri utilisé par la fonction Memtrie.
//Cette valeur peut être récupérée grâce à la fonction MemValClé.

<Valeur de retour> // Chaîne de caractères, valeur qui sera retournée par les fonctions MemRécupère ou MemPositionne.

Notes

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemAjoute. Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Tri des éléments
//L'élément ajouté dans la zone mémoire n'est pas trié.
//Il est nécessaire d'utiliser la fonction memtrie pour trier l'ensemble de la zone mémoire.


MemCrée

Utilisation

//Crée une zone mémoire.
//Cette zone mémoire peut contenir des informations de type texte ou numérique.

// Création d'une zone mémoire
MemCrée("MaZoneMémoire")

Syntaxe

MemCrée(<Nom de la zone mémoire>)

-Détail du paramètre

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire à créer (20 caractères maximum).
//Ce nom sera utilisé par toutes les fonctions de gestion des zones mémoire.

Notes

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire existait auparavant, cette zone mémoire est écrasée.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Taille des informations
//Si la taille des informations à stocker dans la zone mémoire est plus importante que la place mémoire disponible, WinDev utilise un "swap disque" : WinDev crée un ou plusieurs fichiers temporaires pour stocker le surplus d'informations. Ces fichiers temporaires seront créés sur le disque local, dans le répertoire indiqué par la variable d'environnement "TEMP".


MemDernier

Utilisation

//Positionne sur le dernier élément d'une zone mémoire et renvoie la valeur de retour de ce denier élément.

// Positionne sur le dernier élément de la zone mémoire
// "MaZoneMémoire" et renvoie la valeur de cet élément
ResDernier = MemDernier("MaZoneMémoire")

Syntaxe

<Résultat> = MemDernier(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Tout type
//Si la zone mémoire n'est pas vide : valeur de retour du dernier élément, définie par les fonctions MemAjoute ou MemModifie.
//Si la zone mémoire est vide : une chaîne vide (" ").

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Tri de la zone mémoire
//Les tris effectués par la fonction Memtrie sont pris en compte lors de l'appel à la fonction MemDernier.
//Si aucun tri n'a été demandé par la fonction Memtrie, la fonction MemDernier retourne la valeur du dernier élément ajouté par la fonction MemAjoute.

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemDernier.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Équivalence
//Les deux syntaxes suivantes sont équivalentes :
Res = MemDernier(<Nom de la zone mémoire>)
Res = MemRécupère(<Nom de la zone mémoire>,MemOccurrence(<Nom de la zone mémoire>))


MemEncours

Utilisation

//Renvoie l'indice de l'élément en cours.

// Indice de l'élément en cours dans la zone mémoire "ZoneMémoire"
ResIndice = MemEnCours("ZoneMémoire")

Syntaxe

<Résultat> = MemEnCours(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Entier, indice de l'élément en cours dans la zone de mémoire spécifiée.

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Modification de l'élément en cours
//Les fonctions MemPositionne, MemPremier, MemDernier, MemSuivant, MemPrécédent et MemRecherche modifient l'élément en cours.

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemEnCours.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.


MemEnDehors

Utilisation

//Permet de savoir si le parcours effectué sur une zone de mémoire est en dehors de cette zone de mémoire.

MemPremier("MaZoneMémoire")

// Parcours en dehors de la zone mémoire "MaZoneMémoire" ?
TANTQUE MemEnDehors("MaZoneMémoire") = Faux
// Traitements dans la zone mémoire
...
// Fin des traitements
MemSuivant("MaZoneMémoire")
FIN

Syntaxe

<Résultat> = MemEnDehors(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Booléen
Vrai //si la fin de la zone mémoire a été atteinte,
Faux //dans le cas contraire.

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Appel de la fonction MemEnDehors
//La fonction MemEnDehors doit être utilisée après l'appel des fonctions MemPremier, MemDernier, MemSuivant, MemPrécédent et MemRecherche afin de tester si la fin de la zone mémoire a été atteinte.

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemEnDehors.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.


MemExiste

Utilisation

//Teste l'existence d'une zone de mémoire.

// Teste l'existence de la zone mémoire "MaZoneMémoire"
ResExiste = MemExiste("MaZoneMémoire")

Syntaxe

<Résultat> = MemExiste(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Booléen
Vrai //si la zone mémoire existe,
Faux //dans le cas contraire.

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Zone mémoire
//Pour exister, une zone mémoire doit avoir été créée avec la fonction MemCrée.
//Une zone mémoire peut être détruite avec la fonction MemSupprimeTout.


MemModifie

Utilisation

//Modifie un élément dans une zone mémoire.

// Remet à 0 toutes les valeurs supérieures à 100
// dans la zone mémoire "MaZoneMémoire"
POUR Indice = 1 A MemOccurrence("MaZoneMémoire")
ResValeur = MemRécupère("MaZoneMémoire", Indice)
SI ResValeur > 100 ALORS MemModifie("MaZoneMémoire", 0, 0, Indice)
FIN

Syntaxe

MemModifie(<Nom de la zone mémoire>, <Valeur modifiée>, <Valeur de retour>, <Indice>)

-Détail des paramètres

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

<Valeur modifiée> // Chaîne de caractères, entier ou réel
//Valeur modifiée dans la zone mémoire.
//Cette valeur correspond à l'argument de tri utilisé par la fonction memtrie.
//Cette valeur peut être récupérée grâce à la fonction MemValClé.

<Valeur de retour> // Chaîne de caractères, valeur retournée par les fonctions MemRécupère ou MemPositionne.

<Indice> // Entier, indice de l'élément à modifier.
//L'indice d'un élément peut être obtenu grâce aux fonctions MemEnCours ou MemRecherche.

Notes

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemModifie.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Tri des éléments
//L'élément modifié dans la zone mémoire n'est pas trié.
//Il est nécessaire d'utiliser la fonction MemTrie pour trier l'ensemble de la zone mémoire.


MemOccurrence

Utilisation

//Renvoie le nombre d'éléments présents dans une zone de mémoire.

// Nombre d'éléments présents dans la zone mémoire "MaZoneMémoire"
ResOccurrence = MemOccurrence("MaZoneMémoire")

Syntaxe

<Résultat> = MemOccurrence(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Entier, nombre d'éléments présents dans la zone mémoire spécifiée.

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemOccurrence.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.


MemPositionne

Utilisation

//Positionne la zone mémoire sur un élément.

// Positionne sur l'élément 7 dans la zone mémoire "MaZoneMémoire"
ResPosition = MemPositionne("MaZoneMémoire", 7)

Syntaxe

<Résultat> = MemPositionne(<Nom de la zone mémoire>, <Indice>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, valeur de retour de l'élément spécifié, définie par les fonctions MemAjoute ou MemModifie.

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

<Indice> // Entier, indice de l'élément sur lequel la zone mémoire doit être positionnée.
//L'indice d'un élément peut être obtenu grâce aux fonctions MemEnCours ou MemRecherche.

Notes

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemPositionne.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.


MemPrécédent

Utilisation

//Positionne sur l'élément précédent l'élément en cours d'une zone mémoire et renvoie la valeur de retour de cet élément.

// Positionne sur l'élément précédent de la zone mémoire
// "MaZoneMémoire" et renvoie la valeur de cet élément
ResPrécédent = MemPrécédent("MaZoneMémoire")

Syntaxe

<Résultat> = MemPrécédent(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Tout type
//Si l'élément précédent existe : valeur de retour de l'élément précédent, définie par les fonctions MemAjoute ou MemModifie.
//Si l'élément précédent n'existe pas : une chaîne vide (" ").

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Tri de la zone mémoire
//Les tris effectués par la fonction Memtrie sont pris en compte lors de l'appel à la fonction MemPrécédent.
//Si aucun tri n'a été demandé, la fonction MemPrécédent retourne la valeur de l'élément précédent selon l'ordre des éléments ajoutés avec la fonction MemAjoute.

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemPrécédent.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Recherche dans une zone mémoire
//Si la fonction MemRecherche est utilisée avant l'appel de la fonction MemPrécédent, la fonction MemPrécédent se positionnera sur le précédent élément recherché.

-Équivalence
//Les deux syntaxes suivantes sont équivalentes :
Res = MemPrécédent(<Nom de la zone mémoire>)
Res = MemRécupère(<Nom de la zone mémoire>,MemEnCours(<Nom de la zone mémoire>)-1)


MemPremier

Utilisation

//Positionne sur le premier élément d'une zone mémoire et renvoie la valeur de retour de ce premier élément.

// Positionne sur le premier élément de la zone mémoire
// "MaZoneMémoire" et renvoie la valeur de cet élément
ResPremier = MemPremier("MaZoneMémoire")

Syntaxe

<Résultat> = MemPremier(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Tout type
//Si la zone mémoire n'est pas vide : valeur de retour du premier élément, définie par les fonctions MemAjoute ou MemModifie.
//Si la zone mémoire est vide : une chaîne vide (" ").

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Tri de la zone mémoire
//Les tris effectués par la fonction Memtrie sont pris en compte lors de l'appel à la fonction MemPremier.
//Si aucun tri n'a été demandé, la fonction MemPremier retourne la valeur du premier élément ajouté par la fonction MemAjoute.

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemPremier.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Équivalence
//Les deux syntaxes suivantes sont équivalentes :
Res = MemPremier(<Nom de la zone mémoire>)
Res = MemRécupère(<Nom de la zone mémoire>, 1)


MemRecherche

Utilisation

//Recherche un élément dans une zone mémoire :
//soit sur la valeur ajoutée par la fonction MemAjoute ou sur la valeur modifiée par la fonction MemModifie,
//soit sur la valeur de retour.

-Remarque :
//Cette recherche est une recherche à l'identique.

// Recherche la première valeur égale à "M" dans la zone mémoire "ZoneMem"
ResRecherche = MemRecherche("ZoneMem", "M")

Syntaxe

<Résultat> = MemRecherche(<Nom de la zone mémoire>, <Valeur recherchée> [,<Élément>])

-Détail des paramètres

<Résultat> // Tout type
//Si le paramètre <Élément> est à Vrai (par défaut) :
//Valeur du premier élément trouvé ou une chaîne vide (" ") si aucun élément n'a été trouvé.
//Si le paramètre <Élément> est à Faux :
//Indice du premier élément trouvé ou -1 si aucun élément n'a été trouvé.

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

<Valeur recherchée> // Chaîne de caractères, valeur recherchée dans la zone mémoire.

<Élément> // Booléen
Vrai //(valeur par défaut) : la recherche est effectuée sur la valeur ajoutée par la fonction MemAjoute ou sur la valeur modifiée par la fonction MemModifie.
Faux // la recherche est effectuée sur la valeur de retour.

Notes

-Parcours sur une zone mémoire
//La fonction MemRecherche permet d'amorcer un parcours sur la zone mémoire.

//Après l'exécution de la fonction MemRecherche :
//la fonction MemSuivant se positionnera sur le prochain élément recherché.
//la fonction MemPrécédent se positionnera sur le précédent élément recherché.
//Pour reprendre un parcours normal, il est nécessaire d'utiliser les fonctions MemPremier ou MemDernier.

-Recherche sur une valeur numérique
//Pour effectuer une recherche sur une valeur numérique, convertissez cette valeur en chaîne avec la fonction NumériqueVersChaîne avant de lancer la recherche avec la fonction MemRecherche.

-Erreur
//Une erreur du W-Langage est générée lors de l'exécution de la fonction MemRecherche :
//si la zone mémoire <Nom de la zone mémoire> n'existe pas. Pour vérifier l'existence d'une zone mémoire, utilisez la fonction WINDEV_RTFLIENDEBUT0INDEV_RTFLIENFIN001008.
//si la zone mémoire <Nom de la zone mémoire> n'a pas été préalablement triée. Pour trier une zone mémoire, utilisez la fonction Memtrie.


MemRécupère

Utilisation

//Récupère la valeur de retour d'un élément présent dans une zone mémoire.

// Récupération de la valeur de retour de l'élément 7
// présent dans la zone mémoire "MaZoneMémoire"
ResRécupère = MemRécupère("MaZoneMémoire", 7)

Syntaxe

<Résultat> = MemRécupère(<Nom de la zone mémoire>, <Indice>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, valeur de retour de l'élément spécifié (définie par les fonctions MemAjoute ou MemModifie) ou une chaîne vide (" ") si l'élément spécifié n'a pas été trouvé.

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

<Indice> // Entier, indice de l'élément à manipuler.
//L'indice d'un élément peut être obtenu par les fonctions MemEnCours ou MemRecherche.

Notes

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemRécupère.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Positionnement dans la zone mémoire
//La fonction MemRécupère ne se positionne pas sur l'élément manipulé.
//Pour se positionner sur l'élément <Indice>, utilisez la fonction MemPositionne.


MemSuivant

Utilisation

//Positionne sur l'élément suivant d'une zone mémoire et renvoie la valeur de retour de cet élément.

// Positionne sur l'élément suivant de la zone mémoire
// "MaZoneMémoire" et renvoie la valeur de cet élément
ResSuivant = MemSuivant("MaZoneMémoire")

Syntaxe

<Résultat> = MemSuivant(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Tout type
//Si l'élément suivant existe : valeur de retour de l'élément suivant, définie par les fonction MemAjoute ou MemModifie.
//Si l'élément suivant n'existe pas : une chaîne vide (" ").

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Tri de la zone mémoire
//Les tris effectués par la fonction Memtrie sont pris en compte lors de l'appel à la fonction MemSuivant.
//Si aucun tri n'a été demandé, la fonction MemSuivant retourne la valeur de l'élément suivant selon l'ordre des éléments ajoutés avec la fonction MemAjoute.

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemSuivant.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Recherche dans une zone mémoire
//Si la fonction MemRecherche est utilisée avant l'appel de la fonction MemSuivant, la fonction MemSuivant se positionnera sur le prochain élément recherché.

-Équivalence
//Les deux syntaxes suivantes sont équivalentes :
Res = MemSuivant(<Nom de la zone mémoire>)
Res = MemRécupère(<Nom de la zone mémoire>,MemEnCours(<Nom de la zone mémoire>)+1)


MemSupprime

Utilisation

//Supprime un élément dans une zone mémoire.

// Supprime toutes les valeurs nulles de la zone mémoire "ZoneMémoire"
ResRecherche = MemRecherche("ZoneMémoire", 0)
TANTQUE MemEnDehors = Faux
MemSupprime("ZoneMémoire", MemEnCours("ZoneMémoire"))
MemSuivant("ZoneMémoire")
FIN

Syntaxe

MemSupprime(<Nom de la zone mémoire>, <Indice>)

-Détail des paramètres

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

<Indice> // Entier, indice de l'élément à supprimer.
//L'indice d'un élément peut être obtenu par les fonctions MemEnCours ou MemRecherche.

Notes

-Suppression
//Suppression simple : après l'exécution de la fonction MemSupprime, il y a passage sur l'élément suivant.
//Suppression avec recherche : si la suppression est effectuée sur des éléments recherchés par la fonction MemRecherche, utilisez :
//- la fonction
MemSuivant //pour se positionner sur le prochain élément recherché.
//- la fonction
MemPrécédent //pour se positionner sur le précédent élément recherché.

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemSupprime.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.


MemSupprimeTout

Utilisation

//Vide et supprime une zone mémoire.

// Suppression de la zone mémoire "MaZoneMémoire"
MemSupprimeTout("MaZoneMémoire")

Syntaxe

MemSupprimeTout(<Nom de la zone mémoire>)

-Détail du paramètre

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire à supprimer, défini par la fonction MemCrée. Si ce paramètre correspond à un astérisque ("*"), toutes les zones mémoire précédemment créées sont supprimées.

Notes

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemSupprimeTout.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.


MemTrie

Utilisation

//Trie les éléments présents dans une zone mémoire. Ce tri est effectué sur l'argument de tri spécifié avec les fonctions MemAjoute ou MemModifie.

// Tri croissant des éléments dans la zone mémoire "ZoneMémoire"
MemTrie("ZoneMémoire", Vrai)

Syntaxe

MemTrie(<Nom de la zone mémoire> [,<Sens>])

-Détail des paramètres

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

<Sens> // Booléen optionnel
Vrai //(valeur par défaut) si le tri doit être croissant,
Faux //si le tri doit être décroissant.

Notes

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemTrie.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Tri des éléments
//Le tri est utilisé par les fonctions de parcours MemPremier, MemDernier, MemSuivant et MemPrécédent, ainsi que par la fonction MemRecherche.


MemTrouvé

Utilisation

//Vérifie si l'élément recherché a été trouvé.

// L'élément a-t'il été trouvé dans la zone mémoire "ZoneMémoire" ?
ResTrouvé = MemTrouvé("ZoneMémoire")

Syntaxe

<Résultat> = MemTrouvé(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Booléen
Vrai //si l'élément recherché a été trouvé,
Faux //dans le cas contraire.

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Appel de la fonction MemTrouvé
//La fonction MemTrouvé doit être appelée uniquement après les fonctions MemRecherche, MemPremier, MemDernier, MemPrécédent et MemSuivant.

-Vérifications
//Il n'est pas possible d'effectuer plusieurs fois à la suite une vérification avec la fonction MemTrouvé.
//Par exemple, la fonction MemTrouvé ne peut pas être utilisée de la façon suivante :

MemRecherche("ZoneJours", ValeurRecherchée)
TANTQUE MemTrouvé("ZoneJours") = Vrai
MemSuivant("ZoneJours")
FIN

//En effet, les recherches effectuées dans une zone mémoire sont à des recherches à l'identique et la fonction MemTrouvé a, dans ce cas, le même comportement que la fonction MemEnDehors. Dans notre exemple, la fonction MemTrouvé retourne Faux (la fin de la zone mémoire n'est pas atteinte).
//Les recherches suivantes ne seront pas effectuées.

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemTrouvé.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.


MemValClé

Utilisation

//Renvoie la valeur ajoutée ou modifiée (par les fonctions MemAjoute ou MemModifie) de l'élément en cours dans une zone mémoire.

// Récupération de la valeur de l'élément en cours
// dans la zone mémoire "MaZoneMémoire"
ResValeur = MemValClé("MaZoneMémoire")

Syntaxe

<Résultat> = MemValClé(<Nom de la zone mémoire>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, valeur ajoutée par la fonction MemAjoute ou modifiée par la fonction MemModifie.

<Nom de la zone mémoire> // Chaîne de caractères, nom de la zone mémoire, défini par la fonction MemCrée.

Notes

-Existence de la zone mémoire
//L'existence de la zone mémoire n'est pas vérifiée.
//Si la zone mémoire <Nom de la zone mémoire> n'existe pas, une erreur du W-Langage est générée lors de l'exécution de la fonction MemValClé.
//Pour vérifier l'existence d'une zone mémoire, utilisez la fonction MemExiste.

-Appel de la fonction MemValClé
//La fonction MemValClé doit être appelée uniquement après les fonctions MemRecherche, MemPositionne, MemPremier, MemDernier, MemPrécédent et MemSuivant.


Milieu

Utilisation

//Extrait une sous-chaîne d'une chaîne à partir d'une position donnée.

Milieu("Eponine", 2, 3) // Renvoie "pon"
Milieu("Eponine", 2) // Renvoie "ponine"
Milieu("Eponine", 50) // Renvoie ""
Milieu("Eponine", 2, 50) // Renvoie "ponine"

Syntaxe

<Résultat> = Milieu(<chaîne source>, <Position de départ> [, <Longueur>])

-Détail des paramètres

<Résultat> // Chaîne de caractères, partie de <Chaîne source>.
//Chaîne vide ("") si le paramètre <Position de départ> est supérieur à la longueur de <Chaîne Source>.
//EOT si le paramètre <Position de départ> et/ou le paramètre<Longueur> sont négatifs. Une erreur du W-Langage est générée (erreur non fatale). Pour plus de détails sur l'erreur, utilisez la fonction ErreurInfo.

<chaîne source> // Chaîne de caractères, chaîne de caractères contenant la sous-chaîne à extraire.
//Cette chaîne n'est pas modifiée.

<Position de départ> // Entier, position du premier caractère à extraire.
//Si <Position de départ> est nul, l'extraction commence au début de la chaîne.

<Longueur> // Entier optionnel, nombre de caractères à extraire.
//Si ce paramètre n'est pas précisé ou est supérieur au nombre de caractères restant après la <Position de départ>, la chaîne est renvoyée à partir de la <Position de départ>.

Notes

-Divers
//Le premier caractère de la chaîne possède l'indice 1.
//Il est possible d'obtenir la même fonctionnalité avec l'opérateur [[ ]].


Min

Utilisation

//Renvoie la plus petite des valeurs passées en paramètre.

// Plus petite valeur ?
ResMin = Min(10, 15, 20) // Renvoie 10
ResMin = Min("Z", "A") // Renvoie "A"

Syntaxe

<Résultat> = Min(<Valeur 1>, <Valeur 2> [,<Valeur N>])

-Détail des paramètres

<Résultat> // Chaîne de caractères, entier ou réel, la plus petite des valeurs passées en paramètre.

<Valeur 1>/<Valeur 2>/<Valeur N> // Chaîne de caractères, entier ou réel, valeurs à comparer.


Minuscule

Utilisation

//Convertit une chaîne de caractères en minuscules en fonction des paramètres de localisation définis dans Windows.

Minuscule("ABCD") // Renvoie "abcd"
Minuscule("ÇA !") // Renvoie "ça !"
Minuscule("Pierre et Paul") // Renvoie "pierre et paul"

Syntaxe

<Résultat> = Minuscule(<chaîne de caractères>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, chaîne de caractères en minuscules.

<chaîne de caractères> // Chaîne de caractères, chaîne de caractères à passer en minuscules.

Notes

-Règles de conversion
//Les lettres minuscules non accentuées restent en minuscules non accentuées.
//Les lettres minuscules accentuées restent en minuscules non accentuées.
//Les lettres majuscules non accentuées passent en minuscules non accentuées.
//Les lettres majuscules accentuées restent en majuscules accentuées.

-Divers
//Les "blancs" sont conservés.


Modulo

Utilisation

//Retourne le reste d'une division entière.

-Remarque :
//Modulo peut être utilisé aussi bien en tant que mot-clé ou en tant que fonction du W-Langage.

// Récupération du reste de la division
ResteDivision = Modulo(21,4) // ResteDivision vaut 1
// Équivalent à : ResteDivision = 21 Modulo 4

Syntaxe

-Fonction Modulo

<Reste de la division> = Modulo(<Dividende>,<Diviseur>)

-Détail des paramètres
<Reste de la division> // Entier, Reste de la division entière.
<Dividende> // Entier, Dividende de la division.
<Diviseur> // Entier, Diviseur de la division.
// Si ce paramètre vaut 0, une erreur du W-Langage est générée.

-Mot-clé Modulo

<Reste de la division> = <Dividende> Modulo <Diviseur>

-Détail des paramètres
<Reste de la division> // Entier, Reste de la division entière.
<Dividende> // Entier, Dividende de la division.
<Diviseur> // Entier, Diviseur de la division.
//Si ce paramètre vaut 0, une erreur du W-Langage est générée.


Mvalue

Mvalue (fonction TRUE)

Utilisation

//Retourne la valeur d'un stock miroir
//Le fonctionnement est identique à celui de la fonction Svalue("a"), sauf concernant le paramètre temps.

-Valeurs des stocks miroirs :
//Dans le cas d'un appel à la fonction Mvalue(), le paramètre temps t est automatiquement initialisé à la valeur t - 1.
//En effet, un stock miroir représente la somme des valeurs de ses stocks sources.
//Cette somme est effectuée une fois que toutes les actions sont exécutées.
//Il est donc impossible d'obtenir, dans une action, la valeur courante d'un stock miroir.
//Il faut donc prendre la valeur précédente.

//Dans le cas où c = 1 et t = 1 :
//la fonction retournera la somme des valeurs des dotations initiales des stocks sources du stock miroir concerné.

//Dans le cas où cycle >1 et t=1 :
//la valeur correspondant à la dernière unité de temps du cycle précédent sera retournée.

//Un message d'information sera affiché lors de l'appel à cette fonction, pour rappeler ce fonctionnement.

//Cette boite d'information sera affichée, lorsque vous insérez, par glisser-déplacer ou double clic la fonction Mvalue(), pour un stock miroir :

-Note : pour ne plus afficher cette fenêtre, cocher l'interrupteur " Ne plus afficher cette information ".

-Exemple 1
//y est la valeur de retour de la procédure
y = Mvalue("m")
//y = valeur du stock miroir m pour le cycle c courant et le temps t = t-1

-Exemple 2
//y est la valeur de retour de la procédure
//c est le cycle en cours
//t est l'unité de temps en cours
c_, t_ sont des entiers
c_= 4; t_= 10
SI c_ <= c ET t_ <= t ALORS y = Mvalue("b",c_,t_)
//y = valeur du stock b pour le cycle c_=4 et le temps t_= 10 - 1

-Exemple 3
//y est la valeur de retour de la procédure
//nbt est le nombre de temps courant, comptabilisé pour tous les cycles
nbt_ est un entier
nbt_= nbt-10
SI nbt_ > 0 ALORS y = Mvalue("b",Faux,nbt_)
//y = valeur du stock b pour le temps nbt - (10 -1)

Première Syntaxe

Mvalue(<Nom du stock miroir>,[<Cycle>,<Temps>] )

-Détail des paramètres
<Nom du stock miroir> // Chaîne contenant le nom du stock miroir dont on veut obtenir la valeur.
<Cycle> // Entier optionnel, qui indique pour quel cycle, on veut obtenir la valeur du stock miroir.
<Temps> // Entier optionnel, qui indique pour quelle unité de temps - 1 , on veut obtenir la valeur du stock miroir.
//Si les paramètres <Cycle> et <Temps>, ne correspondent pas à une unité vion retournera 0.

Deuxième Syntaxe

Mvalue(<Nom du stock miroir>,[<Faux>,<Nombre de temps>] )

-Détail des paramètres
<Nom du stock miroir> // Chaîne contenant le nom du stock miroir dont on veut obtenir la valeur.
<Faux> // booléen optionnel, qui indique que le cycle n'est pas pris en compte, et que la valeur du paramètre <Nombre de temps>, doit correspondre au temps relatif, non pas au cycle en cours, mais à tous les cycles, qui correspond à la valeur de la variable nbt.
<Nombre de temps> // Entier optionnel, qui indique pour quelle unité de temps - 1, relative à tous les cycles compilés, on veut obtenir la valeur du stock miroir.
//Si le paramètre <Nombre de temps> ne correspond pas à une unité de temps valide, la fonction retournera 0.


NonBinaire

Utilisation

//Renvoie le résultat du NON logique (bit à bit) d'une valeur.

-Rappel :
//L'opération NON logique est équivalente au "Complément à un".
//La négation logique intervient sur TOUS les bits de la valeur.

// Récupération du NON logique
ResNONBinaire = NONBinaire(6) // Renvoie -7
ResNONBinaire = NONBinaire(2) // Renvoie -3

Syntaxe

<Résultat> = NONBinaire(<Valeur>)

-Détail des paramètres

<Résultat> // Entier, résultat du NON logique.

<Valeur> // Entier, valeur à tester.

Notes

-Calcul bit à bit
//NONBinaire effectue le calcul bit à bit de <Valeur> selon la table suivante :

//Valeur 0 1
//Résultat 1 0


NumériqueVersChaîne

Utilisation

//Transforme un numérique (entier, réel ou monétaire) en une chaîne de caractères selon le format spécifié.

NumériqueVersChaine(123) // Renvoie "123"
NumériqueVersChaine(1.23) // Renvoie "1.23"
NumériqueVersChaine(12345.5, "+10.2f") // Renvoie " +12345.50"
NumériqueVersChaine(12345.5, "-+10.2f") // Renvoie "+12345.50 "
NumériqueVersChaine(12345.5, "+010.2f") // Renvoie "+012345.50"
NumériqueVersChaine(12345.5, "010.2f") // Renvoie "0012345.50"

NumériqueVersChaine(12345.5, "10.2fS")
// Renvoie " 12 345.50" (le séparateur des milliers est un " ")

NumériqueVersChaine(12345.5, "10,2fS")
// Renvoie " 12 345,50" (le séparateur décimal est une ",")

Syntaxe

<Résultat> = NumériqueVersChaine(<Nombre> [, <Format>])

-Détail des paramètres

<Résultat> // Chaîne de caractères, nombre exprimé sous forme de chaîne de caractères en fonction du format choisi.
//Si le paramètre <Nombre> est une chaîne, elle est restituée telle quelle.
//Le format est ignoré.

<Nombre> // Entier ou réel, numérique à convertir sous forme de chaîne de caractères (selon le format spécifié).

<Format> // Chaîne de caractères, format de la chaîne de caractères, exprimé sous la forme :
"[<Cadrage>][<signe>][<Zéro>][<Taille>][<.Précision>] <Type>[<Millier>]"

<Cadrage>
//Si ce paramètre est spécifié, justifie le nombre à gauche (<Cadrage> = "-").
//Par défaut, le nombre est justifié à droite.

<signe>
//Si ce paramètre est spécifié, force le signe pour les chiffres positifs (<Signe> = "+"). Ce signe apparaîtra à gauche du premier chiffre significatif.
//Par défaut, seuls les chiffres négatifs ont un signe "-" à gauche du premier chiffre significatif.
//Cas particulier : si ce paramètre est spécifié et si le nombre vaut 0, le signe "+" sera affiché. De même si un nombre négatif devient égal à 0.

<Zéro>
//Si ce paramètre est spécifié (<Zéro> ="0"), le nombre sera complété par des zéro à gauche du premier chiffre significatif si la partie significative du nombre est plus petite que la taille demandée et si le nombre est justifié à droite.
//Par défaut, le nombre n'est pas complété à gauche par des "0".
//Par exemple : NumériqueVersChaine(123,"05d") donnera "00123".

<Taille>largeur totale de la chaîne résultat. La largeur totale correspond aux éléments suivants : signe, séparateur de milliers, point décimal, exposant, parties entières et décimales du nombre. Cette taille doit être inférieure à 100.
//Si la taille indiquée est trop petite pour contenir la partie significative du nombre, elle sera ignorée.
//Par défaut, le nombre aura la taille de sa partie significative (il ne pourra pas être complété par des zéro). Idem si <Taille> = 0
//Si la taille indiquée est plus grande que la partie significative du nombre :

//- la chaîne résultat sera complétée par des espaces à droite si le nombre est justifié à gauche,
//- la chaîne résultat sera complétée par des espaces ou zéros à gauche si le nombre est justifié à droite.

<.Précision>
//Fixe le séparateur décimal et le nombre de décimales (uniquement pour les <Types> flottant ("f") et exposant ("e"). Le nombre de décimal doit être inférieur à 100.
//Si le nombre de décimales du nombre est plus grand que <Précision>, la partie décimale sera arrondie au nombre de décimales demandées.
//Si le nombre de décimales du nombre est plus petit que <Précision>, la partie décimale sera complétée par des "0" à droite.
//Si le séparateur des décimales est une virgule, le séparateur des décimales sera celui défini dans la configuration Windows.
//La valeur de <Précision> peut être plus grande que <Taille>. Dans ce cas <Taille> est ignoré.

<Type>
//Type du résultat, paramètre obligatoire :
d // Entier, un nombre réel sera arrondi à l'entier le plus proche.
e // Notation exponentielle, si <Précision> n'est pas indiqué, 6 chiffres par défaut.
f // Notation décimale, si <Précision> n'est pas indiqué, 6 chiffres par défaut.
x et X // Notation hexadécimale (X pour des lettres majuscules) :
//Seule la partie entière du nombre est prise en compte (pas d'arrondi).
//Cas particulier :
//1. Taille non précisée et nombre négatif : 20 caractères hexadécimaux pour un monétaire, 8 caractères pour tous les autres numériques.
//2. Nombre négatif : la taille de la chaîne résultat sera au minimum la taille permettant d'indiquer le bit de signe.
//Par exemple : -32767 dans le format "3X" donnera "8001"
o // Notation octale, seule la partie entière du nombre est prise en compte (pas d'arrondi).
//Cas particulier :
//1. Taille non précisée et nombre négatif : 27 caractères pour un monétaire, 11 caractères pour tous les autres numériques.
//2. Nombre négatif : la taille de la chaîne résultat sera au minimum la taille permettant d'indiquer le bit de signe.
//Par exemple : -32767 dans le format "3o" donnera "700001"

<Millier>
//Séparateur de milliers (<Millier> = "S" ou "s").
//Les chiffres de la partie entière du nombre seront regroupés par 3 et séparés par le caractère séparateur de milliers défini dans Windows.
//Si le signe est présent, il sera toujours immédiatement à gauche du premier chiffre significatif.
//Il ne peut pas y avoir de séparateur des milliers entre le signe et le premier chiffre.

Notes

-Limites
//Format "f" donne un résultat correct s allant de -1e+17 à 1e+17.
//Formats "x", "d" ou "o" : la partie entière ne doit pas dépasser 99 999 999 999 999 999.


NuméroDeSemaine


OUBinaire

Utilisation

//Renvoie le résultat du OU logique (bit à bit) entre deux valeurs.

// Récupération du OU logique
ResOUBinaire = OUBinaire(6, 6) // Renvoie 6
ResOUBinaire = OUBinaire(6, 2) // Renvoie 6

Syntaxe

<Résultat> = OUBinaire(<Valeur 1>, <Valeur 2>)

-Détail des paramètres

<Résultat> // Entier, résultat du OU logique.

<Valeur 1> // Entier, première valeur à tester.

<Valeur 2> // Entier, seconde valeur à tester.

Notes

-Calcul bit à bit
//OUBinaire effectue le calcul bit à bit entre <Valeur1> et <Valeur2> selon la table suivante :

0 1
0 0 1
1 1 1


OUExclusifBinaire

Utilisation

//Renvoie le résultat du OU Exclusif logique (bit à bit) entre deux valeurs.

// Récupération du OU Exclusif logique
ResOUEXBinaire = OuExclusifBinaire(6, 6) // Renvoie 0
ResOUEXBinaire = OuExclusifBinaire(6, 2) // Renvoie 4

Syntaxe

<Résultat> = OuExclusifBinaire(<Valeur 1>, <Valeur 2>)

-Détail des paramètres

<Résultat> // Entier, résultat du OU Exclusif logique.

<Valeur 1> // Entier, première valeur à tester.

<Valeur 2> // Entier, seconde valeur à tester.

Notes

-Calcul bit à bit
//OUExclusifBinaire effectue le calcul bit à bit entre <Valeur1> et <Valeur2> selon la table suivante :
0 1
0 0 1
1 1 0


OuiNon

Utilisation

//Affiche un message dans une boite de dialogue standard proposant les réponses "Oui" et "Non" et renvoie la réponse de l'utilisateur.

//Pour fermer la fenêtre, l'utilisateur doit valider un des boutons.

// Choix sortie
SI OuiNon("Voulez-vous quitter le programme?") = Oui ALORS Ferme

Syntaxe

<Résultat> = OuiNon([<Bouton sélectionné>], <Texte> [, <Ligne 2> ... [, <Ligne n>]])

-Détail des paramètres

<Résultat> // Constante de type entier, identifie le bouton sélectionné par l'utilisateur :
Non, 0 //L'utilisateur a choisi le bouton [NON]
Oui, 1 //L'utilisateur a choisi le bouton [OUI]

<Bouton sélectionné> // Constante optionnelle de type entier
//Bouton sélectionné par défaut dans la boîte de dialogue :
Non, 0 //Bouton [NON] sélectionné par défaut
Oui, 1 //Bouton [OUI] sélectionné par défaut
//(par défaut)

<Texte> // Chaîne de caractères, texte à afficher.

<Ligne 2> ... <Ligne n> // Chaînes de caractères optionnelles, texte affiché sur les lignes suivantes.

Notes

-Caractéristiques de la boîte de dialogue
//Le titre de la boîte de dialogue correspond au titre de la fenêtre en cours.
//Le message est cadré à gauche.
//Les libellés des boutons dépendent de la langue d'exécution de Windows.
//Le nombre maximum de caractères affichés est limité à 4096. Si une chaîne plus grande est passée en paramètre, elle sera tronquée.
//L'icone affiché (point d'exclamation) ne peut pas être modifié.

-Saut de lignes dans la boîte de dialogue
//La chaîne pré-définie RC (Retour Chariot) peut être utilisée pour forcer le passage à la ligne suivante. Par exemple :
OuiNon("La fiche XXX a été modifiée." + RC +"Voulez-vous la sauver avant de quitter ?")
//est équivalent à :
OuiNon("La fiche XXX a été modifiée.","Voulez-vous la sauver avant de quitter ?")


Options

Options (fonction TRUE)

Utilisation

//Initialise une ou plusieurs fonctionnalités, qui seront prises en compte à l'issue de l'exécution de la procédure.

-Exemple 1

//y est la valeur de retour de la procédure
SI y=50 ALORS Options(3)

-Exemple 2

//y est la valeur de retour de la procédure
SI y=50 ALORS Options(3,5,6,7)

Première Syntaxe

Options(<Numéro d'option>,[< Numéro d'option >,< Numéro d'option >,…..] )

-Détail des paramètres
<Numéro d'option> // entier précisant quelle option ont veut initialiser.
//Il est possible d'initialiser les 7 options actuellement disponibles, simultanément.

-Description des options de fin de procédure

1 // Afficher le lien comme actif même si la valeur de retour = 0 :
//Par défaut, lorsque la valeur de transfert des actions d'un lien est nulle, ce lien est affiché comme étant inactif.
//Pour afficher le lien dans l'état actif, même si la valeur de transfert est nulle, initialiser cette option.

2 // Ne pas afficher le lien de référence aux objets :
//Par défaut, lorsqu'il est fait référence à la valeur d'un objet par l'intermédiaire des fonctions Ovalue() et Mvalue(), un lien de référence est affiché.
//Pour ne pas l'afficher, initialiser cette option.

3 // Ne pas afficher le lien de référence aux liens :
//Par défaut, lorsqu'il est fait référence à la valeur d'un lien par l'intermédiaire de la fonction Lvalue(), un lien de référence est affiché.
//Pour ne pas l'afficher, initialiser cette option.

4 // Désactiver l'action pour le cycle défaut en cours :
//La procédure de cette action ne sera plus exécutée jusqu'à la fin du cycle défaut en cours.

5 // Désactiver l'action pour le cycle flottant en cours, si initialisé :
//La procédure de cette action ne sera plus exécutée, jusqu'à la fin du cycle flottant en cours,
//si le type de cycle est flottant défaut ou flottant flottant.

6 // Désactiver l'action pour tous les cycles :
//La procédure de cette action ne sera plus exécutée, jusqu'à la fin du cycle et pour tous les cycles à venir.

7 // Arrêter la compilation à la fin du cycle :
//La compilation s'arrêtera automatiquement à la fin du cycle défaut courant.


Svalue

Svalue (fonction TRUE)

Utilisation

//Retourne la valeur d'un stock

-Exemple 1

//y est la valeur de retour de la procédure
y = Svalue("b")
//y = valeur du stock b pour le cycle c courant et le temps t courant

-Exemple 2

//y est la valeur de retour de la procédure
//c est le cycle en cours
//t est l'unité de temps en cours
c_, t_ sont des entiers
c_= 4; t_= 10
SI c_ <= c ET t_ <= t ALORS y = Svalue("b",c_,t_)
//y = valeur du stock b pour le cycle c_=4 et le temps t_= 10

-Exemple 3

//y est la valeur de retour de la procédure
//nbt est le nombre de temps courant, comptabilisé pour tous les cycles
nbt_ est un entier
nbt_= nbt-10
SI nbt_ > 0 ALORS y = Svalue("b",Faux,nbt_)
//y = valeur du stock b pour le temps nbt - 10

Première Syntaxe

Svalue(<Nom du stock>,[<Cycle>,<Temps>] )

-Détail des paramètres

<Nom du stock> // Chaîne contenant le nom du stock dont on veut obtenir la valeur.
<Cycle> // Entier optionnel, qui indique pour quel cycle, on veut obtenir la valeur de l'objet.
<Temps> // Entier optionnel, qui indique pour quelle unité de temps, on veut obtenir la valeur du stock.
//Si les paramètres <Cycle> et <Temps>, ne correspondent pas à une unité valide, la fonction retournera 0.

Deuxième Syntaxe

Svalue(<Nom du stock>,[<Faux>,<Nombre de temps>] )

-Détail des paramètres

<Nom du stock> // Chaîne contenant le nom du stock dont on veut obtenir la valeur.
<Faux> // booléen optionnel, qui indique que le cycle n'est pas pris en compte, et que la valeur du paramètre <Nombre de temps>, doit correspondre au temps relatif, non pas au cycle en cours, mais à tous les cycles, qui correspond à la valeur de la variable nbt.
<Nombre de temps> // Entier optionnel, qui indique pour quelle unité de temps, relative à tous les cycles compilés, on veut obtenir la valeur du stock.
//Si le paramètre <Nombre de temps> ne correspond pas à une unité de temps valide, la fonction retournera 0.


PartieDécimale

Utilisation

//Renvoie la partie décimale d'un nombre.

// Partie décimale de 16.487
ResPartieDécimal = PartieDécimale(16.487)
// Renvoie 0.487

Syntaxe

<Résultat> = PartieDécimale(<Nombre>)

-Détail des paramètres

<Résultat> // Réel, partie décimale recherchée.

<Nombre> // Réel, nombre à manipuler.


PartieEntière

Utilisation

//Renvoie la partie entière d'un nombre.

// Partie entière de 16.999
ResPartieEntière = PartieEntière(16.999)
// Renvoie 16
// Pour obtenir 17, utiliser la fonction Arrondi

Syntaxe

<Résultat> = PartieEntière(<Nombre>)

-Détail des paramètres

<Résultat> // Entier, partie entière recherchée.
//Correspond au plus grand entier inférieur ou égal à <Nombre>.

<Nombre> // Réel, nombre à manipuler.


Phonétique

Utilisation

//Renvoie la phonétique correspondant à la chaîne passée en paramètre. Il est ainsi possible de détecter si deux chaînes de caractères sont phonétiquement semblables (selon la phonétique française).

// Comparaison de deux chaînes de caractères
Phonétique("TRAIT") = Phonétique("très")

Syntaxe

<Résultat> = Phonétique(<chaîne Source>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, chaîne de caractères en pseudo-phonétique correspondant à <Chaîne Source>.

<chaîne source> // Chaîne de caractères, chaîne de caractères à traduire en phonétique.
//Cette chaîne n'est pas modifiée.


PoidsFaible

Utilisation

//Renvoie les deux octets de poids faible d'un entier.

Res est un entier = CurseurPos(cpClient)
SI Res <>-1 ALORS
Aresult("Position X = " + PoidsFaible(Res)+"Position Y = " + PoidsFort(Res))
FIN

Syntaxe

<Résultat> = PoidsFaible(<Valeur>)

-Détail des paramètres

<Résultat> // Entier sans signe sur 2 octets, les deux octets de poids faible.

<Valeur> // Entier, valeur dont le poids faible est recherché.
//Si cette valeur est d'un type numérique différent de entier, cette valeur sera automatiquement convertie en entier. Si cette valeur est une chaîne de caractères, une erreur sera affichée.

Notes

-Divers
//La fonction PoidsFort permet de récupérer le poids fort d'un entier.


PoidsFort

Utilisation

//Renvoie les deux octets de poids fort d'un entier.

Res est un entier = CurseurPos(cpClient)
SI Res <>-1 ALORS
Aresult("Position X = " + PoidsFaible(Res)+"Position Y = " + PoidsFort(Res))
FIN

Syntaxe

<Résultat> = PoidsFort(<Valeur>)

-Détail des paramètres

<Résultat> // Entier, les deux octets de poids fort.

<Valeur> // Entier, valeur dont le poids fort est recherché.
//Si cette valeur est d'un type numérique différent de entier, cette valeur sera automatiquement convertie en entier.
//Si cette valeur est une chaîne de caractères, une erreur sera affichée.

Notes

-Divers
//La fonction PoidsFaible permet de récupérer le poids faible d'un entier.


Position

Utilisation

//Recherche la position d'une chaîne de caractères dans une autre chaîne de caractères.

MaChaîne = "Ils ont des chapeaux ronds"
n = Position(MaChaîne, "des", 1, DepuisDébut) // Renvoie 9
n = Position(MaChaîne, "XXX") // Renvoie 0
n = Position(MaChaîne, "l", 0, Depuisfin) // Renvoie 2
n = Position(MaChaîne, "e", 11) // Renvoie 17
n = Position(MaChaîne, "o", Taille(MaChaîne), Depuisfin) // Renvoie 23
n = Position(MaChaîne, "o", n-1, Depuisfin) // Renvoie 5
n = Position(MaChaîne, "o", n-1, Depuisfin) // Renvoie 0

Syntaxe

<Résultat> = Position(<chaîne initiale>, <chaîne A rechercher> [, <Position de départ> [, <Option>]])

-Détail des paramètres

<Résultat> // Entier
//Position du premier caractère de la chaîne de caractères recherchée dans la chaîne initiale ou 0 si la chaîne recherchée n'a pas été trouvée.
//Cette position est donnée par rapport au début de la chaîne.

<chaîne initiale> // Chaîne de caractères, chaîne de caractères dans laquelle la recherche doit être effectuée (taille maximale : 2 Go).

<chaîne A rechercher> // Chaîne de caractères, chaîne de caractères à rechercher dans la chaîne initiale.

<Position de départ> // Entier optionnel, indice du caractère à partir duquel la recherche doit être effectuée.
//Par défaut, la recherche commence à partir du premier caractère (caractère numéro 1).
//Si ce paramètre est négatif, la recherche commence à partir du premier caractère.
//Si ce paramètre est supérieur au nombre de caractères de la <Chaîne initiale>, <Résultat> est égal à 0.

<Option> // Constante (ou combinaison de constantes) optionnelle, indique le sens du parcours de la recherche et les caractéristiques de la recherche :
DepuisDébut //(par défaut), recherche effectuée du premier caractère de la chaîne vers le dernier
Depuisfin //recherche effectuée du dernier caractère de la chaîne vers le premier
MotComplet //Recherche le mot complet, c'est-à-dire entouré par des caractères de ponctuation ou des espaces
SansCasse e sans tenir compte de la casse (majuscules/minuscules)

Notes

-Recherche de la chaîne de caractères
//Par défaut, la recherche est sensible à la casse : la chaîne recherchée doit avoir la même casse que la chaîne à trouver dans la chaîne.
//Pour effectuer une recherche non sensible à la casse, utilisez le paramètre SansCasse.

//Les positions dans une chaîne de caractères sont toujours données depuis le début de la chaîne, quel que soit le sens de parcours de la recherche.

//Pour utiliser la fonction Position avec le paramètre DepuisFin, il est nécessaire de commencer à la position calculée par Taille(<Chaîne initiale>).
//Par exemple :
Position(MaChaîne, "\", Taille(MaChaîne), Depuisfin)

//La Syntaxe suivante peut également être utilisée.
//Dans ce cas, le paramètre 0 permet à la fonction de sélectionner la position de départ la plus adaptée.
Position(MaChaîne, "\", 0, Depuisfin)

-Divers
//La fonction PositionOccurrence permet de connaître la position de la Nème occurrence d'une sous-chaîne en effectuant une recherche soit depuis le début de la chaîne, soit depuis la fin de la chaîne.


PositionOccurrence

Utilisation

//Recherche la X ème position d'une chaîne de caractères dans une autre chaîne de caractères.

n = PositionOccurrence("Une chaîne d'exemple", "d",1) // Renvoie 12
n = PositionOccurrence("Une chaîne d'exemple", "zen",1) // Renvoie 0
n = PositionOccurrence("Une chaîne d'exemple", "e",1) // Renvoie 3
n = PositionOccurrence("Une chaîne d'exemple", "e", 2) // Renvoie 10

// Recherche du 3ème "e" en partant de la fin :
// la position est donnée en partant du début
n = PositionOccurrence("Une chaîne d'exemple", "e", 3, Depuisfin)
// Renvoie 14

Syntaxe

<Résultat> = PositionOccurrence(<chaîne initiale>, <chaîne à rechercher> , <Rang de l'occurrence recherchée> [<Option de recherche>])

-Détail des paramètres

<Résultat> // Entier, position du premier caractère de l'occurrence recherchée dans la chaîne initiale ou 0 si la chaîne recherchée n'a pas été trouvée.

<chaîne initiale> // Chaîne de caractères, chaîne de caractères dans laquelle la recherche doit être effectuée (taille maximale : 2 Go).

<chaîne A rechercher> // Chaîne de caractères, chaîne de caractères à rechercher dans la chaîne initiale.

<Rang de l'occurrence recherchée> // Entier, numéro de l'occurrence de la <Chaîne à rechercher>.
<Résultat> //contiendra la position de cette occurrence.
//Si ce paramètre est inférieur à 1, <Résultat> vaut 0.
//Si ce paramètre est supérieur au nombre de caractères de la <Chaîne initiale>, <Résultat> est égal à 0.

<Options de recherche> // Constante optionnelle, indique le sens du parcours et les options de la recherche :
DepuisDébut //(par défaut), recherche effectuée du premier caractère de la chaîne vers le dernier
Depuisfin //Recherche effectuée du dernier caractère de la chaîne vers le premier
MotComplet //Recherche un mot complet (entouré par des caractères de ponctuation ou des espaces)
SansCasse //Recherche sans tenir compte de la casse (différences majuscules / minuscules)

Notes

-Recherche de la chaîne de caractères
//Par défaut, la recherche est sensible à la casse : la chaîne recherchée doit avoir la même casse que la chaîne à trouver dans la chaîne.
//Pour ne par tenir compte de la casse, utilisez la constante SansCasse.


Puissance

Utilisation

//Élever un nombre à une puissance.

// 8 puissance 5
ResPuissance = Puissance(8,5)
// Renvoie 32768

Syntaxe

<Résultat> = Puissance(<Nombre A élever>, <Exposant>)

-Détail des paramètres

<Résultat> // Réel, résultat du <Nombre à élever> à la puissance <Exposant>.

<Nombre A élever> // Entier ou réel, nombre à élever.

<Exposant> // Entier ou réel, exposant.


Racine

Utilisation

//Renvoie la racine d'un nombre.

// Racine carré de 25
ResRacine = Racine(25)
// Renvoie 5

Syntaxe

<Résultat> = Racine(<Nombre> [,<Ordre de la Racine>])

-Détail des paramètres

<Résultat> // Réel, racine du nombre.

<Nombre> // Entier ou réel, nombre à manipuler.

<Ordre de la Racine> // Entier ou réel, ordre de la racine.
//Si ce paramètre n'est pas spécifié, la racine carrée du <Nombre> est extraite.


Remplace

Exemple

Utilisation

//Remplace toutes les occurrences d'un mot présent dans une chaîne par un autre mot.

Remarque : La chaîne de caractères initiale n'est PAS modifiée.

ChaîneInitiale est une chaîne = "Abracacabra !"
ChaîneRemplacée est une chaîne = Remplace(ChaîneInitiale, "a", "o")
Aresult(ChaîneRemplacée) // Affiche "Abrococobro !"

Syntaxe

<Résultat> = Remplace(<chaîne initiale>, <chaîne A remplacer>, <Nouvelle chaîne> [, <Option>])

-Détail des paramètres

<Résultat> // Chaîne de caractères, nouvelle chaîne de caractères dans laquelle les différents remplacements ont été effectués.

<chaîne initiale> // Chaîne de caractères, chaîne de caractères dans laquelle les remplacements doivent être effectués (taille maximale : 2 Go).

<chaîne A remplacer> // Chaîne de caractères, chaîne de caractères à remplacer dans la chaîne initiale.
//Si ce paramètre correspond à une chaîne vide (""), <Résultat> correspondra à <Chaîne initiale>.

<Nouvelle chaîne> // Chaîne de caractères, chaîne de caractères qui remplacera <Chaîne à remplacer>.
//Si ce paramètre correspond à une chaîne vide (""), toutes les occurrences de <Chaîne à remplacer> seront supprimées.

<Option> // Constante (ou combinaison de constantes) optionnelle, indique les caractéristiques de la recherche du mot à remplacer :
MotComplet //Recherche le mot complet (entouré par des caractères de ponctuation ou des espaces)
SansCasse //Recherche sans tenir compte de la casse (majuscules/minuscules)

Notes

-Recherche de la chaîne de caractères
//Par défaut, la recherche est sensible à la casse : la chaîne recherchée doit avoir la même casse que la chaîne à trouver dans la chaîne initiale.
//Pour effectuer une recherche ne tenant pas compte de la casse, utilisez la constante SansCasse.


Répète

Utilisation

//Concatène N répétitions d'une même chaîne de caractères.

Res = Répète("x", 4) // Renvoie "xxxx"
Res = Répète("Boby", 2) // Renvoie "BobyBoby"
Res = Répète("", 2) // Renvoie ""
Res = Répète("", 0) // Renvoie 0

Syntaxe

<Résultat> = Répète(<chaîne initiale>, <Nombre de répétitions>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, nouvelle chaîne de caractères contenant la répétition voulue ou une chaîne vide ("") si <Nombre de répétitions> est négatif ou nul.

<chaîne initiale> // Chaîne de caractères, chaîne de caractères à répéter.

<Nombre de répétitions> // Entier, nombre de fois où la <Chaîne initiale> doit être répétée.


ZRemplace

Exemple d'utilisation de la fonction Remplace

-Exemple : Remplacements divers

//L'exemple suivant permet de remplacer les occurrences d'un mot présent dans une chaîne par un autre mot.

ChaîneRemplacée est une chaîne
ChaîneRemplacée = Remplace("ABACAD", "A", "x") // ChaîneRemplacée = "xBxCxD"
ChaîneRemplacée = Remplace("ABACAD", "A", "") // ChaîneRemplacée = "BCD"
ChaîneRemplacée = Remplace("BABAR", "BA", "x") // ChaîneRemplacée = "xxR"
ChaîneRemplacée = Remplace("BABAR", "", "x") // ChaîneRemplacée = "BABAR"


ReStartAt

Exemple

Utilisation

//Elle permet la reprise des calculs à un instant indiqué.

//Une action qui veut faire un retro-calcul, doit ouvrir une porte vers le passé.

//La fonction ReStartAt() permet le retro-calcul. Elle retourne le numéro de la porte ouverte.

//Le numéro de cette porte est associé à l'action en cours et au nombre de temps en cours (nbt).
//Il ne peut y avoir plus d'une porte pour une même action et un même nbt.

//A ce numéro de porte est associé un compteur de passage par cette porte.
//Ce compteur est incrémenté a chaque fois que l'action franchit la porte vers le passé.

//L'état des portes de l'élaboration peut être connue par la fonction ReStartStat().

Première Syntaxe

<Résultat>=ReStartAt(<Cycle>,<Temps>,[<max_passing>],[<max_action_gate>],[<max_link_gate>],
[<max_global_gate>])

-Détail des paramètres

<Résultat> // numéro de porte créée ou déjà créée par l'action, pour le nombre de temps (nbt) en cours.
//Lorsque la porte existe déjà, le compteur de passage de cette porte est incrémenté.

<Cycle> // Entier qui indique pour quel cycle on veut redémarrer les calculs.

<Temps> // Entier qui indique pour quelle unité de temps on veut redémarrer les calculs.
//Si les paramètres <Cycle> et <Temps> ne correspondent pas à une unité de temps valide la fonction retourne 0.
//Ces paramètres doivent correspondre à une unité de temps présente ou passée.

<max_passing> // Entier optionnel qui limite le nombre de passage par cette porte.

<max_action_gate> // Entier optionnel qui limite le nombre de porte pouvant être ouvertes par l'action en cours.
//En effet d'autre portes peuvent ouvertes pour d'autres nombres de temps (nbt), par l'action en cours.

<max_link_gate> // Entier optionnel qui limite le nombre de porte pouvant être ouvertes par le lien contenant l'action en cours.
//En effet d'autres portes peuvent être ouvertes pour d'autres nombre de temps (nbt) par toutes les autres actions du lien contenant l'action en cours.

<max_global_gate> // Entier optionnel qui limite le nombre de porte pouvant être ouvertes par toutes les actions de tous les liens de l'élaboration.

Notes

//Si une des limites est atteinte, la porte n'est pas créée.
//Si la porte existait déjà, elle est détruite à la sortie de l'action, et le passage vers le passé n'est pas effectué.

Deuxième Syntaxe

<Résultat>=ReStartAt(<Faux>,<Nombre de temps>,[<max_passingmax_action_gate>],
[<max_link_gate>],[<max_global_gate>])

-Détail des paramètres

<Faux> // booléen qui indique que le cycle n'est pas pris en compte,
//et que la valeur du paramètre <Nombre de temps>,
//doit correspondre au temps relatif, non pas au cycle en cours,
//mais à tous les cycles et qui correspond à la valeur de la variable nbt.

<Nombre de temps> // Entier qui indique pour quelle unité de temps,
//relative à tous les cycles compilés, on veut redémarrer les calculs.
//Si le paramètre <Nombre de temps> ne correspond pas à une unité de temps valide, la fonction retournera 0.

Notes

//La description des paramètres suivants est la même que pour la syntaxe précédente.

//Ci-dessous, le graphe des valeurs y calculées selon le code de la procédure :

Notes

//La légende du graphe « P.p 1.2 » signifie « Porte 1, passage 2 ».


ReStartStat

Exemple

Utilisation

//La fonction ReStartStat() donne l'état des portes de l'élaboration créées par la fonction ReStartAt().

//Elle initialise la structure globale g qui est accessible dans la procédure de l'action en cours.
//Elle peut également retourner le nombre de passage en cours pour une porte spécifiée.

Première Syntaxe

ReStartStat()

//La structure globale g est renseignée par la fonction ReStartStat().
//Les membres de cette structure sont :

g:action_gate // numéro de la porte ouverte par l'action courante et le nbt courant, si existante.
g:action_passing // numéro de passage pour la porte ouverte par l'action courante pour le nbt courant, si existante.

g:nb_action_gate // nombre de portes ouvertes par l'action en cours.
g:nb_link_gate // nombre de portes ouvertes par le lien en cours.
g:nb_global_gate // nombre de portes ouvertes par l'élaboration.

g:global_passing // dernier numéro de passage pour la dernière porte de l'élaboration.

g:f_action_gate // booléen, vrai si une porte a été ouverte par l'action courante pour le nbt courant.
g:f_link_gate // booléen, vrai si une porte a été ouverte par le lien courante pour le nbt courant.
g:f_global_gate // booléen, vrai si une porte a été ouverte par l'élaboration pour le nbt courant.

g:t_action_gate // tableau des numéros des portes ouvertes par l'action en cours.
g:t_link_gate // tableau des numéros des portes ouvertes par le lien en cours.

Notes

// La dimension des tableaux g:t_action_gate et g:t_link_gate
// peut être obtenue par la fonction Dimension() du W-Langage.

Deuxième Syntaxe

<Résultat>=ReStartStat(<Numéro de porte>)

-Détail des paramètres

<Résultat> // Entier qui contient le nombre de passage pour la porte <Numéro de porte>.
//Si la porte n'existe pas la fonction retourne 0.

<Numéro de porte> // Entier qui contient le numéro de la porte dont on veut obtenir le nombre de passage.


ZReStartAt

Exemple d'utilisation de la fonction ReStartAt

-L'action "Act" appelle la fonction ReStartAt() pour le nbt 50

//Le futur numéro de porte renvoyé par cette fonction vaut 1.

//La porte 1 sera créée à la sortie de l'action, et le premier passage
//par cette porte sera initialisé à 1.

//Le retro-calcul s'effectuera pour les paramètres temporels c et t
//passés à la fonction ReStartAt(c,t).

//Lorsque l'action "Act" revient au nbt 50 et qu'elle rappelle la fonction ReStartAt(),
//le retour vers le passé se fera par la porte précédemment créée,
//et le compteur de passage sera incrémenté et vaudra 2.

//Si l'action "Act" passe le nbt 50 sans rappeler la fonction ReStartAt(),
//la porte 1 sera supprimée ainsi que son compteur de passage associé.

//y est la valeur de retour de la procédure
//c est le cycle en cours
//t est l'unité de temps en cours

porte est un entier
c_, t_ sont des entiers

SI c = 5 ET t = 10 //nbt = 50
SI y <> <Résultat attendu>
c_ = 2 ; t_ = 5
porte = ReStartAt(c_,t_)
//les calculs reprendront à l'unité temporelle 5 du cycle 2
//a la sortie de l'action en cours
FIN
FIN

-Ouverture d'une porte vers le passé alors qu'on est déjà dans le passé

//l'action "Act" a ouvert la porte 1 et elle est déjà passée 3 fois par cette porte ( 3 passages ).
//Elle revient vers la porte 1, mais avant d'y arriver, elle ouvre une nouvelle porte.
//Le numéro de la deuxième porte ouverte vaudra 2, et le compteur de passage associé vaudra 1.
//Il en est de même pour l'ouverture de nouvelles portes par d'autres actions.

//y est la valeur de retour de la procédure
//nbt est le nombre de temps courant, comptabilisé pour tous les cycles

nbt_ est un entier
porte est un entier

SI nbt = 30
SI y <> <Résultat attendu>
nbt_ = 20
porte = ReStartAt(Faux,nbt_)
FIN
FIN


ZReStartStat

Exemple d'utilisation de la fonction ReStartStat

-On veut connaître l'état des portes de l'élaboration

passing est un entier

ReStartStat()

y= g:global_passing
//on récupère le nombre de passage en cours pour la dernière porte ouverte par l'élaboration

SI y<>0
//si on est dans le passé, on déclenche une action
<Action>

//on récupère le nombre de porte pour l'action en cours
y = Dimension(g:t_action_gate)

//on récupère le nombre de passage pour la porte 3
SI y<=3
passing=g:t_action_gate[3]
FIN

FIN

-On veut connaître le nombre de passage d'une porte

porte,passing est un entier
porte = 3

passing = ReStartStat(porte)
//on récupère le nombre de passage en cours pour la porte 3

//on déclenche des actions selon le nombre de passage en cours
SELON passing
CAS 1 : <Action 1 >
CAS 2 : <Action 2 >
FIN


Nouvelle page
Saisissez ici le texte de la page


SansAccent

Utilisation

//Transforme les caractères accentués d'une chaîne de caractères en caractères non accentués.

SansAccent("pépère") // Renvoie "pepere"
SansAccent("où ça ?") // Renvoie "ou ça ?"
SansAccent("") // Renvoie ""

Syntaxe

<Résultat> = SansAccent(<chaîne initiale>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, chaîne de caractères dans laquelle tous les caractères accentués ont été remplacés par des caractères non accentués.

<chaîne initiale> // Chaîne de caractères, chaîne de caractères initiale.


SansEspace

Utilisation

//Renvoie une chaîne de caractères sans les espaces situés à gauche et à droite.

SansEspace(" 3.75 FF ") // Renvoie "3.75 FF"

Syntaxe

<Résultat> = SansEspace(<chaîne initiale>)

-Détail des paramètres

<Résultat> // Chaîne de caractères, chaîne de caractères sans les espaces.

<chaîne initiale> // Chaîne de caractères, chaîne de caractères initiale dont les espaces à droite et à gauche doivent être supprimés. Cette chaîne de caractères n'est pas modifiée.


Sinus

Utilisation

//Renvoie le sinus d'un angle.

// Sinus de 30
ResSinus = Sinus(30)
// Renvoie 0.5

Syntaxe

<Résultat> = Sinus(<Angle>)

-Détail des paramètres

<Résultat> // Réel, sinus de l'angle spécifié.

<Angle> // Entier ou réel, angle (en degrés) à manipuler.


SQLAssocie

Nouvelle page
Saisissez ici le texte de la page


SQLAvance

Nouvelle page
Saisissez ici le texte de la page


SQLBloque

Nouvelle page
Saisissez ici le texte de la page


SQLChangeConnexion

Nouvelle page
Saisissez ici le texte de la page


SQLCol

Nouvelle page
Saisissez ici le texte de la page


SQLColonne

Nouvelle page
Saisissez ici le texte de la page


SQLConnecte

Nouvelle page
Saisissez ici le texte de la page


SQLDéconnecte

Nouvelle page
Saisissez ici le texte de la page


SQLDernier

Nouvelle page
Saisissez ici le texte de la page


SQLExec

Nouvelle page
Saisissez ici le texte de la page


SQLFerme

Nouvelle page
Saisissez ici le texte de la page


SQLFormatColonne

Nouvelle page
Saisissez ici le texte de la page


SQLInfoGene

Nouvelle page
Saisissez ici le texte de la page


SQLLitCol

Nouvelle page
Saisissez ici le texte de la page


SQLLitMémo

Nouvelle page
Saisissez ici le texte de la page


SQLListeSource

Nouvelle page
Saisissez ici le texte de la page


SQLListeTable

Nouvelle page
Saisissez ici le texte de la page


SQLModifie

Nouvelle page
Saisissez ici le texte de la page


SQLPositionne

Nouvelle page
Saisissez ici le texte de la page


SQLPrécédent

Nouvelle page
Saisissez ici le texte de la page


SQLPremier

Nouvelle page
Saisissez ici le texte de la page


SQLReqExiste

Nouvelle page
Saisissez ici le texte de la page


SQLSuivant

Nouvelle page
Saisissez ici le texte de la page


SQLTable

Nouvelle page
Saisissez ici le texte de la page


StatCorrélation

Exemple

Utilisation

//Calcule le coefficient de corrélation entre deux séries de valeurs.

// Calcul du coefficient de corrélation entre la ligne 1 et la ligne 2 d'une matrice
ResCoefCorrélation = StatCorrélation("MaMatrice", 1, 2, Faux)

Syntaxe

<Résultat> = StatCorrélation(<Nom de la matrice> [,<1ère ligne/1ère colonne> [,<2ème ligne/2ème colonne> [,<Ligne/Colonne>]]])

-Détail des paramètres

<Résultat> // Réel, coefficient de corrélation existant entre les deux séries de valeurs ou 0 si le coefficient de corrélation est nul.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<1ère ligne/1ère colonne> // Entier optionnel, 1ère ligne ou 1ère colonne contenant les données (1 par défaut).

<2ème ligne/2ème colonne> // Entier optionnel, 2ème ligne ou 2ème colonne contenant les données (2 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai //(par défaut) si les séries de valeurs correspondent à des colonnes de la matrice,
Faux //si les séries de valeurs correspondent à des lignes de la matrice.

Notes

-Calcul du coefficient de corrélation

StatCorrélation("MaMatrice", 1, 3, Faux) // retourne 0,997054.

StatCorrélation("MaMatrice", 1, 3, Faux) // retourne 1.

StatCorrélation("MaMatrice", 1, 3, Faux) // retourne 0.

-Nombre d'éléments présents dans la matrice
//Le nombre d'éléments présents dans la matrice est pris comme référence.
//Ce nombre d'éléments correspond :
//-au nombre de lignes de la matrice, connu avec MatNbLigne;
//-au nombre de colonnes de la matrice, connu avec MatNbColonne.
//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0.
//Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatCorrélation ne retourne pas de code d'erreur.
//Pour savoir si le calcul du coefficient de corrélation a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction WINDEV1000ErreurInfo avec la constante errMessage.


StatCovariance

Exemple

Utilisation

//Calcule la covariance entre deux séries de valeurs.

-Remarque :
//La covariance correspond à la moyenne du produit des écarts pour chaque série.

// Calcul de la covariance entre la ligne 1 et la ligne 2 d'une matrice
ResCovariance = StatCovariance("MaMatrice", 1, 2, Faux)

Syntaxe

<Résultat> = StatCovariance(<Nom de la matrice> [,<1ère ligne/1ère colonne> [,<2ème ligne/2ème colonne> [,<Ligne/Colonne>]]])

-Détail des paramètres

<Résultat> // Réel, covariance entre les deux séries de valeurs ou 0 si la covariance est nulle.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<1ère ligne/1ère colonne> // Entier optionnel, 1ère ligne ou 1ère colonne contenant les données (1 par défaut).

<2ème ligne/2ème colonne> // Entier optionnel, 2ème ligne ou 2ème colonne contenant les données (2 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai //(par défaut) si les séries de valeurs correspondent à des colonnes de la matrice,
Faux //si les séries de valeurs correspondent à des lignes de la matrice.

Notes

-Nombre d'éléments présents dans la matrice
//Le nombre d'éléments présents dans la matrice est pris comme référence.
//Ce nombre d'éléments correspond :
//au nombre de lignes de la matrice, connu avec MatNbLigne;
//au nombre de colonnes de la matrice, connu avec MatNbColonne.

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatCovariance ne retourne pas de code d'erreur.
//Pour savoir si le calcul de la covariance a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatEcartMoyen

Exemple

Utilisation

//Calcule la moyenne des écarts absolus des valeurs par rapport à leur moyenne arithmétique.

-Remarque : L'écart moyen donne la dispersion dans un ensemble de valeurs.

// Calcul de l'écart moyen des éléments de la ligne 1 d'une matrice
ResEcartMoyen = StatEcartMoyen("MaMatrice", 1, Faux)

Syntaxe

<Résultat> = StatEcartMoyen(<Nom de la matrice> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]])

-Détail des paramètres

<Résultat> // Réel, écart moyen des valeurs ou 0 si l'écart moyen est nul.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<Numéro de la ligne/colonne> // Entier optionnel, numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai // (par défaut) si la série de valeurs correspond à une colonne de la matrice,
Faux // si la série de valeurs correspond à une ligne de la matrice.

Notes

-Nombre d'éléments d'une ligne ou d'une colonne de la matrice
//Le nombre d'éléments présents dans une ligne ou dans une colonne de la matrice est pris comme référence. Ce nombre d'éléments correspond :
//au nombre total de lignes de la matrice, connu avec MatNbLigne (si le calcul s'effectue sur une colonne);
//au nombre total de colonnes de la matrice, connu avec MatNbColonne (si le calcul s'effectue sur une ligne).

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatEcartMoyen ne retourne pas de code d'erreur.
//Pour savoir si le calcul de l'écart moyen a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatEcartType

Exemple

Utilisation

//Calcule l'écart type d'une série de valeurs.

-Rappel :
//L'écart type est une mesure de la dispersion des valeurs par rapport à la valeur moyenne.

-Remarque :
//Ce calcul s'effectue sur un échantillon de valeurs. Pour calculer l'écart type sur une série complète de valeurs, utilisez la fonction StatEcartTypeP.

// Calcul de l'écart type des éléments de la ligne 1 d'une matrice
ResEcartType = StatEcartType("MaMatrice", 1, Faux)

Syntaxe

<Résultat> = StatEcartType(<Nom de la matrice> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]])

-Détail des paramètres

<Résultat> // Réel, écart type des valeurs ou 0 si l'écart type est nul.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<Numéro de la ligne/colonne> // Entier optionnel, numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai // (par défaut) si la série de valeurs correspond à une colonne de la matrice,
Faux // si la série de valeurs correspond à une ligne de la matrice.

Notes

-Nombre d'éléments d'une ligne ou d'une colonne de la matrice
//Le nombre d'éléments présents dans une ligne ou dans une colonne de la matrice est pris comme référence. Ce nombre d'éléments correspond :
//au nombre total de lignes de la matrice, connu avec MatNbLigne (si le calcul s'effectue sur une colonne);
//au nombre total de colonnes de la matrice, connu avec MatNbColonne (si le calcul s'effectue sur une ligne).

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatEcartType ne retourne pas de code d'erreur.
//Pour savoir si le calcul de l'écart type a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatEcartTypeP

Exemple

Utilisation

//Calcule l'écart type d'une série complète de valeurs.

-Rappel :
//L'écart type est une mesure de la dispersion des valeurs par rapport à la valeur moyenne.

-Remarque :
//La fonction StatEcartTypeP part de l'hypothèse que les arguments représentent l'ensemble de la population. Pour calculer l'écart type sur un échantillon de cette population, utilisez la fonction StatEcartType. Sur des échantillons de grande taille, les fonctions StatEcartTypeP et StatEcartType renvoient approximativement la même valeur.

// Calcul de l'écart type des éléments de la ligne 1 d'une matrice
ResEcartTypeP = StatEcartTypeP("MaMatrice", 1, Faux)

Syntaxe

<Résultat> = StatEcartTypeP(<Nom de la matrice> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]])

-Détail des paramètres

<Résultat> // Réel, écart type des valeurs ou 0 si l'écart type est nul.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<Numéro de la ligne/colonne> // Entier optionnel, numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai // (par défaut) si la série de valeurs correspond à une colonne de la matrice,
Faux // si la série de valeurs correspond à une ligne de la matrice.

Notes

-Nombre d'éléments d'une ligne ou d'une colonne de la matrice
//Le nombre d'éléments présents dans une ligne ou dans une colonne de la matrice est pris comme référence.
//Ce nombre d'éléments correspond :
//au nombre total de lignes de la matrice, connu avec MatNbLigne (si le calcul s'effectue sur une colonne);
//au nombre total de colonnes de la matrice, connu avec MatNbColonne (si le calcul s'effectue sur une ligne).

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatEcartTypeP ne retourne pas de code d'erreur.
//Pour savoir si le calcul de l'écart type a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatErreur

Exemple

Utilisation

//Calcule le numéro de la dernière erreur due à une fonction Statxx (fonctions statistiques).

// Identification du type d'erreur
ResErreur = StatErreur()

Syntaxe

<Résultat> = StatErreur()

-Détail du paramètre

<Résultat> // Entier, numéro de la dernière erreur due à une fonction statistique :
//Numéro, type d'erreur : fonctions concernées
//0, pas d'erreur : toutes les fonctions
//1, matrice vide : toutes les fonctions
//2, deux valeurs minimum sont nécessaires dans la ligne ou la colonne de la matrice : StatVariance, StatEcartMoyen
//3, moyenne géométrique négative : StatMoyenne, StatEcartType
//4, division par zéro : StatMoyenne, StatCorrélation
//5, la matrice n'existe pas : toutes les fonctions

Notes

-Libellé de l'erreur
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatMax

Exemple

Utilisation

//Calcule la valeur maximale d'une série de valeurs.

// Valeur maximale des éléments de la ligne 1 d'une matrice
ResMax = StatMax("MaMatrice", 1, Faux)

Syntaxe

<Résultat> = StatMax(<Nom de la matrice> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]])

-Détail des paramètres

<Résultat> // Réel, valeur maximale de la série.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<Numéro de la ligne/colonne> // Entier optionnel, numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai // (par défaut) si la série de valeurs correspond à une colonne de la matrice,
Faux // si la série de valeurs correspond à une ligne de la matrice.

Notes

-Nombre d'éléments d'une ligne ou d'une colonne de la matrice
//Le nombre d'éléments présents dans une ligne ou dans une colonne de la matrice est pris comme référence.
//Ce nombre d'éléments correspond :
//au nombre total de lignes de la matrice, connu avec MatNbLigne (si le calcul s'effectue sur une colonne);
//au nombre total de colonnes de la matrice, connu avec MatNbColonne (si le calcul s'effectue sur une ligne).

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatMax ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatMin

Exemple

Utilisation

//Calcule la valeur minimale d'une série de valeurs.

// Valeur minimale des éléments de la ligne 1 d'une matrice
ResMin = StatMin("MaMatrice", 1, Faux)

Syntaxe

<Résultat> = StatMin(<Nom de la matrice> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]])

-Détail des paramètres

<Résultat> // Réel, valeur minimale de la série.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<Numéro de la ligne/colonne> // Entier optionnel, numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai // (par défaut) si la série de valeurs correspond à une colonne de la matrice,
Faux // si la série de valeurs correspond à une ligne de la matrice.

Notes

-Nombre d'éléments d'une ligne ou d'une colonne de la matrice
//Le nombre d'éléments présents dans une ligne ou dans une colonne de la matrice est pris comme référence. Ce nombre d'éléments correspond :
//au nombre total de lignes de la matrice, connu avec MatNbLigne (si le calcul s'effectue sur une colonne);
//au nombre total de colonnes de la matrice, connu avec MatNbColonne (si le calcul s'effectue sur une ligne).

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatMin ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatMoyenne

Exemple

Utilisation

//Calcule la moyenne arithmétique, géométrique ou harmonique d'une série de valeurs.

// Moyenne arithmétique des éléments de la ligne 1 d'une matrice
ResMoyenne = StatMoyenne("MaMatrice", statArithmétique, 1, Faux)

Syntaxe

<Résultat> = StatMoyenne(<Nom de la matrice> [,<Type de moyenne> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]]])

-Détail des paramètres

<Résultat> // Réel, moyenne de la série.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<Type de moyenne> // Constante optionnelle, indique le type de moyenne à calculer :
statArithmétique // (par défaut), moyenne arithmétique
statGéométrique // Moyenne géométrique
statHarmonique //Moyenne harmonique

<Numéro de la ligne/colonne> // Entier optionnel, numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai // (par défaut) si la série de valeurs correspond à une colonne de la matrice,
Faux // si la série de valeurs correspond à une ligne de la matrice.

Notes

-Nombre d'éléments d'une ligne ou d'une colonne de la matrice
//Le nombre d'éléments présents dans une ligne ou dans une colonne de la matrice est pris comme référence.
//Ce nombre d'éléments correspond :
//au nombre total de lignes de la matrice, connu avec MatNbLigne (si le calcul s'effectue sur une colonne);
//au nombre total de colonnes de la matrice, connu avec MatNbColonne (si le calcul s'effectue sur une ligne).

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatMoyenne ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatSomme

Exemple

Utilisation

//Calcule le cumul d'une série de valeurs.

// Cumul des éléments de la ligne 1 d'une matrice
ResSomme = StatSomme("MaMatrice", 1, Faux)

Syntaxe

<Résultat> = StatSomme(<Nom de la matrice> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]])

-Détail des paramètres

<Résultat> // Réel, cumul des valeurs de la série.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<Numéro de la ligne/colonne> // Entier optionnel, numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai // (par défaut) si la série de valeurs correspond à une colonne de la matrice,
Faux // si la série de valeurs correspond à une ligne de la matrice.

Notes

-Nombre d'éléments d'une ligne ou d'une colonne de la matrice
//Le nombre d'éléments présents dans une ligne ou dans une colonne de la matrice est pris comme référence.
//Ce nombre d'éléments correspond :
//au nombre total de lignes de la matrice, connu avec MatNbLigne (si le calcul s'effectue sur une colonne);
//au nombre total de colonnes de la matrice, connu avec MatNbColonne (si le calcul s'effectue sur une ligne).

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatSomme ne retourne pas de code d'erreur.
//Pour savoir si cette fonction a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatVariance

Exemple

Utilisation

//Calcule la variance d'une série de valeurs.

-Remarque :
//Ce calcul s'effectue sur un échantillon de valeurs. Pour calculer la variance sur une série complète de valeurs, utilisez la fonction StatVarianceP.

// Calcul de la variance des éléments de la ligne 3
ResVariance = StatVariance("MaMatrice", 3, Faux)

Syntaxe

<Résultat> = StatVariance(<Nom de la matrice> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]])

-Détail des paramètres

<Résultat> // Réel, variance d'une série de valeurs.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<Numéro de la ligne/colonne> // Entier optionnel, numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai // (par défaut) si la série de valeurs correspond à une colonne de la matrice,
Faux // si la série de valeurs correspond à une ligne de la matrice.

Notes

-Nombre d'éléments d'une ligne ou d'une colonne de la matrice
//Le nombre d'éléments présents dans une ligne ou dans une colonne de la matrice est pris comme référence. Ce nombre d'éléments correspond :
//au nombre total de lignes de la matrice, connu avec MatNbLigne (si le calcul s'effectue sur une colonne);
//au nombre total de colonnes de la matrice, connu avec MatNbColonne (si le calcul s'effectue sur une ligne).

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatVariance ne retourne pas de code d'erreur.
//Pour savoir si le calcul de la variance a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


StatVarianceP

Exemple

Utilisation

//Calcule la variance d'une série complète de valeurs.

-Remarque :
//La fonction StatVarianceP part de l'hypothèse que les arguments représentent l'ensemble de la population. Pour calculer la variance sur un échantillon de cette population, utilisez la fonction StatVariance. Sur des échantillons de grande taille, les fonctions StatVarianceP et StatVariance renvoient approximativement la même valeur.

// Calcul de la variance des éléments de la ligne 3
ResVarianceP = StatVarianceP("MaMatrice", 3, Faux)

Syntaxe

<Résultat> = StatVarianceP(<Nom de la matrice> [,<Numéro de la ligne/colonne> [,<Ligne/Colonne>]])

-Détail des paramètres

<Résultat> // Réel, cariance d'une série complète de valeurs.

<Nom de la matrice> // Chaîne de caractères, nom de la matrice contenant les données, défini avec la fonction MatCrée.

<Numéro de la ligne/colonne> // Entier optionnel, numéro de la ligne ou de la colonne contenant les données (1 par défaut).

<Ligne/Colonne> // Booléen optionnel
Vrai // (par défaut) si la série de valeurs correspond à une colonne de la matrice,
Faux // si la série de valeurs correspond à une ligne de la matrice.

Notes

-Nombre d'éléments d'une ligne ou d'une colonne de la matrice
//Le nombre d'éléments présents dans une ligne ou dans une colonne de la matrice est pris comme référence. Ce nombre d'éléments correspond :
//au nombre total de lignes de la matrice, connu avec MatNbLigne (si le calcul s'effectue sur une colonne);
//au nombre total de colonnes de la matrice, connu avec MatNbColonne (si le calcul s'effectue sur une ligne).

//Si les séries comportent moins d'éléments que la matrice, les valeurs manquantes sont automatiquement complétées par des 0. Ces valeurs sont prises en compte lors des calculs.

-Gestion des erreurs
//Attention : La fonction StatVarianceP ne retourne pas de code d'erreur.
//Pour savoir si le calcul de la variance a généré des erreurs, utilisez la fonction StatErreur.
//Le libellé de l'erreur peut être connu grâce à la fonction ErreurInfo avec la constante errMessage.


Taille

Utilisation

//Renvoie la taille d'une chaîne de caractères, c'est-à-dire le nombre de caractères composant la chaîne de caractères (y compris les caractères espace et 0 binaire).

Taille("Quasimodo") // Renvoie 9
Taille(" Quasimodo ") // Renvoie 11
Taille("A" + Caract(0)) // Renvoie 2
Taille("") // Renvoie 0
Taille(" ") // Renvoie 1

Syntaxe

<Résultat> = Taille(<chaîne source>)

-Détail des paramètres

<Résultat> // Entier, nombre de caractères composant la chaîne.

<chaîne source> // Chaîne de caractères, chaîne de caractères dont la taille doit être calculée.


Tang

Utilisation

//Renvoie la tangente d'un angle.

// Tangente de 45
ResTangente = Tang(45)
// Renvoie 1

Syntaxe

<Résultat> = Tang(<Angle>)

-Détail des paramètres

<Résultat> // Réel, tangente de l'angle spécifié.

<Angle> // Entier ou réel, angle (en degrés) à manipuler.
//Si ce paramètre est égal à 90°, -90°, 270° ou -270°, une erreur du W-Langage est générée.


Trace

Utilisation

//Affiche des informations demandées (contenu d'un champ par exemple) dans une fenêtre ouverte en parallèle de la fenêtre en cours.

-Remarque :
//La fonction Trace est utile en phase de développement pour vérifier le bon déroulement du programme.

// Affichage d'informations dans le fenêtre de trace
Trace("Résultat du calcul : " + ResCalcul)

Syntaxe

Trace(<Informations> [, <Informations complémentaires> ...])

-Détail des paramètres

<Informations> // Tout type, ensemble des éléments à afficher dans la fenêtre de Trace.

<Informations complémentaires> // Tout type, élément supplémentaire à afficher dans la fenêtre de Trace.
//Sera affiché sur la même ligne que <Informations>.

Notes

-Fenêtre de Trace
//Les informations passées en paramètre sont affichées sur la ligne suivante de la fenêtre de Trace.
//La fenêtre de trace est ouverte automatiquement dès le premier appel à la fonction Trace (la fonction TraceDébut est exécutée automatiquement). Par défaut, cette fenêtre est ouverte en haut, à gauche de l'écran.
//Le fonctionnement de la fonction Trace est similaire à celui de la fonction Info mais l'affichage s'effectue dans une fenêtre parallèle, sans attente de touche.
//Si la fenêtre appelant la fenêtre de Trace perd le focus, la fenêtre de Trace devient invalide.

//Le menu contextuel de la fenêtre de Trace permet de :
//- copier/couper/coller le contenu de la fenêtre de Trace.
//- ouvrir la fenêtre de Trace au-dessus de toutes les autres fenêtres (y compris les fenêtres des autres applications).
//- mémoriser la taille et la position de la fenêtre de Trace lors de sa fermeture. Lors du ré-affichage de cette fenêtre, la fenêtre s'affichera selon la taille et la position mémorisées.
//- afficher un ascenseur horizontale.
//- afficher les caractères spéciaux en gris et en littéral : EOT, TAB, etc. Ainsi, les caractères "Retour Chariot" (RC) présents correspondent à "<\r><\n>".
//Remarque : Cette option sera prise en compte uniquement à partir de la prochaine ligne d'informations affichée.


TraceDébut

Utilisation

//Ouvre la fenêtre de Trace.

-Remarques :
//Si la fenêtre de Trace est déjà ouverte, la fonction TraceDébut n'a aucune action.

//La fonction TraceDébut est optionnelle.
//Le premier appel à la fonction Trace ouvre automatiquement la fenêtre de Trace.

// Ouvre la fenêtre de Trace au-dessus de toutes les fenêtres du système
TraceDébut(trDessusTout)

Syntaxe

TraceDébut([<Mode d'affichage>])

-Détail du paramètre

<Mode d'affichage> // Constante optionnelle
trDessusTout // si la fenêtre de Trace doit être affichée au-dessus de toutes les fenêtres du système.

//Par défaut, la fenêtre de Trace s'affiche en haut à gauche de l'écran.


TraceFin

Utilisation

//Ferme la fenêtre de Trace si cette fenêtre a été ouverte.

-Remarque :
//La fenêtre de Trace est fermée automatiquement à la fermeture du projet.

// Fermeture de le fenêtre de trace
TraceFin()

Syntaxe

TraceFin()


TypeVar

Utilisation

//Identifie le type d'une expression, d'une variable (lors d'un appel de procédure par exemple) ou d'un champ.

TypeVar(Paramètre)

Syntaxe

<Résultat> = TypeVar(<Expression>)

-Détail des paramètres

<Résultat> // Entier, identifie le type de la variable ou de la valeur du champ.
0 // pour les champs qui ne renvoient pas de valeur (bouton, champ OLE, etc.).
wlBooléen //Booléen
wlEntierSansSigne_1 //Entier non signé sur 1 octet
wlEntierSansSigne_2 //Entier non signé sur 2 octets
wlEntierSansSigne_4 //Entier non signé sur 4 octets
wlEntierSansSigne_8 //Entier non signé sur 8 octets
wlEntier_1 //Entier signé sur 1 octet
wlEntier_2 //Entier signé sur 2 octets
wlEntier //Entier signé sur 4 octets
wlEntier_8 //Entier signé sur 8 octets
wlMonétaire //Monétaire
wlRéel_4 //Réel sur 4 octets
wlRéel //Réel sur 8 octets
wlHandle //Handle de fenêtre
wlCaractère //Caractère
wlChaîne //Chaîne de caractères
wlSourceDeDonnées //Source de données
wlChaînePascal //Chaîne Pascal
wlChaîneFixe //Chaîne fixe
wlChaîneASCIIZ //Chaîne ASCIIZ
wlDate //Date
wlHeure //Heure
wlDateHeure //DateHeure
wlDurée //Durée
wlChaîneBinaire //Chaîne binaire
wlMémoBinaire //Mémo binaire
wlVariant //Variant
wlAutomation //Objet automation
wlChampOLE //Champ OLE
wlTableau //Tableau
wlVariableComposée //Variable composée
wlStructure //Structure
wlInstance //Instance de classe
wlDescriptionFichier //Description de fichier Hyper File
wlDescriptionRubrique //Description de rubrique Hyper File
wlDescriptionLiaison //Description de liaison Hyper File
wlPolice //Police

<Expression> // Chaîne de caractères, nom de la variable W-Langage ou du champ dont on veut connaître le type.


TypeVariable

Utilisation

//Identifie le type d'une variable du W-Langage.

SI TypeVariable(Var1)<>12 ALORS
Aresult("Var1 n'est pas de type chaîne de caractères")
SINON
Aresult("Var1 est de type chaîne de caractères")
FIN

Syntaxe

<Résultat> = TypeVariable(<Nom de la variable>)

-Détail des paramètres

<Résultat> // Entier, identifie le type de la variable.
1 //Entier
2 //Entier non signé
3 //Entier long
6 //Réel simple
7 //Réel turbo
8 //Réel double
12 //Caractères et chaîne de caractères, (chaîne, chaîne fixe, chaîne ASCIIZ, chaîne Pascal)
17 //Entier court et booléen
18 //Monétaire

<Nom de la variable> // Chaîne de caractères, nom de la variable W-Langage.


TableauCherche

Utilisation

Cherche l'indice d'un élément dans un tableau.Il est possible d'effectuer les recherches suivantes :
- Recherche d'un élément dans un tableau d'éléments simples à une dimension.
- Recherche d'un élément dans un tableau d'éléments simples à 2 dimensions selon une colonne.
- Recherche d'un élément dans un tableau d'éléments simples à 2 dimensions selon plusieurs colonnes.
- Recherche d'un élément dans un tableau de structures ou de classes à une dimension.

// Remplir le tableau
MonTableau est un tableau de 0 chaîne
TableauAjoute(MonTableau, "True-World")
TableauAjoute(MonTableau, " True-World")
TableauAjoute(MonTableau, "True-World et True")

// Chercher "True-World"
ResIndice est un entier
ResIndice = TableauCherche(MonTableau, tcLinéairePremier, "True-World")

Info("La chaîne True-World est à l'indice : "+ResIndice)
// Retourne : "La chaîne True-World est à l'indice : 1"

Syntaxe
Recherche d'un élément dans un tableau d'éléments simples à 1 dimension
<Résultat>= TableauCherche(<Nom du tableau>, <Type de recherche>, <Valeur recherchée> [, <Indice de départ>])
-Détail des paramètres

<Résultat> // EntierIndice de l'élément recherché
-1 si l'élément n'est pas trouvé dans le tableau

<Nom du tableau> // TableauNom de la variable de type Tableau à manipulerCe tableau doit être un tableau à une dimension

<Type de recherche> // Constante de type entierType de recherche à effectuer :

tcDichotomique
Recherche dichotomique.
Ce mode de recherche est rapide mais il doit être utilisé sur un tableau trié par ordre croissant, sans doublons (voir fonction TableauTrie).

tcLinéaire
Recherche linéaire. La recherche d soit à partir du premier élément
- soit à partir de l'<Indice de départ>
La recherche s'arrête au premier élément trouvé.

tcLinéaireDernier
Recherche linéaire à partir du dernier élémentCette constante ne doit pas être utilisée si l'<Indice de départ> est précisé

tcLinéairePrécédent
Recherche linéaire de l'élément précédentCette recherche est effectuée à partir de la position en cours ou de l'<Indice de départ>

tcLinéairePremier
Recherche linéaire à partir du premier élémentLorsque cette constante est utilisée, l'<Indice de départ> n'est pas pris en compte

tcLinéaireSuivant
Recherche linéaire de l'élément suivantCette recherche est effectuée à partir de la position en cours ou de l'<Indice de départ>
<Nom du tableau> // TableauNom de la variable de type Tableau à manipulerCe tableau doit être un tableau à une dimension

<Nom du tableau> // TableauNom de la variable de type Tableau à manipulerCe tableau doit être un tableau à une dimension


ZFinAmortissementDégressif

Exemple d'utilisation de la fonction FinAmortissementDégressif

-Valeur d'un amortissement à taux fixe

//Le code suivant permet de connaître la valeur d'un amortissement.
//Le coût d'acquisition et la valeur résiduelle du bien, la durée d'amortissement, la période pour laquelle l'amortissement doit être calculé et le nombre de mois de la première année d'amortissement sont saisis par l'utilisateur dans des champs de saisie (Coût, ValRésiduelle, Durée, Période, NbMois).

// Déclaration de la variable
Res est un réel

// Calcul de la valeur d'amortissement
Res = FinAmortissementDégressif(Coût, ValRésiduelle, Durée, Période, NbMois)

SI Res <> 0 ALORS
// Affichage du résultat
Aresult("La valeur d'amortissement est : "+Res)
SINON
SI Res = 0 ALORS
SI FinErreur = 0 ALORS
Aresult("La valeur d'amortissement est nulle")
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN
FIN
FIN


ZFinAmortissementLinéaire

Exemple d'utilisation de la fonction FinAmortissementLinéaire

-Valeur d'un amortissement linéaire

//Le code suivant permet de connaître la valeur d'un amortissement.

// Déclaration de la variable
Res est un réel

// Calcul de la valeur d'amortissement
Res = FinAmortissementLinéaire(Coût, ValRésiduelle, Durée)

SI Res <> 0 ALORS
// Affichage du résultat
Aresult("La valeur d'amortissement est : "+Res)
SINON
SI Res = 0 ALORS
SI FinErreur = 0 ALORS
Aresult("La valeur d'amortissement est nulle")
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN
FIN
FIN


ZFinErreur

Exemple d'utilisation de la fonction FinErreur

-Affichage du message d'erreur

//Le code suivant permet de connaître la valeur d'un amortissement.

// Déclaration de la variable
Res est un réel

// Calcul de la valeur d'amortissement
Res = FinAmortissementDégressif(Coût, ValRésiduelle, Durée, Période, NbMois)

SI Res <> 0 ALORS
// Affichage du résultat
Aresult("La valeur d'amortissement est : "+ResValAmortissement)
SINON
SI Res = 0 ALORS
// Erreur ?
SI FinErreur = 0 ALORS
Aresult("La valeur d'amortissement est nulle")
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN
FIN
FIN


ZFinIntérêtPériode

Exemple d'utilisation de la fonction FinIntérêtPériode

-Montant des intérêt dus

//Le code suivant permet de connaître le montant des intérêts dus.

//On considère que les valeurs saisies par l'utilisateur correspondent à la même unité temporelle.

// Déclaration de la variable
Res est un réel

// Calcul du montant des intérêts dus
Res = FinIntérêtPériode(Montant, Taux, Période, Durée)

SI FinErreur = 0 ALORS
Aresult("Le montant des intérêts dus est : "+Res)
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN


ZFinNbVersement

Exemple d'utilisation de la fonction FinNbVersement

-Nombre de versements nécessaires pour rembourser un capital

//Le code suivant permet de connaître le nombre de versements nécessaires pour rembourser un capital.

// Déclaration de la variable
Res est un réel

// Calcul du nombre de versements
Res = FinNbVersement(-ValeurRemb, Taux, Montant)

SI FinErreur = 0 ALORS
Aresult(Res+" versements sont nécessaires")
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN


ZFinTauxIntérêt

Exemple d'utilisation de la fonction FinTauxIntérêt

-Évaluation du taux d'intérêt d'un emprunt

//Le code suivant permet d'évaluer le taux d'intérêt d'un emprunt.

// Déclaration de la variable
Res est un réel

// Calcul du taux d'intérêt
Res = FinTauxIntérêt(NbVersement, -ValeurRemb, Montant)

SI FinErreur = 0 ALORS
Aresult("Le taux d'intérêt est : "+Res)
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN


ZFinValActuelle

Exemple d'utilisation de la fonction FinValActuelle

-Valeur actuelle d'un investissement

//Le code suivant permet d'obtenir la valeur actuelle d'un investissement.
//On considère que les paiements doivent être effectués en fin de période (constante Faux).

// Déclaration de la variable
Res est un réel

// Calcul de la valeur actuelle
ResRes = FinValActuelle(-ValeurRemb, ValeurFuture, NbPériode, Taux, Faux)

SI FinErreur = 0 ALORS
Aresult("La valeur actuelle est : "+Res)
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN


ZFinValActuelleNette

Exemple d'utilisation de la fonction FinValActuelleNette

-Valeur actuelle nette d'un investissement

//Le code suivant permet d'obtenir la valeur actuelle nette d'un investissement.
//Cet investissement de 100.000 F doit rapporter :
//6000 F la première année,
//- 3000 F la seconde,
//4500 la troisième,
//8000 la dernière.
//Le taux d'actualisation annuelle : 10 %

// Déclaration de la variable
Res est un réel

// Création et initialisation de la matrice
MatCrée("Matrice")
MatEcrit("Matrice", -100000, 1, 1)
MatEcrit("Matrice", 6000, 1, 2)
MatEcrit("Matrice", -3000, 1, 3)
MatEcrit("Matrice", 4500, 1, 4)
MatEcrit("Matrice", 8000, 1, 5)

// Calcul de la valeur actuelle nette
Res = FinValActuelleNette(10, "Matrice", 1)

SI FinErreur = 0 ALORS
Aresult("La valeur actuelle nette est : "+Res)
SINON
Aresult(errMessage)) // Affichage du message d'erreur
FIN


ZFinValFuture

Exemple d'utilisation de la fonction FinValFuture

// Déclaration de la variable
Res est un réel

// Calcul de la valeur actuelle
Res = FinValFuture(-CapitalInit, -Dépôt, NbPériode, Taux, Faux)

SI FinErreur = 0 ALORS
Aresult("La valeur future est : "+Res)
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN


ZFinValRemboursement

Exemple d'utilisation de la fonction FinValRemboursement

-Montant de chaque remboursement d'un investissement

//Le code suivant permet d'obtenir le montant de chaque remboursement d'un investissement.

//On considère que les paiements doivent être effectués en fin de période (constante Faux).

// Déclaration de la variable
Res est un réel

// Calcul de la valeur actuelle
Res = FinValRemboursement(-CapitalInit, NbPériode, Taux, Faux)

SI FinErreur = 0 ALORS
Aresult("La montant de chaque remboursement est : "+Res)
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN


ZMatAdditionne

Exemple d'utilisation de la fonction MatAdditionne

-Addition de deux matrices de mêmes dimensions

//Le code suivant permet d'additionner deux matrices.

//Pour cet exemple, on considère que les matrices ont été préalablement créées.
//L'existence des deux matrices est testée avec MatExiste.
//Les deux matrices doivent être de mêmes dimensions (même nombre de colonnes vérifié avec MatNbColonne, même nombre de lignes vérifié avec MatNbLigne).

// Déclaration des variables
ResAddition est un booléen

// Teste l'existence des matrices
SI MatExiste("Matrice1") ET MatExiste("Matrice2") ALORS
// Même nombre de lignes ?
SI MatNbLigne("Matrice1") = MatNbLigne("Matrice2") ALORS
// Même nombre de colonnes ?
SI MatNbColonne("Matrice1") = MatNbColonne("Matrice2") ALORS
// Addition des deux matrices
ResAddition = MatAdditionne("Matrice1", "Matrice2", "MatriceRésultat")
SI ResAddition = Vrai ALORS
Aresult("L'addition a été effectuée")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
SINON
Aresult("Les matrices n'ont pas le même nombre de colonnes")
FIN
SINON
Aresult("Les matrices n'ont pas le même nombre de lignes")
FIN
SINON
Aresult("Les matrices n'existent pas")
FIN


ZMatCompresse

Exemple d'utilisation de la fonction MatCompresse

-Compression d'une matrice

//Le code suivant permet de compresser une matrice.
//Le nom de la matrice est saisi par l'utilisateur dans un champ de saisie (NomMatrice).

//On considère que la matrice à compresser a été préalablement créée.

-Compression de la matrice
MatCompresse(NomMatrice)

// Erreur ?
SI Aresult(MatErreur(NomMatrice)) = 0 ALORS
Aresult("La compression a été effectuée")
SINON
Aresult(ErreurInfo(errMessage)) // Affichage du message d'erreur
FIN


ZMatCopie

Exemple d'utilisation de la fonction MatCopie

-Copie d'une matrice

//Le code suivant permet de copier une matrice.
//Le nom de la matrice de base est saisi par l'utilisateur dans un champ de saisie (NomMatrice).

//On considère que la matrice à copier a été préalablement créée.
//L'existence de la matrice est testée avec MatExiste.

-Déclaration des variables
Res est un booléen

-Teste l'existence de la matrice

SI MatExiste(NomMatrice) = Vrai ALORS
// Copie de la matrice
Res = MatCopie(NomMatrice, "MaMatriceCopie")
SI Res = Vrai ALORS
Aresult("La matrice a été copiée")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
SINON
Aresult("La matrice n'existe pas")
FIN


ZMatCrée

Exemple d'utilisation de la fonction MatCrée

-Création d'une matrice

//Le code suivant permet de créer une matrice.
//L'existence de la matrice est testée avec MatExiste avant la création de la matrice.

-Déclaration des variables
ResExiste est un booléen
ResEcrase est un booléen
ResCréation est un booléen

-Teste l'existence de la matrice
ResExiste = MatExiste(NomMatrice)

-La matrice existe
SI ResExiste = Vrai ALORS
// La matrice existe
FIN

-La matrice n'existe pas ou la matrice existante doit être écrasée
SI ResExiste = Faux OU ResEcrase = Vrai ALORS
ResCréation = MatCrée(NomMatrice) // Création de la matrice
FIN

-Erreur ?
SI ResCréation = Faux
Erreur(ErreurInfo(errMessage)) // Affichage du message d'erreur
SINON
Aresult("La matrice a été créée")
FIN


ZMatDéterminant

Exemple d'utilisation de la fonction MatDéterminant

-Calcul du déterminant d'une matrice

//Le code suivant permet de calculer le déterminant d'une matrice.
//On considère que la matrice a été préalablement créée.
//L'existence de la matrice est testée avec MatExiste.
//Le nombre de colonnes de la matrice doit être égal au nombre de lignes de la matrice.

// Déclaration des variables
ResDéterminant est un réel

// Teste l'existence de la matrice
SI MatExiste(NomMatrice) = Vrai ALORS
// Nb. colonnes de la matrice = Nb. lignes de la matrice ?
SI MatNbColonne(NomMatrice) = MatNbLigne(NomMatrice) ALORS
// Calcul du déterminant
ResDéterminant = MatDéterminant(NomMatrice)
SI ResDéterminant <> 0 ALORS
Aresult("La valeur du déterminant est : "+ResDéterminant)
SINON
// Erreur ?
SI Aresult(MatErreur(NomMatrice)) = 0 ALORS
Aresult("Le déterminant est nul")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
FIN
SINON
Aresult("Le nombre de colonnes n'est pas égal au nombre de lignes")
FIN
SINON
Info("La matrice n'existe pas")
FIN


ZMatEcrit

Exemple d'utilisation de la fonction MatEcrit

-Écriture dans une matrice

//Le code suivant permet d'écrire dans une matrice.
//L'élément (ligne2, colonne3) reçoit la valeur 7.

//L'existence de la matrice est testée avec MatExiste.
//La matrice est créée avec MatCrée.
//Le nom de la matrice est saisi par l'utilisateur dans un champ de saisie (NomMatrice).

// Déclaration des variables
ResExiste est un booléen
ResEcrase est un booléen
ResCréation est un booléen
ResEcriture est un booléen

// Teste l'existence de la matrice
ResExiste = MatExiste(NomMatrice)

// La matrice existe
SI ResExiste = Vrai ALORS
// Écrasement de la matrice ?
ResEcrase = OuiNon("Cette matrice existe déjà. Voulez-vous l'écraser ?")
FIN

// La matrice n'existe pas ou la matrice doit être écrasée
SI ResExiste = Faux OU ResEcrase = Vrai ALORS
// Création de la matrice
ResCréation = MatCrée(NomMatrice)
FIN

// Erreur ?
SI ResCréation = Faux
Aresult(ErreurInfo(errMessage))
SINON
// Écriture dans la matrice
// Rappel : L'élément (ligne2, colonne3) reçoit la valeur 7
ResEcriture = MatEcrit(NomMatrice, 7, 2, 3)
SI ResEcriture = Vrai
Aresult("L'écriture a été effectuée")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
FIN


ZMatErreur

Exemple d'utilisation de la fonction MatErreur

-Affichage du message d'erreur

//Le code suivant permet d'afficher la dernière erreur survenue sur une matrice.

// Déclaration de la variable
ResErreur est un entier

// Erreur survenue sur la matrice ?
ResErreur = MatErreur(NomMatrice)

// Affichage du message d'erreur
SI ResErreur <> 0 ALORS
Aresult(ErreurInfo(errMessage))
FIN


ZMatExiste

Exemple d'utilisation de la fonction MatExiste

-Tester l'existence d'une matrice

//Le code suivant permet de savoir si une matrice existe.

// Déclaration des variables
ResExiste est un booléen

// Teste l'existence de la matrice
ResExiste = MatExiste(NomMatrice)
SI ResExiste = Vrai ALORS
Aresult("La matrice existe")
SINON
Aresult(ErreurInfo(errMessage))
FIN


ZMatInverse

Exemple d'utilisation de la fonction MatInverse

-Inversion d'une matrice

//Le code suivant permet d'inverser une matrice.
//On considère que la matrice a été préalablement créée.
//L'existence de la matrice est testée avec MatExiste.
//Le nombre de colonnes de la matrice doit être égal au nombre de lignes de la matrice.
//Le déterminant ne doit pas être nul.

// Déclaration des variables
ResInversion est un booléen

// Teste l'existence de la matrice
SI MatExiste(NomMatrice) = Vrai ALORS
// Nb. colonnes de la matrice = Nb. lignes de la matrice ?
SI MatNbColonne(NomMatrice) = MatNbLigne(NomMatrice) ALORS
// Déterminant non nul ?
SI MatDéterminant(NomMatrice) <> 0 ALORS
// Inversion de la matrice
ResInversion = MatInverse(NomMatrice, "MaMatriceInversion")
// Erreur ?
SI ResInversion = Vrai ALORS
Aresult("L'inversion a été effectuée")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
SINON
Aresult("Le déterminant est nul")
FIN
SINON
Aresult("Le nombre de colonnes n'est pas égal au nombre de lignes")
FIN
SINON
Aresult("La matrice n'existe pas")
FIN


ZMatLit

Exemple d'utilisation de la fonction MatLit

-Lecture d'un élément dans une matrice

//Le code suivant permet de lire la valeur d'un élément dans une matrice.

// Déclaration de la variable
ResLecture est un réel

// Lecture de l'élément
ResLecture = MatLit(NomMatrice, LigneElément, ColonneElément)
// Erreur ?
SI Aresult(MatErreur(NomMatrice)) = 0 ALORS
Aresult("La valeur de l'élément (ligne "+LigneElément+",...
colonne "+ColonneElément+") est : "+ResLecture)
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZMatLitColonne

Exemple d'utilisation de la fonction MatLitColonne

-Lecture des éléments d'une colonne dans une matrice

//Le code suivant permet de lire la valeur des éléments d'une colonne dans une matrice.

// Déclaration de la variable
ResLectureColonne est une chaîne de caractères

// Lecture des éléments de la colonne. Chaque élément contiendra 10
// caractères dont 2 chiffres après la virgule, dans un format réel.
ResLectureColonne = MatLitColonne(NomMatrice, ColonneElément, "10.2f")
// Erreur ?
SI Aresult(MatErreur(NomMatrice)) = 0 ALORS
Aresult("Les éléments de la colonne "+ColonneElément+" sont : "+ResLectureColonne)
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZMatLitLigne

Exemple d'utilisation de la fonction MatLitLigne

-Lecture des éléments d'une ligne dans une matrice

//Le code suivant permet de lire la valeur des éléments d'une ligne dans une matrice.

// Déclaration de la variable
ResLectureLigne est une chaîne de caractères

// Lecture des éléments de la ligne. Chaque élément contiendra 10
// caractères dont 2 chiffres après la virgule, dans un format réel.
ResLectureLigne = MatLitLigne(NomMatrice, LigneElément, "10.2f")
// Erreur ?
SI Aresult(MatErreur(NomMatrice)) = 0 ALORS
Aresult("Les éléments de la ligne "+LigneElément+" sont : "+ResLectureLigne)
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZMatMultiplie

Exemple d'utilisation de la fonction MatMultiplie

-Multiplication de deux matrices

//Le code suivant permet de multiplier deux matrices.
//On considère que les matrices ont été préalablement créées.
//L'existence des deux matrices est testée avec MatExiste.
//Le nombre de colonnes de la 1ère matrice doit être égal au nombre de lignes de la 2ème matrice.

// Déclaration des variables
ResMultiplie est un booléen

// Teste l'existence des matrices
SI MatExiste("Matrice1") ET MatExiste("Matrice2") ALORS
// Nb. colonnes de la 1ère matrice = Nb. lignes de la 2ème matrice ?
SI MatNbColonne("Matrice1") = MatNbLigne("Matrice2") ALORS
// Multiplication des deux matrices
ResMultiplie = MatMultiplie("Matrice1", "Matrice2", "MatriceRésultat")
SI ResMultiplie = Vrai ALORS
Aresult("La multiplication a été effectuée")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
SINON
Aresult("Le nombre de colonnes n'est pas égal au nombre de lignes")
FIN
SINON
Aresult("Les matrices n'existent pas")
FIN


ZMatNbColonne

Exemple d'utilisation de la fonction MatNbColonne

-Nombre de colonnes d'une matrice

//Le code suivant permet de connaître le nombre de colonnes d'une matrice.

// Déclaration de la variable
ResNbColonne est un entier

// Nombre de colonnes ?
ResNbColonne = MatNbColonne(NomMatrice)
// Erreur ?
SI Aresult(MatErreur(NomMatrice)) = 0 ALORS
Aresult("La matrice contient : "+ResNbColonne+" colonne(s)")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZMatNbLigne

Exemple d'utilisation de la fonction MatNbLigne

-Nombre de lignes d'une matrice

//Le code suivant permet de connaître le nombre de lignes d'une matrice.

// Déclaration de la variable
ResNbLigne est un entier

// Nombre de lignes ?
ResNbLigne = MatNbLigne(NomMatrice)
// Erreur ?
SI Aresult(MatErreur(NomMatrice)) = 0 ALORS
Aresult("La matrice contient : "+ResNbLigne+" ligne(s)")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZMatRéelAdditionne

Exemple d'utilisation de la fonction MatRéelAdditionne

-Addition d'une valeur à tous les éléments d'une matrice

//Le code suivant permet d'additionner la valeur 5 à tous les éléments d'une matrice.

//On considère que la matrice a été préalablement créée. L'existence de la matrice est testée avec MatExiste.

// Déclaration des variables
ResRéelAddition est un booléen

// Teste l'existence de la matrice
SI MatExiste(NomMatrice) ALORS
// Additionne la valeur 5 à tous les éléments de la matrice
MatRéelAdditionne(NomMatrice, 5)
// Erreur ?
SI Aresult(MatErreur(NomMatrice)) = 0 ALORS
Aresult("L'addition a été effectuée")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
SINON
Aresult("La matrice n'existe pas")
FIN


ZMatRéelMultiplie

Exemple d'utilisation de la fonction MatRéelMultiplie

-Multiplication des éléments d'une matrice par une valeur

//Le code suivant permet de multiplier tous les éléments d'une matrice par la valeur 5.

//On considère que la matrice a été préalablement créée.
//L'existence de la matrice est testée avec MatExiste.

// Teste l'existence de la matrice
SI MatExiste(NomMatrice) ALORS
// Multiplication des éléments de la matrice par la valeur 5
MatRéelMultiplie(NomMatrice, 5)
// Erreur ?
SI Aresult(MatErreur(NomMatrice)) = 0 ALORS
Aresult("La multiplication a été effectuée")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
SINON
Aresult("La matrice n'existe pas")
FIN


ZMatRemplit

Exemple d'utilisation de la fonction MatRemplit

-Remplissage d'une matrice

//Le code suivant permet de remplir une matrice.
//Cette matrice est remplie de la ligne 1 à 5 et de la colonne 1 à 3 par la valeur 7.

//L'existence de la matrice est testée avec MatExiste.
//La matrice est créée avec MatCrée.

// Déclaration des variables
ResExiste est un booléen
ResEcrase est un booléen
ResCréation est un booléen
ResRemplissage est un booléen

// Teste l'existence de la matrice
ResExiste = MatExiste(NomMatrice)

// La matrice existe
SI ResExiste = Vrai ALORS
// Écrasement de la matrice ?
ResEcrase = OuiNon("Cette matrice existe déjà. Voulez-vous l'écraser ?")
FIN

// La matrice n'existe pas ou doit être écrasée
SI ResExiste = Faux OU ResEcrase = Vrai ALORS
// Création de la matrice
ResCréation = MatCrée(NomMatrice)
FIN

// Erreur ?
SI ResCréation = Faux
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
SINON
// Remplissage de la matrice.
// Remplissage de la ligne 1 à 5 et de la colonne 1 à 3 par la valeur 7.
ResRemplissage = MatRemplit(NomMatrice, 7, 5, 3)
// Erreur ?
SI ResRemplissage = Vrai
Aresult("La matrice a été remplie")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZMatSupprime

Exemple d'utilisation de la fonction MatSupprime

-Suppression d'une matrice

//Le code suivant permet de supprimer une matrice.

//On considère que la matrice à supprimer a été préalablement créée.

// Suppression de la matrice
MatSupprime(NomMatrice)
Aresult("La suppression a été effectuée")


ZMatTranspose

Exemple d'utilisation de la fonction MatTranspose

-Calcul de la transposée d'une matrice

//Le code suivant permet de calculer la transposée d'une matrice.
//On considère que la matrice a été préalablement créée. L'existence de la matrice est testée avec MatExiste.

// Déclaration des variables
ResTranspose est un booléen

// Teste l'existence de la matrice
SI MatExiste(NomMatrice) = Vrai ALORS
// Calcul de la transposée de la matrice
ResTranspose = MatTranspose(NomMatrice, "MaMatriceTransposée")
// Erreur ?
SI ResTranspose = Vrai ALORS
Aresult("Le calcul de la transposée a été effectué")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
SINON
Aresult("La matrice n'existe pas")
FIN


ZStatCorrélation

Exemple d'utilisation de la fonction StatCorrélation

-Calcul du coefficient de corrélation

//Le code suivant permet de calculer le coefficient de corrélation entre la ligne 3 et la ligne 5 d'une matrice.
//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResCoefCorrélation est un réel

// Coefficient de corrélation entre la ligne 3 et la ligne 5 de la matrice
ResCoefCorrélation = StatCorrélation("MaMatrice", 3, 5, Faux)

// Affichage du coefficient
SI ResCoefCorrélation <> 0 ALORS
Aresult("Le coefficient de corrélation est : "+ResCoefCorrélation)
SINON
// Erreur de calcul du coefficient de corrélation ?
SI StatErreur <> 0 ALORS
Aresult("Le coefficient de corrélation est nul")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
FIN


ZStatCovariance

Exemple d'utilisation de la fonction StatCovariance

-Calcul de la covariance

//Le code suivant permet de calculer la covariance entre la ligne 3 et la ligne 5 d'une matrice.
//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResCovariance est un réel

// Covariance entre les éléments de la ligne 3 et les éléments de la ligne 5
ResCovariance = StatCovariance("MaMatrice", 3, 5, Faux)

// Affichage de la covariance
SI ResCovariance <> 0 ALORS
Aresult("La covariance est : "+ResCovariance)
SINON
// Erreur de calcul de la covariance ?
SI StatErreur <> 0 ALORS
Aresult("La covariance est nulle")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
FIN


ZStatEcartMoyen

Exemple d'utilisation de la fonction StatEcartMoyen

-Calcul de l'écart moyen

//Le code suivant permet de calculer l'écart moyen de la valeur des éléments de la ligne 3.

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResEcartMoyen est un réel

// Écart moyen de la valeur des éléments de la ligne 3
ResEcartMoyen = StatEcartMoyen("MaMatrice", 3, Faux)

// Affichage du résultat
SI ResEcartMoyen <> 0 ALORS
Aresult("L'écart moyen est : "+ResEcartMoyen)
SINON
// Erreur de calcul de l'écart moyen ?
SI StatErreur <> 0 ALORS
Aresult("L'écart moyen est nul")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
FIN


ZStatEcartType

Exemple d'utilisation de la fonction StatEcartType

-Calcul de l'écart type

//Le code suivant permet de calculer l'écart type de la valeur des éléments de la ligne 3.

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResEcartType est un réel

// Écart type de la valeur des éléments de la ligne 3
ResEcartType = StatEcartType("MaMatrice", 3, Faux)

// Affichage du résultat
SI ResEcartType <> 0 ALORS
Aresult("L'écart type est : "+ResEcartType)
SINON
// Erreur de calcul de l'écart type ?
SI StatErreur <> 0 ALORS
Aresult("L'écart type est nul")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
FIN


ZStatEcartTypeP

Exemple d'utilisation de la fonction StatEcartTypeP

-Calcul de l'écart type

//Le code suivant permet de calculer l'écart type de la valeur des éléments de la ligne 3.
//La valeur des éléments de cette ligne représente l'ensemble de la population.

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResEcartTypeP est un réel

// Écart type de la valeur des éléments de la ligne 3
ResEcartTypeP = StatEcartTypeP("MaMatrice", 3, Faux)

// Affichage du résultat
SI ResEcartTypeP <> 0 ALORS
Aresult("L'écart type est : "+ResEcartTypeP)
SINON
// Erreur de calcul de l'écart type ?
SI StatErreur <> 0 ALORS
Aresult("L'écart type est nul")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
FIN


ZStatErreur

Exemple d'utilisation de la fonction StatErreur

-Affichage du message d'erreur

//Le code suivant permet de calculer l'écart type de la valeur des éléments de la ligne 3.
//La fonction StatErreur permet de vérifier qu'aucune erreur n'a été générée lors de ce calcul

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResEcartType est un réel

// Écart type de la valeur des éléments de la ligne 3
ResEcartType = StatEcartType("MaMatrice", 3, Faux)

// Affichage du résultat
SI ResEcartType <> 0 ALORS
Aresult("L'écart type est : "+ResEcartType)
SINON
// Erreur de calcul de l'écart type ?
SI StatErreur <> 0 ALORS
Aresult("L'écart type est nul")
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN
FIN


ZStatMax

Exemple d'utilisation de la fonction StatMax

-Connaître la valeur maximale d'une série de valeurs

//Le code suivant permet d'obtenir la valeur maximale des éléments de la ligne 3.

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResMax est un réel

// Valeur maximale des éléments de la ligne 3
ResMax = StatMax("MaMatrice", 3, Faux)

// Erreur sur la fonction StatMax ?
SI StatErreur = 0 ALORS
// Affichage du résultat
Aresult("La valeur maximale est : "+ResMax)
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZStatMin

Exemple d'utilisation de la fonction StatMin

-Connaître la valeur minimale d'une série de valeurs

//Le code suivant permet d'obtenir la valeur minimale des éléments de la ligne 3.

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResMin est un réel

// Valeur minimale des éléments de la ligne 3
ResMin = StatMin("MaMatrice", 3, Faux)

// Erreur sur la fonction StatMin ?
SI StatErreur = 0 ALORS
// Affichage du résultat
Aresult("La valeur minimale est : "+ResMin)
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZStatMoyenne

Exemple d'utilisation de la fonction StatMoyenne

-Calcul de la moyenne géométrique d'une série de valeurs

//Le code suivant permet de calculer la moyenne géométrique (constante statGéométrique) des éléments de la ligne 3.

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResMoyenne est un réel

// Moyenne géométrique des éléments de la ligne 3
ResMoyenne = StatMoyenne("MaMatrice", statGéométrique, 3, Faux)

// Erreur sur la fonction StatMoyenne ?
SI StatErreur = 0 ALORS
// Affichage du résultat
Aresult("La moyenne géométrique est : "+ResMoyenne)
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZStatSomme

Exemple d'utilisation de la fonction StatSomme

-Cumul d'une série de valeurs

//Le code suivant permet de cumuler les éléments de la ligne 3.

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResSomme est un réel

// Cumul des éléments de la ligne 3
ResSomme = StatSomme("MaMatrice", 3, Faux)

// Erreur sur la fonction StatSomme ?
SI StatErreur = 0 ALORS
// Affichage du résultat
Aresult("Le cumul est : "+ResSomme)
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZStatVariance

Exemple d'utilisation de la fonction StatVariance

-Calcul de la variance

//Le code suivant permet de calculer la variance des éléments de la ligne 3 d'une matrice.

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResVariance est un réel

// Variance des éléments de la ligne 3
ResVariance = StatVariance("MaMatrice", 3, Faux)

// Erreur de calcul de la variance ?
SI StatErreur = 0 ALORS
// Affichage de la variance
Aresult("La variance est : "+ResVariance)
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


ZStatVarianceP

Exemple d'utilisation de la fonction StatVarianceP

-Calcul de la variance

//Le code suivant permet de calculer la variance des éléments de la ligne 3 d'une matrice. La valeur des éléments de cette ligne représente l'ensemble de la population.

//On considère que la matrice a été préalablement créée et initialisée.

// Déclaration des variables
ResVarianceP est un réel

// Variance des éléments de la ligne 3
ResVarianceP = StatVarianceP("MaMatrice", 3, Faux)

// Erreur de calcul de la variance ?
SI StatErreur = 0 ALORS
// Affichage de la variance
Aresult("La variance est : "+ResVarianceP)
SINON
// Affichage du message d'erreur
Aresult(ErreurInfo(errMessage))
FIN


Val

Utilisation

//Renvoie la valeur numérique d'une chaîne de caractères. Il est ainsi possible d'effectuer des calculs numériques sur des chaînes de caractères.

Val("143") // Renvoie 143
Val("1.67") // Renvoie 1,67
Val("ABC") // Renvoie 0
Val("3plus2") // Renvoie 3
Val("7,5") // Renvoie 7
Val("1D2") // Renvoie 100
Val("2.5e-2") // Renvoie 0.025

Syntaxe

<Résultat> = Val(<chaîne source> [, <Base utilisée>])

-Détail des paramètres

<Résultat> // Réel ou entier, valeur numérique de la chaîne.
0 // en cas d'erreur.

<chaîne source> // Chaîne de caractères, chaîne de caractères à convertir en valeur numérique. Pour un réel, le séparateur doit être le point '.' et les préfixes de notation scientifique peuvent être 'E', 'e', 'D' ou 'd'.
// Si le séparateur est une virgule, les chiffres présents après la virgule ne seront pas pris en compte.

<Base utilisée> // Chaîne de caractères ou entier (optionnel), base dans laquelle est représenté le chiffre.
//Les valeurs possibles sont les suivantes :
"d" // base 10 (décimal)
"x" // base 16 (hexadécimal)
"o" // base 8 (octal)
un entier //compris entre 2 et 36

Notes

-Plage de conversion
//La conversion d'une chaîne en entier avec la fonction Val est réalisée si la valeur est comprise entre -9.223.372.036.854.775.808 et 9.223.372.036.854.775.807.

-Divers
//Dès qu'un caractère de <Chaîne source> ne peut pas constituer un nombre, la fonction Val arrête d'interpréter <Chaîne source>, et retourne le nombre correspondant aux caractères déjà lus.
//Les réels ne sont convertibles qu'à partir de la base 10.
//Dans les autres bases, les caractères situés après le "." (point) ne seront pas pris en compte.


ValueRead

ValueRead (fonction TRUE)

Utilisation

//Récupérer la valeur d'une pseudo variable globale, mémorisée dans un fichier.
//Cette fonction permet de simuler la lecture de variables globales, dont la déclaration et l'initialisation seront préalablement faîtes avec la fonction ValueWrite().
//Les valeurs de ces pseudos variables peuvent être affichées dans la fenêtre " Valeurs ", après la compilation de l'élaboration.

-Note :
//Lorsqu'on exécute une compilation locale à partir de la fenêtre " Procédure ", la valeur récupérée est celle mémorisée pendant la compilation de l'élaboration, à moins qu'elle n'ait été réinitialisée par une compilation locale précédente.

-Exemple 1

//y est la valeur de retour de la procédure
y = ValueRead("ab")
//On initialise la variable y avec la valeur de la pseudo variable de nom "ab"

-Exemple 2

Nom est une chaîne
Nom = ValueRead("Nom")
//On initialise la variable Nom avec la valeur de la pseudo variable de nom "Nom"

-Exemple 3

Compte est un monétaire
Compte = ValueRead("montant")
//On initialise la variable Compte avec la valeur de la pseudo variable de nom "montant"

Syntaxe

<Résultat> = ValueRead(<Nom de la pseudo variable> )

-Détail des paramètres

<Résultat> // chaîne de caractère contenant la valeur mémorisée sous le nom <Nom de la pseudo variable>.
//Cette chaîne est limitée à 100 caractères.

<Nom de la pseudo variable> // entier ou chaîne de caractère précisant le nom de la pseudo variable.
//La taille de ce nom est limitée à 40 caractères.


ValueWrite

ValueWrite (fonction TRUE)

Utilisation

//Mémorise dans un fichier une valeur associée à un nom.
//Cette fonction permet de simuler la déclaration et l'initialisation de variables globales, dont on pourra lire la valeur avec la fonction ValueRead().
//Les valeurs de ces pseudos variables peuvent être affichées dans la fenêtre " Valeurs ", après la compilation de l'élaboration.

-Note :
//Lorsqu'on exécute une compilation locale à partir de la fenêtre " Procédure ", la valeur mémorisée n'écrase pas la valeur mémorisée pendant la compilation de l'élaboration.

-Exemple 1

//y est la valeur de retour de la procédure
ValueWrite("ab", y)
//On mémorise la valeur de la variable y dans la pseudo variable de nom "ab"

-Exemple 2

ValueWrite("nombre de produit", 300)
//On mémorise la valeur 300 dans la pseudo variable de nom "nombre de produit"

-Exemple 3

ValueWrite("nom", "DUPOND")
//On mémorise le nom "DUPOND" dans la pseudo variable de nom "nom"

-Exemple 4

ValueWrite("dim")
//On efface le contenu de la pseudo variable de nom "dim"

Première Syntaxe

ValueWrite(<Nom de la pseudo variable>,[<Valeur de la pseudo variable>] )

-Détail des paramètres
<Nom de la pseudo variable> // entier ou chaîne de caractère précisant quel nom on veut donner à la pseudo variable.
//Ce nom sera mémorisé dans une chaîne de caractère dont la taille est limitée à 40 caractères.

<Valeur de la pseudo variable> // valeur optionnelle de la pseudo variable.
//Cette valeur sera mémorisée dans une chaîne de caractère dont la taille est limitée à 100 caractères.


VariantConvertit

Nouvelle page
Saisissez ici le texte de la page


Crypte

Nouvelle page
Saisissez ici le texte de la page


xlsDonnée

Utilisation

Récupère le contenu d'une cellule d'un fichier XLS.
Selon le mode d'ouverture du fichier XLS, le résultat peut varier :

- En mode multi-feuilles :
la donnée récupérée est située sur la feuille sélectionnée avec la fonction xlsFeuilleEnCours.

- En mode compatible :
la donnée récupérée est toujours située sur la première feuille du classeur.

Remarque : Le contenu d'une cellule d'un fichier XLS peut être récupéré uniquement si :

- le fichier XLS existe.

- le fichier XLS est ouvert.

// Ouverture d'un fichier XLSId = xlsOuvre("C:\MonRépertoire\Fichier.XLS")SI Id <> -1 // Récupération de la valeur d'une cellule Res = xlsDonnée(Id, 3, 4) ...FIN

Syntaxe

<Résultat> = xlsDonnée(<Identifiant du fichier XLS>, <Numéro de la ligne>, <Numéro de la colonne> [, <Lignes et colonnes vides>])

-Détail du paramètre

<Résultat> : Chaîne de caractères
Contenu de la cellule spécifiée ou la constante xlsDonnéeErreur en cas d'erreur.

Remarque :
si le fichier Excel a été ouvert en mode compatible, le contenu de la cellule est limité à 255 caractères.

<Identifiant du fichier XLS> : Entier
Identifiant du fichier XLS à manipuler, renvoyé par la fonction xlsOuvre.

<Numéro de la ligne> : Entier
Numéro de la ligne de la cellule à lire.

<Numéro de la colonne> : Entier
Numéro de la colonne de la cellule à lire.

<Lignes et colonnes vides> : Booléen optionnel
Mode de prise en compte des colonnes et des lignes vides :

Vrai (par défaut)
- les lignes et les colonnes entièrement vides ne sont pas prises en compte

Faux
- les lignes et les colonnes entièrement vides sont prises en compte


xlsFeuilleEnCours

Utilisation

Permet de connaître ou de modifier la feuille courante d'un fichier XLS

Remarque : En mode multi-feuilles, les fonctions de gestion des fichiers XLS travaillent toujours sur la feuille courante. Lors de l'ouverture du ficher XLS, la 1ère feuille du classeur est la feuille courante.

id est un entier
id = xlsOuvre("Fichier.XLS")
//ou
id = xlsOuvreExport("Fichier.XLS")

//manipulation sur le fichier XLS
//...
//Récupération de la feuille courante
Feuille est un entier
Feuille = xlsFeuilleEnCours(id)
//Positionnement sur la dernière feuille du fichier
NbFeuille est un entier = xlsNbFeuille(id)
SI xlsFeuilleEnCours(id,NbFeuille) ALORS
Info("La feuille courante a été modifiée")
FIN

Syntaxe : connaître la feuille en cours<Résultat> = xlsFeuilleEnCours(<Identifiant du fichier XLS>)

-Détails des paramètres

<Résultat> : // Entier
// Indice de la feuille en cours. Cette valeur est comprise entre 1 et xlsNbFeuille()
<Identifiant du fichier XLS> : // Entier
// Identifiant du fichier XLS à manipuler,
renvoyé par la fonction xlsOuvre() ou xlsOuvreExport()

Syntaxe : modifier la feuille en cours
<Résultat> = xlsFeuilleEnCours(<Identifiant du fichier XLS>, <Numéro de la feuille>)

-Détails des paramètres

<Résultat> : // Booléen
// Vrai si la feuille courante a été changée,
//Faux dans le cas contraire ( par exemple si la feuille spécifiée n'existe pas
<Identifiant du fichier XLS> : // Entier
// Identifiant du fichier XLS à manipuler,
renvoyé par la fonction xlsOuvre() ou xlsOuvreExport()
<Numéro de la feuillle> : // Entier
// Indice de la nouvelle feuille.
//Cette valeur est comprise entre 1 et xlsNbFeuille()


xlsFerme

Utilisation

//Ferme un fichier XLS

// Ouverture d'un fichier XLS
Id = xlsOuvre("C:\MesRépertoires\Fichier.XLS")...// Fermeture du fichier XLS
xlsFerme(Id)

Syntaxe

xlsFerme(<Identifiant du fichier XLS>)

-Détail du paramètre

<Identifiant du fichier XLS> // Entier
// Identifiant du fichier XLS à fermer, renvoyé par la fonction xlsOuvre


xlsMsgErreur
Utilisation

Renvoie le libellé de la dernière erreur due à une fonction XLS.

//manipulation sur le fichier XLS
id est un entier
id = xlsOuvre("Fichier.XLS")
//ou
id = xlsOuvreExport("Fichier.XLS")
//...

SI id <> -1
Info("Le fichier XLS a été ouvert")
SINON
ResErreur=xlsMsgErreur(id)
FIN

Syntaxe :
<Résultat> = xlsMsgErreur(Identifiant du fichier XLS>)

-Détails des paramètres

<Résultat> : // Chaîne de caractères
// Libellé de la dernière erreur survenue sur le fichier XLS ou une chaîne vide ("") si aucune erreur n'est survenue.
<Identifiant du fichier XLS> : // Entier
// Identifiant du fichier XLS à manipuler,
renvoyé par la fonction xlsOuvre() ou xlsOuvreExport()

Notes :

Différentes erreurs
//Les erreurs pouvant survenir sur l'ensemble des fonctions XLS sont :
- Le fichier XLS n'a pas été trouvé, n'existe pas, n'est pas ouvert, n'est pas valide ou ne peut être ouvert.
- La ligne et/ou la colonne spécifiée sont vides ou n'existent pas.
- Pas assez de mémoire pour ouvrir le fichier.
- La version d'Excel utilisée est inconnue ou trop ancienne (les fonctions XLS ne peuvent pas lire
les fichiers au format Excel version 2 ou inférieure).

Fonction équivalente

//La fonction ErreurInfo utilisée avec la constante errMessage permet également de renvoyer le libellé de la dernière erreur survenue.


xlsNbColonne

Utilisation

Renvoie le nombre de colonnes d'une feuille d'un fichier XLS.
Selon le mode d'ouverture du fichier XLS, le résultat peut varier :
- en mode multi-feuilles, le nombre de colonnes est calculé pour la feuille sélectionnée avec la fonction xlsFeuilleEnCours.
- en mode compatible, le nombre de colonnes est toujours calculé pour la première feuille du classeur.

Cette fonction suppose que le fichier XLS possède une structure de type base de données, c'est-à-dire que chaque ligne correspond à un nombre de colonnes fixe.

Remarque :
- le nombre de colonnes d'un fichier XLS peut être obtenu uniquement si :
-- le fichier XLS existe.
-- le fichier XLS est ouvert..

// Ouverture d'un fichier XLSId = xlsOuvre("C:\MonRépertoire\Fichier.XLS")SI Id <> -1 ALORS // Nombre de colonnes Res = xlsNbColonne(Id) ...FIN

Syntaxe

<Résultat> = xlsNbColonne(<Identifiant du fichier XLS> [, <Colonnes vides>])

-Détail du paramètre

<Résultat> : Entier
Nombre de colonnes du fichier XLS spécifié ou -1 en cas d'erreur (fichier XLS non ouvert par exemple). Pour connaître le libellé de l'erreur, utilisez la fonction xlsMsgErreur ou la fonction ErreurInfo avec la constante errMessage.

<Identifiant du fichier XLS> : Entier
Identifiant du fichier XLS à manipuler, renvoyé par la fonction xlsOuvre.

<Colonnes vides> : Booléen optionnel
Mode de prise en compte des colonnes vides :
Vrai (par défaut)
- les colonnes entièrement vides ne sont pas prises en compte
Faux
- les colonnes entièrement vides sont prises en compte


xlsNbFeuille

Utilisation

Renvoie le nombre de feuilles d'un fichier XLS.

//manipulation sur le fichier XLS
id est un entier
id = xlsOuvre("Fichier.XLS")
//ou
id = xlsOuvreExport("Fichier.XLS")
//...

//Récupération du nombre de feuilles du fichier
NbFeuille est un entier
NBFeuille = xlsNbFeuille(id)

Syntaxe : connaître le nombre de feuilles

<Résultat> = xlsNBFeuille(<Identifiant du fichier XLS>)

-Détails des paramètres

<Résultat> : // Entier
// Nombre de feuilles du fichier XLS spécifié ou -1 en cas d'erreur.
Pour connaître le libellé de l'erreur, utilisez la fonction xlsMsgErreur() ou la fonction ErreurInfo() avec la constante errMessage.
<Identifiant du fichier XLS> : // Entier
// Identifiant du fichier XLS à manipuler,
renvoyé par la fonction xlsOuvre() ou xlsOuvreExport()


xlsNbLigne

Utilisation

Renvoie le nombre de lignes d'un fichier XLS.
Selon le mode d'ouverture du fichier XLS, le résultat peut varier :
- en mode multi-feuilles, le nombre de lignes est calculé pour la feuille sélectionnée avec la fonction xlsFeuilleEnCours.
- en mode compatible, le nombre de lignes est toujours calculé pour la première feuille du classeur.

Remarque : Le nombre de lignes d'un fichier XLS ne peut être connu que si :
- le fichier XLS existe.
- le fichier XLS est ouvert.

// Ouverture d'un fichier XLSId = xlsOuvre("C:\MonRépertoire\Fichier.XLS")SI Id <> -1 ALORS // Nombre de lignes Res = xlsNbLigne(Id) ...FIN

Syntaxe

<Résultat> = xlsNbLigne(<Identifiant du fichier XLS> [, <Lignes vides>])

-Détail du paramètre

<Résultat> : Entier
Nombre de lignes du fichier XLS spécifié ou -1 en cas d'erreur (fichier XLS non ouvert par exemple). Pour connaître le libellé de l'erreur, utilisez la fonction xlsMsgErreur ou la fonction ErreurInfo avec la constante errMessage.

<Identifiant du fichier XLS> : Entier
Identifiant du fichier XLS à manipuler, renvoyé par la fonction xlsOuvre.

<Lignes vides> : Booléen optionnel
Mode de prise en compte des lignes vides :
Vrai (par défaut)
- les lignes entièrement vides ne sont pas prises en compte
Faux
- les lignes entièrement vides sont prises en compte


xlsOuvre

Utilisation

//Ouvre un fichier XLS

Remarque : Par défaut, le fichier XLS est ouvert en mode multi-feuilles : les différentes feuilles du classeur sont gérées.

Attention : Seuls les fichiers XLS sont gérés. Les fichiers spécifiques à Office 2007 (fichiers .xlsx) ne sont pas gérés

id est un entier
id = xlsOuvre("C:\MesRépertoires\Fichier.XLS")
SI id <> -1 Info("Le fichier XLS a été ouvert")SINON Info(xlsMsgErreur(id))FIN

Syntaxe

<Résultat> = xlsOuvre(<Chemin du fichier XLS>)

-Détails des paramètres

<Résultat> : // Entier
// Identifiant du fichier XLS à ouvrir ou -1 en cas d'erreur.
Cet identifiant sera utilisé dans tous les fonctions XLS

<Chemin du fichier XLS> : // Chaîne de caractères//Chemin complet ou relatif du fichier XLS à ouvrir (260 caractères maximum).


xlsTitreColonne

Nouvelle page
Saisissez ici le texte de la page


xlsTypeColonne

Nouvelle page
Saisissez ici le texte de la page


xlsVersion

Nouvelle page
Saisissez ici le texte de la page


Tableau dynamique

Utilisation

//Un tableau dynamique est un type "avancé" de tableau : les dimensions de ce tableau sont allouées à la demande, au cours du programme. Dans la plupart des cas, un tableau "simple" est suffisant.

//Rappel : Un tableau est un type structuré qui permet de regrouper une série d'éléments de même type. Chaque élément du tableau est accessible directement par son numéro d'ordre.

//Il est conseillé d'utiliser :
//Un tableau dynamique ou un tableau "simple" lorsque la taille du tableau doit être modifiée au cours du programme.

Syntaxe

-Déclarer un tableau dynamique
<Nom du tableau> est un tableau dynamique

Détail de la syntaxe
<Nom du tableau dynamique> //Nom de la variable tableau dynamique à déclarer.
//Remarque : Le mot-clé un n'est pas obligatoire : c'est un mot d'agrément.

TableauClient est un tableau dynamique

-Allouer un tableau dynamique
<Nom du tableau dynamique> = allouer un tableau dynamique de <Dimension 1> [par <Dimension 2> ... [par <Dimension 10>]] <Type des éléments du tableau>
//ou
<Nom du tableau dynamique> = allouer un tableau dynamique de <Dimension 1> [,<Dimension 2> ... [,<Dimension 10>]] <Type des éléments du tableau>

Détail de la syntaxe
<Nom du tableau dynamique> //Nom du tableau dynamique à manipuler. Ce tableau à été préalablement déclaré.
<Dimension 1>...<Dimension 10> //Dimension 1 à 10 du tableau (valeur entiere égale ou supérieure à 0).
<Type des éléments du tableau> //Type des éléments constituant le tableau.
//Voir les différents types de variables.

//Remarque : Les mots-clés un et dynamique ne sont pas obligatoires : ce sont des mots d'agrément.

TableauClient est un tableau dynamique
TableauClient = allouer un tableau dynamique de 4 par 7 entiers
// Équivalent à :
TableauClient = allouer un tableau dynamique de 4,7 entiers

-Déclarer et allouer un tableau dynamique
//Il est possible de déclarer ET d'allouer un tableau dynamique sur une seule ligne de code.
<Nom du tableau dynamique> est un tableau dynamique de <Dimension 1> [par <Dimension 2> ... [par <Dimension 10>]] <Type des éléments du tableau>
//ou
<Nom du tableau dynamique> est un tableau dynamique de <Dimension 1> [,<Dimension 2> ... [,<Dimension 10>]] <Type des éléments du tableau>

Détail de la syntaxe
<Nom du tableau dynamique> //Nom du tableau dynamique à manipuler. Ce tableau a été préalablement déclaré.
<Dimension 1>...<Dimension 10> //Dimension 1 à 10 du tableau (valeur entière érieure à 0).
<Type des éléments du tableau> //Type des éléments constituant le tableau.
//Voir les différents types de variables.

//Remarques :
//Les mots-clés un et dynamique ne sont pas obligatoires : ce sont des mots d'agrément.
//Dans ce cas, il ne faut pas utiliser le mot-clé Libérer pour libérer explicitement le tableau dynamique. Si le mot-clé libérer est utilisé, une erreur d'exécution sera générée.

TableauClient est un tableau dynamique de 4 par 7 entiers
// Équivalent à :
TableauClient est un tableau dynamique
TableauClient = allouer un tableau dynamique de 4 par 7 entiers

-Faire référence à un tableau dynamique
//Remarque : Pour faire référence à un tableau dynamique, ce tableau doit être alloué.

-Faire référence à un élément d'un tableau à une dimension :
<Nom du tableau>[Indice1]

-Faire référence à un élément d'un tableau à deux dimensions :
<Nom du tableau>[Indice1, Indice2]
//ou
<Nom du tableau>[Indice1][Indice2]

-Faire référence à un élément d'un tableau à n dimensions :
<Nom du tableau>[Indice1,...,IndiceN]
//ou
<Nom du tableau>[Indice1]...[IndiceN]

Détail de la syntaxe
<Nom du tableau dynamique> //Nom du tableau dynamique à manipuler.
<Indice1> //Indice de l'élément pour la 1ière dimension.
<Indice2> //Indice de l'élément pour la 2ième dimension.
<IndiceN> //Indice de l'élément pour la Nième dimension (N <= 10).
//Remarque : Il n'est pas possible de manipuler un tableau dans sa totalité. Par exemple, il n'est pas possible d'affecter un tableau avec un autre tableau.

TableauClient[2,5,3] = 47
// Équivalent à :
TableauClient[2][5][3] = 47

Notes

-Libérer un tableau dynamique (optionnel)
//Un tableau dynamique est automatiquement libéré en fin de vie de la variable (fermeture de la fenêtre par exemple) ou lors de l'allocation de nouvelles dimensions.
//Pour libérer explicitement un tableau dynamique, utilisez la syntaxe suivante :
libérer <Nom du tableau dynamique>
//Si la déclaration et l'allocation du tableau dynamique est réalisée en une seule ligne de code, il ne faut pas utiliser le mot-clé Libérer pour libérer explicitement le tableau dynamique.
//Si le mot-clé Libérer est utilisé, une Erreur d'exécution sera générée.

-Déclarer un membre de type tableau dynamique
//Il est possible de déclarer un membre de type "tableau dynamique" dans :
//une structure,
//une variable composée,
//une classe.

//L'allocation du tableau dynamique doit être effectuée à la suite de la déclaration de la structure, de la variable composée ou de la classe.
//Par exemple :
// Déclaration d'une structure
Struct est une structure
x1 est un entier
x2 est un tableau dynamique // Déclaration du tableau
FIN

-Déclaration d'une variable de type structureruct est une Struct
// Allocation du tableau
x2 = allouer un tableau dynamique de 4,7 entiers
//Remarque : dans le cas d'une classe, la déclaration doit être réalisée dans le code de déclaration de classe, et l'allocation doit être réalisée dans le constructeur de la classe.

-Dimension d'un tableau dynamique
//La fonction Dimension permet de :
//connaître le nombre d'éléments dans un tableau dynamique.
//redimensionner un tableau dynamique.
//Attention : La fonction Dimension ne permet pas de modifier le nombre de dimensions d'un tableau dynamique.

Limites

-Éléments d'un tableau dynamique
//Un tableau dynamique ne peut pas être constitué :
//- de variables composées.
//- de tableaux.


Tableau fixe

Utilisation

//Un tableau fixe est un type "avancé" de tableau : les dimensions de ce tableau sont fixées lors de la compilation et ne peuvent pas être modifiées.

//Les dimensions d'un tableau sont fixées lors de la compilation, uniquement si les dimensions de ce tableau correspondent :
//soit à un entier.
//soit à une constante préalablement créée.
//Dans les autres cas, une erreur du W-Langage est générée lors de la compilation du projet.

//Rappel : Un tableau est un type structuré qui permet de regrouper une série d'éléments de même type. Chaque élément du tableau est accessible directement par son numéro d'ordre.

//Il est conseillé d'utiliser :
//un tableau dynamique ou un tableau "simple" lorsque la taille du tableau doit être modifiée au cours du programme.

Syntaxe

-Déclarer un tableau fixe
<Nom du tableau> est un tableau fixe de <Dimension 1> [par <Dimension 2> ... [par <Dimension 10>]] <Type des éléments du tableau>
//ou
<Nom du tableau> est un tableau fixe de <Dimension 1> [,<Dimension 2> ... [,<Dimension 10>]] <Type des éléments du tableau>

Détail de la syntaxe
<Nom du tableau> //Nom de la variable tableau à déclarer.
<Dimension 1>...<Dimension 10> //Dimension 1 à 10 du tableau (valeur entière).
<Type des éléments du tableau> //Type des éléments constituant le tableau.
//Voir les différents types de variables.

//Remarque : Le mot-clé un n'est pas obligatoire : c'est un mot d'agrément.

TableauClient est un tableau fixe de 5 par 7 par 3 entiers
// Équivalent à :
TableauClient est un tableau fixe de 5,7,3 entiers

-Faire référence à un tableau fixe
//Faire référence à un élément d'un tableau à une dimension :
<Nom du tableau>[Indice1]

//Faire référence à un élément d'un tableau à deux dimensions :
<Nom du tableau>[Indice1, Indice2]
//ou
<Nom du tableau>[Indice1][Indice2]

//Faire référence à un élément d'un tableau à N dimensions :
<Nom du tableau>[Indice1, ... , IndiceN]
//ou
<Nom du tableau>[Indice1]...[IndiceN]

Détail de la syntaxe
<Nom du tableau> //Nom du tableau fixe à manipuler.
<Indice1> //Indice de l'élément pour la 1ière dimension.
<Indice2> //Indice de l'élément pour la 2ième dimension.
<IndiceN> //Indice de l'élément pour la Nième dimension (N <= 10).
//Remarque : Il n'est pas possible de manipuler un tableau dans sa totalité. Par exemple,ossible d'affecter un tableau avec un autre tableau.

TableauClient[2,5,3] = 47
// Équivalent à :
TableauClient[2][5][3] = 47

Notes

-Déclarer un membre de type tableau fixe
//Il est possible de déclarer un membre de type tableau fixe dans :
//une variable composée. Ce tableau fixe est alloué directement dans la zone mémoire de cette variable composée.
//une structure <Nom de la structure>. Ce tableau fixe est alloué directement dans la zone mémoire de chaque variable de type <Nom de la structure>.
//Par exemple :
Struct est une structure
n1 est un entier
nTab est un tableau fixe sur 2 entiers
n2 est un entier
FIN
MaStructure est une Struct

-Dimension d'un tableau fixe
//La fonction Dimension permet de connaître le nombre d'éléments dans un tableau fixe.
//Rappel : Il n'est pas possible de redimensionner un tableau fixe.

Limites

-Éléments d'un tableau fixe
//Un tableau fixe ne peut pas être constitué :
//- de variables composées.
//- de tableaux.


Date

Le type date

//Le type Date permet de manipuler simplement des dates. Ce type permet de gérer de manière quasi automatique les conversions (fonctions ChaîneVersDate, DateVersChaîne, EntierVersDate, DateVersEntier, ...)
//Ce type peut être utilisé aussi bien :
//pour récupérer puis manipuler des rubriques Hyper File au format Date
//pour récupérer puis manipuler les champs de saisie de type Date
//dans les fonctions du W-Langage permettant de gérer les dates.
//pour réaliser des calculs sur les dates (différence, addition, ...). Pour plus de détails, consultez le chapitre Opérations disponibles sur le type date.

//Remarque : Plusieurs propriétés peuvent être utilisées avec le type Date, pour récupérer par exemple qu'une partie de la date.

Syntaxe

-Déclarer et initialiser une variable

<Nom de la variable> est une date = <Valeur>
//ou
<Nom de la variable> est une date
<Nom de la variable> = <Valeur>

Détail de la syntaxe
<Nom de la variable> //Nom de la variable à déclarer.
<Valeur> //Valeur à affecter à la variable. Cette valeur peut être de type :
//Date
//DateHeure : seule la date sera prise en compte.
//chaîne de caractères, au format AAAAMMJJ (AAAA : année, MM : Mois, JJ : Jour)
//entier : la date correspondra alors au nombre de jours écoulés entre le 1er janvier 1800 et la date spécifiée.

//Remarques :
//Par défaut, une variable de type date est initialisée avec la date du jour (date système). Pour régler la valeur par défaut affectée aux variables de type Date, Heure et DateHeure, utilisez la fonction DateHeureParDéfaut.
//Lorsque plusieurs variables du même type sont déclarées et initialisées sur la même ligne, seule la dernière variable est initialisée.

DateDébut est une date = 1205
DateFin est une date = "20011231" // 31/12/2001
DateJour est une date = DateSys()

Notes

-Les propriétés utilisables sur les dates
Année //Renvoie ou modifie l'année de la date spécifiée (sous forme d'entier)
Jour //Renvoie ou modifie le jour de la date spécifiée (sous forme d'entier)
Mois //Renvoie ou modifie le mois de la date spécifiée (sous forme d'entier)

//Pour plus de détails sur les opérations possibles sur les dates (addition, soustraction, comparaison), consultez Opérations disponibles sur le type date.

DateDébut est une date = "20011201"
DateDébut..Année +=5 // Ajoute 5 ans à la date
DateDébut..Mois = 5 // M
DateFin = DateDébut // Calcule la fin (30 jours après)
DateFin..Mois++
DateFin..Jour--

Limites

-Plage de dates
//Le type date permet de gérer des dates comprises entre le 01/01/0001 et le 31/12/9999.


Heure

Le type Heure

//Le type Heure permet de manipuler simplement des heures. Ce type permet de gérer de manière quasi automatique les conversions (fonctions HeureVersChaîne, HeureVersEntier, ...)
//Ce type peut être utilisé aussi bien :
//pour récupérer puis manipuler des rubriques Hyper File au format Heure
//pour récupérer puis manipuler les champs de saisie de type Heure
//dans les fonctions du W-Langage permettant de gérer les Heures.
//pour réaliser des calculs sur les heures (différence, addition, ...). Pour plus de détails, consultez le chapitre Opérations disponibles sur le type heure.

//Remarque : Plusieurs propriétés peuvent être utilisées avec le type heure, pour récupérer par exemple qu'une partie de l'heure (heure, minute, ..).
Syntaxe

-Déclarer et initialiser une variable

<Nom de la variable> est une heure= <Valeur>
//ou
<Nom de la variable> est une heure
<Nom de la variable> = <Valeur>

Détail de la syntaxe

<Nom de la variable> //Nom de la variable à déclarer.
<Valeur> //Valeur à affecter à la variable. Cette valeur peut être de type :
//Heure
//DateHeure : seule l'heure sera prise en compte.
//chaîne de caractères, au format :
// - HHMM
// - HHMMSS
// - HHMMSSCC
// - HHMMSSMMM

//Seules les heures et les minutes seront prises en compte.
//(HH : Heure, MM : minutes, SS : secondes, CC : centièmes de secondes, MMM : millièmes de secondes)

//entier : l'heure correspondra alors au nombre de centièmes de secondes écoulés depuis minuit "00 :00 :00 :00". A minuit correspond l'entier 0. Ne peut dépasser 8.639.999 (24 heures - 1 centième de seconde).

//Remarques :
//Lorsque plusieurs variables du même type sont déclarées et initialisées sur la même ligne, seule la dernière variable est initialisée.
//Par défaut, une variable de type Heure est initialisée avec l'heure système. Pour régler la valeur par défaut affectée aux variables de type Date, Heure et DateHeure, utilisez la fonction DateHeureParDéfaut.

HeureDébut est une heure= 1205
HeureFin est une heure = "2030" // 20 heures 30
HeureEnCours est une heure = HeureSys()

Notes
-Les propriétés utilisables sur les heures

Heure //Renvoie ou modifie l'heure (sous forme d'entier)
Milliseconde //Renvoie ou modifie le nombre de millisecondes (sous forme d'entier)
Minute //Renvoie ou modifie le nombre de minutes (sous f
Seconde //Revoie ou modifie le nombre de secondes (sous forme d'entier)

//Pour plus de détails sur les opérations possibles sur les heures (addition, soustraction, comparaison), consultez Opérations disponibles sur le type Heure.

HeureDébut est une heure= "20011201"
HeureDébut..heure +=5 // Ajoute 5 heures
HeureDébut..Minutes= 5 // Modifie le nombre de minutes

Limites

//Le type Heures permet de gérer les heures comprises entre 00:00 et 23:59. La précision est effectuée à la milliseconde.


DateHeure
Saisissez ici le texte de la page


Durée
Saisissez ici le texte de la page


Liste des propriétés

Nouvelle page
Saisissez ici le texte de la page


Maintenant

Nouvelle page
Saisissez ici le texte de la page


Opérations sur les dates

Opérations disponibles sur les dates, heures, durées, ...
Saisissez ici le texte de la page


Année

Nouvelle page
Saisissez ici le texte de la page


Heure

Nouvelle page
Saisissez ici le texte de la page


Jour

Nouvelle page
Saisissez ici le texte de la page


Milliseconde

Nouvelle page
Saisissez ici le texte de la page


Minute

Nouvelle page
Saisissez ici le texte de la page


Mois

Nouvelle page
Saisissez ici le texte de la page


PartieDate

Nouvelle page
Saisissez ici le texte de la page


PartieHeure

Nouvelle page
Saisissez ici le texte de la page


Seconde

Nouvelle page
Saisissez ici le texte de la page


ZDimension

Exemples d'utilisation de la fonction Dimension

-Exemples d'utilisation de la fonction Dimension

-Exemple 1 : Calculer la dimension d'un tableau
//L'exemple suivant est une fonction de vérification d'un tableau.
//La taille du tableau à vérifier est une variable.

i est un entier
res est un booléen
POUR i = 1 A Dimension(NomTab)
SI NomTab[i] = 0 ALORS res=Faux ; SORTIR
FIN
res=Vrai

-Exemple 2 : Re-dimensionner un tableau dynamique
//Cet exemple permet de re-dimensionner un tableau dynamique.
MonTab est un tableau dynamique de 5 par 3 entiers
...
// Redimensionner le tableau
Dimension(MonTab, 8, 6)


xlsOuvreExport

Utilisation

//Ouvre un fichier XLS situé dans le répertoire ...\Export du modèle

Remarque 1 : Si le fichier XLS est déjà ouvert par Excel, il sera dupliqué dans le répertoire export, et c'est le fichier dupliqué qui sera ouvert.

Remarque 2: Par défaut, le fichier XLS est ouvert en mode multi-feuilles : les différentes feuilles du classeur sont gérées.
Pour connaître ou modifier la feuille courante utilsez la fonction xlsFeuilleEncours()

Attention : Seuls les fichiers XLS sont gérés. Les fichiers spécifiques à Office 2007 (fichiers .xlsx) ne sont pas gérés

id est un entier
id = xlsOuvreExport("Fichier.XLS")
SI id <> -1 Info("Le fichier XLS a été ouvert")SINON Info(xlsMsgErreur(id))FIN

Syntaxe

<Résultat> = xlsOuvreExport(<Nom du fichier XLS>)

-Détails des paramètres

<Résultat> : // Entier
// Identifiant du fichier XLS à ouvrir ou -1 en cas d'erreur.
Cet identifiant sera utilisé dans tous les fonctions XLS
<Chemin du fichier XLS> : // Chaîne de caractères//Nom du fichier XLS à ouvrir (260 caractères maximum).
//Ce fichier doit se trouver dans le répertoire ...\Export du modèle en cours.


Propriétés

Nouvelle page
Saisissez ici le texte de la page