AVS de Winamp

 AVS de Winamp : Tutoriel 8

Aide sur les expressions

Présentation

Ces pages sont une version étendue de l'aide sur les expressions de AVS. Vous y retrouverez tout le contenu de celle-ci, mais avec des explications plus détaillées. Le tout est illustré de nombreux exemples et de quelques représentations graphiques.

Encore une fois, comme cette aide aborde à plusieurs reprises des aspects purement mathématiques, sa bonne compréhension nécessite quelques bonnes bases dans cette matière (niveau troisième minimum). Et si ce n'est pas votre cas, vous pouvez toujours la parcourir pour essayer de comprendre ...

Les variables

En programmation, une variable est une zone de mémoire pouvant contenir une donnée utilisable par un programme. Dans la majorité des langages, cette zone mémoire est référencée par un simple nom : le nom de la variable. AVS, dans ses effets dynamiques, n'échappe pas à cette règle.

Dans AVS, un nom de variable doit commencer par une lettre et peut contenir un nombre quelconque de lettres, chiffres et souligné (caractère '_').

Une variable AVS ne peut contenir qu'un nombre, et en particulier, un nombre à virgule flottante comme 0.5, -2.781 ou 10 (en réalité 10.0).

Exemples :  
  a
  ma_variable
  x1

Noter qu'il existe quelques noms de variables réservés, c'est à dire, reconnus par AVS pour un usage particulier. Ces variables sont détaillées au niveau de chacun des effets concernés.

D'une façon générale, lorsqu'une variable apparaît à gauche d'une affectation (voir ci-dessous), c'est pour y écrire une valeur. Lorsqu'elle apparaît à droite, y compris dans une fonction, c'est pour en lire la valeur.

Une variable n'est connue qu'à l'intérieur d'un effet. En d'autres termes, la variable A d'un effet et la variable A d'un autre effet n'ont rien de commun (malgré le même nom).

 2.8 Il existe cependant une série de 100 variables, nommées reg00, reg01, reg02, ..., reg99, dont la valeur est globale à toute une présélection. Cela signifie, par exemple, que reg00 peut être renseignée dans un effet dynamique, et utilisée dans un autre. Ces variables globales (ou registres) sont très utiles pour synchroniser des effets. Noter que leur contenu peut être facilement visualisable via la fenêtre Debug Window accessible dans le menu Settings.

Les constantes

 2.8 En plus des variables, AVS met aussi à votre disposition des variables d'un type spécial, appelées constantes, et contenant des valeurs remarquables. Ces constantes sont les suivantes :

Constante Valeur
$PI 3,14159...
$E 2,71828...
$PHI 1,61803...

Les commentaires

 2.8 Les instructions d'un effet dynamique sont saisies les unes à la suite des autres, séparées par des point-virgules. Même si les zones de texte permettent d'appliquer une légère mise en page pour faciliter la lecture du code, l'utilisation de commentaires est fortement recommandées pour s'y retrouver.

Exemples :  
  x=3; // commentaire de fin de ligne
y=3; // ligne suivante
   
  x=3 /* commentaire dans la ligne */;y=3;
   
  x=3; /* commentaire
             sur plusieurs
             lignes */;y=3;

L'affectation

L'affectation est l'instruction de base de AVS. Elle permet de donner à une variable (de lui affecter) la valeur désirée. Noter qu'une variable qui n'a pas encore eu d'affectation contient toujours 0.

Syntaxes :    
  Affectation <variable>=<expression>
   2.8 Assignation <variable>=assign(<expression1>,<expression2>)
Exemples :    
  a=1 La variable a reçoit la valeur 1.
  a=a+1 La variable a reçoit sa valeur précédente plus 1.
  b=0.1 La variable b reçoit la valeur 0.1.
  b=.1 Idem ci-dessus (le zéro avant la 'virgule' est facultatif).
  a=assign(b,c) Les variables a et b reçoivent la valeur de c.
  a=assign(if(b,c,d),e) La variable a reçoit la valeur de e, et si b est différent de 0, c reçoit la valeur de e, sinon, d reçoit la valeur de e.

Les tableaux

 2.8 En plus des variables, AVS dispose maintenant de la notion de tableaux. Un tableau est un ensemble de données accédées par un numéro d'ordre allant de 0, pour la première occurrence (le premier élément) à plus de un million (ils ont prévu large !).

Il existe deux types de tableau : le tableau local (connu uniquement de l'effet en cours) et le tableau global (connu de tous les effets d'une présélection).

La manipulation des données d'un tableau passe obligatoirement par l'emploi de fonctions spécifiques. Regardez les exemples ci-dessous pour en apprendre un peu plus.

Syntaxes :    
  Tableau local megabuf(<expression>)
  Tableau global gmegabuf(<expression>)
Exemples :    
  a=megabuf(5) La variable a reçoit la valeur de la 6ème occurrence du tableau local.
  a=megabuf(b) La variable a reçoit la valeur indicée par b du tableau local.
  b=assign(gmegabuf(5),a) La variable b reçoit la valeur de a, ainsi que la 6ème occurrence du tableau global.

N'oubliez pas que le premier élément d'un tableau est indicé par (numéroté avec) 0, donc le deuxième est indicé par 1, et donc, par extension, le nème élément est indicé par n-1.

Cette notion de tableau s'accompagne également d'une fonction spéciale permettant de gérer des boucles (du code écrit une seule fois mais qui peut être répété plusieurs fois en boucle), ainsi que de deux fonctions permettant de grouper des instructions.

Syntaxes :    
  Boucle loop(<expression>,<instruct>)
  Exécuter 2 instructions exec2(<instruct1>,<instruct2>)
  Exécuter 3 instructions exec3(<instruct1>,<instruct2>,<instruct3>)
Exemples :    
  a=loop(45,assign(k,k+1)) Ajoute 45 fois la valeur 1 à la variable k. Le contenu de a est indéterminé.
  a=exec2(<instr1>,<instr2>) Exécute instr1, puis instr2 et retourne le résultat de cette dernière dans a.
  a=exec3(<inst1>,<inst2>,<inst3>) Exécute inst1, inst2 puis inst3 et retourne le résultat de cette dernière dans a.
  a=loop(100, exec2(
 assign(gmegabuf(k),megabuf(k)),
 assign(k,k+1) ) )		 Si k vaut 0 avant cet instruction, celle-ci transfert les 100 premières occurrences du tableau local dans le tableau global.

Attention, le terme d'instruction ne désigne ici que les fonctions loop(), exec2(), exec3() ou assign().

Notez que le nombre maximum de boucles que vous pouvez exécuter est limité à 4096.

Les opérations arithmétiques

Sous ce terme sont regroupées l'addition, la soustraction, la multiplication et la division. Ces opérations servent de base pour la construction d'une expression. La priorité de calcul habituelle des opérations est respectée (d'abord * et /, puis + et -) ; en cas de doute, vous pouvez utiliser les parenthèses.

Syntaxes :    
  Addition <expression>+<expression>
  Soustraction <expression>-<expression>
  Multiplication <expression>*<expression>
  Division <expression>/<expression>
Exemples :    
  a+b Somme (du contenu) de a et (de celui) de b.
  a-b Différence entre a et b.
  -b Equivalent à 0-b (moins unaire).
  a*b Produit de a et de b.
  a/b Division de a par b.
  a*b+c Somme du produit de a par b et de c.
  (a*b)+c Idem ci-dessus.
  a*(b+c) Produit de a par la somme de b et de c.

Noter que AVS retourne la valeur -1 pour toute expression impossible à calculer, en particulier lorsque celle-ci contient une division par zéro (par exemple, x/0 = -1 et, de même, 3+x/0 = -1).

Les opérations binaires

Une opération binaire est une opération qui s'effectue bit par bit sur les nombres concernés. AVS gère les deux opérations binaires de base : le OU et le ET. Les tableaux suivants vous donnent les règles d'application de ces opérations pour un bit (valant donc 0 ou 1) :

OU  0   1 
0 0 1
1 1 1
 
ET  0   1 
0 0 0
1 0 1

Pour être plus clair, prenons par exemple les nombres 21 et 6. Sachant qu'un nombre binaire s'écrit à partir de la somme des puissances successives de 2 (c'est à dire : 1, 2, 4, 8, 16, 32, 64, ...) en partant de la plus grande, nous obtenons :

21 = 1*16 + 0*8 + 1*4 + 0*2 + 1*1, en binaire : 10101,

et

6 = 0*16 + 0*8 + 1*4 + 1*2 + 0*1, en binaire : 00110.

En appliquant les règles énoncés dans les tableaux ci-dessus, nous obtenons les résultats suivants :

21 -> 1 0 1 0 1  
6 -> 0 0 1 1 0  
21 OU 6 -> 1 0 1 1 1 soit 23
21 ET 6 -> 0 0 1 0 0 soit 4

De prime abord, je doute que vous voyiez l'intérêt de ce type d'opérations, mais, pour en avoir une idée, jetez un coup d'œil aux exemples ...

Syntaxes :    
   OU  <expression>|<expression>
   ET  <expression>&<expression>
Exemples :    
  a&0 Vaut toujours 0.
  a&1 Vaut 1 si a est impair et 0 sinon.
  a&2 Vaut 2 si a vaut 2 ou 3, 6 ou 7, 10 ou 11, etc. et 0 si a vaut 0 ou 1, 4 ou 5, 8 ou 9, etc.
  a&7 Est le reste de la division de a par 8.
  a|0 Vaut toujours a (arrondi à l'entier le plus proche).
  a|1 Vaut a si a est impair et a+1 sinon.
  a|2 Vaut a si a vaut 2 ou 3, 6 ou 7, 10 ou 11, etc. et a+2 si a vaut 0 ou 1, 4 ou 5, 8 ou 9, etc.

Noter que les opérations binaires ne peuvent s'effectuer que sur des nombres entiers (sans décimales). AVS effectue donc systématiquement l'arrondi à l'entier le plus proche d'un nombre réel (avec décimales) avant de procéder à l'opération binaire demandée.

L'opération modulo

L'opération modulo permet tout simplement d'obtenir le reste de la division d'un nombre par un autre.

Syntaxe :    
  Modulo <expression>%<expression>
Exemples :    
  a%2 Vaut 1 si a est impair et 0 sinon.
  a%9 Est le reste de la division de a par 9.

Noter que cette opération ne peut s'effectuer que sur des nombres entiers. AVS effectue donc systématiquement l'arrondi à l'entier le plus proche d'un nombre réel avant de faire le calcul.

Les fonctions trigonométriques

Les fonctions trigonométriques sont des fonctions qui transforment un angle en une valeur numérique. Traditionnellement, un angle est exprimé en degrés et vaut entre 0 (pas d'angle) et 360 degrés (un tour complet). Avec AVS, un angle doit être exprimé en radians et vaut donc, de la même façon, entre 0 et 2π radians. Le symbole π se lit 'pi' et vaut environ 3,14159.

Par soucis de performance, je vous conseille de n'utiliser que des angles exprimés en radians. A titre d'informations, je vous donne quand même les formules de conversions de degrés vers les radians, et inversement :

             π * deg                     180 * rad
   rad = ---------           deg = ------------
               180                               π

Syntaxes :    
  Sinus sin(<expression>)
  Cosinus cos(<expression>)
  Tangente tan(<expression>)

Le petit schéma ci-dessous représente un cercle de rayon 1, appelé cercle trigonométrique. Le trait gris représente un angle a (partant de l'horizontale en tournant dans le sens inverse des aiguilles d'une montre). Les valeurs de la fonction sinus se lisent sur le trait vert (en projetant dessus le point d'intersection de la ligne grise avec le cercle trigonométrique), celle de la fonction cosinus sur le trait rouge (en projetant dessus ce même point d'intersection), et celle de la fonction tangente sur le trait bleu (en prolongeant, d'un côté ou de l'autre, le trait gris).


Comme vous le constatez, les fonctions sinus et cosinus ne retournent que des valeurs comprises entre -1 et +1, alors que la fonction tangente peut retourner n'importe quelle valeur.

L'image ci-dessous vous donne la représentation graphique des fonctions sinus (en rouge), cosinus (en jaune) et tangente (en vert). Etant générée à l'aide du SuperScope, vous noterez que les y positifs sont en bas et les y négatifs en haut :


Exemples :    
  sin(0) Vaut 0.
  cos(0) Vaut 1.
  tan(0) Vaut 0.
  sin(π) Vaut 0 (π correspond à un demi tour).
  cos(π) Vaut -1.
  tan(π) Vaut 0.
  sin(π/2) Vaut 1 (π/2 correspond à un quart de tour).
  cos(π/2) Vaut 0.
  sin(π/4) Vaut environ 0,707.
  cos(π/4) Vaut environ 0,707.
  tan(π/4) Vaut 1.

Notez que lorsque vous faites un tour complet, vous revenez évidemment au point de départ. En termes mathématiques, cela revient à ajouter 2π à votre angle de départ. La même chose se reproduit quelque soit le nombre de tours que vous faites. Donc, si n est ce nombre de tours, nous avons :

     sin(a) = sin(a + n * 2*pi)

     cos(a) = cos(a + n * 2*pi)

     tan(a) = tan(a + n * 2*pi)

En d'autres termes, si a augmente sans arrêt, ces fonctions retourneront régulièrement les mêmes valeurs.

AVS dispose également des fonctions trigonométriques inverses, qui, à partir d'une valeur, donnent un angle.

Syntaxes :    
  Arc-sinus asin(<expression>)
  Arc-cosinus acos(<expression>)
  Arc-tangente atan(<expression>)

Comme pour les fonctions précédentes, vous trouverez ci-dessous une image vous donnant la représentation graphique des fonctions arc-sinus (en rouge), arc-cosinus (en jaune) et arc-tangente (en vert).


Notez que pour des valeurs de x au-delà de -1 ou de 1, c'est à dire, là où les tracés des fonctions arc-sinus et arc-cosinus s'arrête, AVS retournera toujours, pour ces deux fonctions, la valeur -1.

Exemples :    
  asin(0) Vaut 0.
  asin(t) Vaut entre -π/2 et π/2.
  acos(-1) Vaut π.
  acos(t) Vaut entre 0 et π.
  atan(0) Vaut 0.
  atan(t) Vaut entre -π/2 et π/2.

Pour terminer, AVS dispose d'une dernière fonction trigonométrique un peu spéciale :

Syntaxe :    
  Arc-tangente 2 atan2(<expression>,<expression>)

Cette fonction est, en fait, équivalente à l'arc-tangente de la division de la première expression par la seconde. En d'autres termes :

   atan2(x,y) = atan(x/y)

A titre de seul et unique exemple, je vous donne ici les formules permettant de convertir des coordonnées rectangulaires (x et y) en coordonnées polaires (r et d) :

   r=atan2(x,-y) et d=sqrt((x*x+y*y)/2)

Les fonctions de tests

Les trois premières fonctions de ce groupe permettent de comparer deux valeurs.

Syntaxes :    
  Egal equal(<expression>,<expression>)
  Supérieur above(<expression>,<expression>)
  Inférieur below(<expression>,<expression>)

Le tableau suivant, au travers d'exemples concrets, devrait être la plus claire de toutes les explications :

a b equal(a,b) above(a,b) below(a,b)
5 5 1 0 0
5 10 0 0 1
10 5 0 1 0
-10 -5 0 0 1
-5 -10 0 1 0

La chose importante à retenir, c'est que le résultat de ces fonctions est soit 1 pour VRAI, soit 0 pour FAUX.


Le groupe de fonctions suivant permet de donner le résultat d'un test faisant intervenir deux conditions. En d'autres termes, ces fonctions permettent d'effectuer des opérations logiques entre des conditions comme celles citées ci-dessus.

Syntaxes :    
  Et band(<condition>,<condition>)
  Ou bor(<condition>,<condition>)
  Non bnot(<condition>)

Encore une fois, rien ne valant quelques exemples, vous devriez trouver votre bonheur dans le tableau ci-dessous :

a b band(a,b) bor(a,b) bnot(a)
0 0 0 0 1
0 1 0 1 1
1 1 1 1 0
10 5 1 1 0
0 5 0 1 1

Comme le montrent les deux derniers exemples, toute valeur différente de zéro est considérée comme signifiant VRAI.

Les fonctions suivantes permettent d'obtenir un résultat selon la valeur numérique du ou des paramètres qui lui sont fournis.

Syntaxes :    
  Minimum min(<expression>,<expression>)
  Maximum max(<expression>,<expression>)
  Signe sign(<expression>)
  Valeur absolue abs(<expression>)

Encore une fois, vous devriez trouver toutes les explications sur ces fonctions dans les exemples ci-dessous.

Exemples :    
  min(a,b) Vaut a s'il est plus petit que b, et b s'il est plus petit que a.
  min(8,10) Vaut 8.
  min(1.5,-1.5) Vaut -1.5.
  min(-8,-10) Vaut -10.
  max(a,b) Vaut a s'il est plus grand que b, et b s'il est plus grand que a.
  max(8,10) Vaut 10.
  max(1.5,-1.5) Vaut 1.5.
  max(-8,-10) Vaut -8.
  sign(a) Vaut -1 si a est plus petit que 0, 0 si a vaut 0, et 1 si a est plus grand que 0.
  sign(8) Vaut 1.
  sign(0) Vaut 0.
  sign(-8) Vaut -1.
  abs(a) Vaut -a si a est plus petit que 0, et a si a est plus grand que 0 (abs(a) est égal à a*sign(a)).
  abs(8) Vaut 8.
  abs(0) Vaut 0.
  abs(-8) Vaut 8.

La fonction suivante permet d'obtenir un résultat différent selon que la condition donnée est vraie ou fausse.

Syntaxe :    
  Si ... alors ... sinon if(<condition>,<expression>,<expression>)
Exemples :    
  if(c,a,b) Vaut a si c est VRAI, et b si c est FAUX.
  if(1,10,20) Vaut 10.
  if(0,10,20) Vaut 20.
  if(above(a,b),-1,1) Vaut -1 si a est plus grand que b, et 1 sinon.
  if(a,0,1) Vaut 0 si a est différent de 0, et 1 sinon.

Les fonctions de son

Rassurez vous, les deux fonctions suivantes ne génèrent pas des sons, mais vont plutôt récupérer les caractéristiques du son que diffuse Winamp.

Syntaxes :    
  Oscillo. getosc(<expression 1>,<expression 2>,<expression 3>)
  Spectre. getspec(<expression 1>,<expression 2>,<expression 3>)

Dans les deux syntaxes ci-dessus :

expression 1 est une valeur comprise entre 0 et 1 indiquant le point central où l'information est récupérée.

expression 2 est également une valeur comprise entre 0 et 1 indiquant la largeur de la zone où l'information est récupérée.

expression 3 indique le canal sur lequel l'information est prélevée : 1 pour le canal gauche, 2 pour le canal droite, et 0 pour un mélange des deux.

Noter que ces deux fonctions, lorsqu'elles utilisent les mêmes paramètres, retournent toujours les mêmes valeurs pour une image de l'animation à créer (elles sont donc très utiles pour synchroniser des effets).

Comme il est assez difficile de donner des exemples parlant pour ces fonctions, nous allons voir de quoi est composé un son, afin de mieux comprendre leur utilité.

Quel qu'il soit, un son n'est ni plus ni moins qu'une vibration de l'air.

Plus le son est fort, plus cette vibration est importante. En termes plus techniques, on dit que son amplitude augmente. Inversement, plus le son est faible, plus son amplitude diminue.

De la même façon, plus un son est aigu, plus la vibration est rapide. En termes techniques, on dit que sa fréquence augmente. Inversement, plus un son est grave, plus sa fréquence diminue.

Comme nous venons de la voir, de façon très simplifiée, un son dépend donc de deux choses : son amplitude et sa fréquence.

Et bien, la fonction getosc() permet d'obtenir l'amplitude d'un son à un instant donné. Comme il s'agit d'une vibration, cette amplitude pourra varier entre -1 et 1 si le son est fort, et rester près de 0 si le son est faible.

Quant à la fonction getspec(), c'est un peu plus compliqué. Contrairement à ce que vous auriez pu croire, elle ne va pas vous donner la fréquence du son, tout simplement parce que, dans la majorité des cas, un son contient une multitude de fréquences mélangées. En réalité, cette fonction va simplement vous indiquer l'importance d'une fréquence donnée. Dans ce cas, comme il s'agit plus ou moins d'un pourcentage, la valeur retournée pourra varier entre 0 (fréquence absente) et 1 (fréquence dominante).

Les fonctions d'interface

 2.8 Ces fonctions sont utiles pour connaître diverses données de votre système.

Syntaxes :    
  Temps système gettime(<expression>)
  Clavier-Souris getkbmouse(<expression>)
Exemples :    
  gettime(a) Temps écoulé, en secondes (avec décimales), depuis a, lui-même résultat d'un gettime() précédent. Très utile pour synchroniser des effets.
  gettime(0) Temps écoulé depuis le démarrage de votre système. Indispensable pour démarrer la synchronisation ci-dessus.
  gettime(-1) Temps écoulé depuis le début du morceau de musique que vous écoutez.
  gettime(-2) Durée totale du morceau que vous écoutez.
  getkbmouse(1) Retourne la position en x de la souris (0 correspond au centre de l'image, et -1 et 1 aux bords de celle-ci).
  getkbmouse(2) Retourne la position en y de la souris (0 correspond au centre de l'image, et -1 et 1 aux bords de celle-ci).
  getkbmouse(3) Retourne la position du bouton gauche de la souris (0 bouton relâché, 1 bouton appuyé).
  getkbmouse(4) Retourne la position du bouton droit de la souris (0, bouton relâché, 1 bouton appuyé).
  getkbmouse(5) Retourne la position du bouton central de la souris (0, bouton relâché, 1 bouton appuyé).
  getkbmouse(n) Retourne l'état de la touche du clavier dont le code est n (voir ci-dessous).

Comme nous venons de le voir dans le dernier exemple, il est possible de connaître l'état d'une touche quelconque du clavier. Mais pour cela, il est nécessaire de connaître le code de chacune celle-ci. Le moyen le plus sûr est de créer la présélection suivante :

Il vous suffira ensuite d'appuyer sur une touche quelconque (et pas que dans AVS d'ailleurs) pour voir apparaître son code dans la fenêtre de visualisation.

Les autres fonctions

Les fonctions restantes seront traitées une par une, et de façon simplifiée, dans ce dernier paragraphe.

rand(a)

Cette fonction renvoie une valeur aléatoire entière comprise entre 0 et a-1.

floor(a)

 2.8  Cette fonction renvoie la valeur entière immédiatement inférieure à a.

ceil(a)

 2.8  Cette fonction renvoie la valeur entière immédiatement supérieure à a.

pow(a,p)

En mathématiques, cette fonction s'écrit sous la forme :

        ap

Qui se lit, a à la puissance p.

Lorsque p est entier, cela revient à faire p fois la multiplication de a par lui-même. Par exemple :

    pow(6,4) = 64 = 6 * 6 * 6 * 6 = 1296

sqr(a)

Cette fonction retourne le carré de a, c'est à dire a multiplié par lui-même. En fait, c'est l'équivalent de pow(a,2).

sqrt(a)


Cette fonction retourne la racine carré de a, c'est à dire une valeur telle que, multipliée par elle-même cela donne a. Par exemple 2 est la racine carrée de 4 parce que 2 * 2 = 4.


Cette fonction n'a, normalement, de sens que si a est positif (c'est à dire, plus grand que zéro). Avec AVS, elle acceptera tout de même une valeur négative (donc inférieure à zéro), celui-ci utilisera simplement la valeur absolue de ce nombre pour donner son résultat.

Noter, au passage, que cette fonction est équivalente à pow(a,0.5).

invsqrt(a)

 2.8  Cette fonction retourne l'inverse de la racine carré de a. En fait, elle est équivalente à 1/sqrt(a). Attention, pour des résultats cohérents a doit être strictement supérieur à 0.

exp(a)

Cette fonction, bien qu'elle n'apparaisse pas dans l'aide sur les expressions, est également disponible dans AVS. Elle renvoie e à la puissance a. e est le nombre d'Euler et vaut environ 2,718 (voir ci-dessous).

log(a)

Cette fonction renvoie le logarithme népérien de a. On dit également logarithme naturel, ou encore, logarithme base e. Elle retourne la valeur p telle que e à la puissance p est égal à a. Ce qui s'écrit encore :

   log(a) = p  <=>  ep  = a

Cette fonction n'a de sens que si a est positif, dans le cas contraire elle retournera toujours -1.

log10(a)

Cette fonction renvoie le logarithme base 10 de a. Elle retourne la valeur p telle que 10 à la puissance p est égal à a. Ce qui s'écrit encore :

   log10(a) = p  <=>  10p  = a

Par exemple, log10(1000) vaut 3, parce que 10 à la puissance 3 est égal à 1000.

Comme la précédente, cette fonction n'a de sens que si a est positif, dans le cas contraire elle retournera toujours -1.

sigmoid(x,p)

Pour ceux que cela intéresse, cette fonction est équivalente à :

           1    
        1 + e(-p*x)

Pour une bonne partie d'entre vous, je pense cela ne signifie pas grand chose. Mais, rassurez vous, cela n'a aucune importance. Lisez simplement la suite, et vous saurez l'essentiel.

L'image ci-dessous, obtenue à l'aide du SuperScope de AVS, vous montre le tracé de plusieurs courbes sigmoïdes pour lesquelles x varie toujours de -2 à +2, et p, de -10 (en bleu) à +10 (en rouge).


Comme vous pouvez le constater, quelque soit la valeur de p (sauf pour zéro), cette fonction renvoie toujours une valeur entre 0 et 1. Ces valeurs seront atteintes pour des valeurs absolues de x de plus en plus élevées au fur et à mesure que n s'approche de 0, alors que, lorsque la valeur absolue de p atteint 100 et plus, ces deux valeurs 0 et 1 sont obtenues presque immédiatement dès que x s'éloigne de 0.

Noter que, quelque soit la valeur de x, cette fonction retourne toujours 0.5 lorsque p vaut 0.


Page précédente
Retour à la présentation
Retour à l'accueil