|
Programmation en language LUA | |
Fonctions mathématiques |
Ce document présente les fonctions mathématiques en LUA. Ces fonctions peuvent être utilisées dans les scripts LUA de LoriotPro.
Chaque fonction est décrite,
avec un exemple.
math.abs
Renvoie la valeur absolu, ou la valeur positive, d'une valeur donnée.
> = math.abs(-100)
100
> = math.abs(25.67)
25.67
Renvoie le cosinus et le sinus inverse de la valeur donnée.
> = math.acos(1)
0
> = math.acos(0)
1.5707963267949 > =
math.asin(0)
0
> = math.asin(1)
1.5707963267949
Renvoie la tangente inverse. Nous pouvons
faire ceci en fournissant y/x en employant math.atan ou
nous pouvons passer y et x à math.atan2 pour le faire à notre place.
> c, s = math.cos(0.8), math.sin(0.8)
> =
math.atan(s/c)
0.8
> = math.atan2(s, c)
0.8
math.atan2 doit être utilisé de préférence et en particulier
quand on convertit des coordonnées rectangulaires en coordonnées polaires. math.atan2 emploie le signe des deux arguments pour placer le
résultat dans le quart de cercle correct, et produit également des
valeurs correctes quand un de ses arguments est 0 ou très de près de
0.
> = math.atan2(1, 0), math.atan2(-1, 0), math.atan2(0, 1),
math.atan2(0, -1)
1.5707963267949 -1.5707963267949 0 3.1415926535898
Renvoie le nombre entier au-dessus et au-dessous d'une valeur donnée.
> = math.floor(0.5)
0
> = math.ceil(0.5)
1
Renvoie le cosinus, le sinus et la valeur de tangente pour une valeur donnée.
> = math.cos(math.pi/4)
0.70710678118655
> =
math.sin(0.123)
0.12269009002432
> = math.tan(5/4)
3.0095696738628
> =
math.tan(.77)
0.96966832796149
Convertir des radians en degrés et vice versa.
> = math.deg(math.pi)
180
> = math.deg(math.pi/2)
90
> =
math.rad(180)
3.1415926535898
> = math.rad(1)
0.017453292519943
math.exp() renvoie e (la
base des logarithmes normaux) augmenté à une puissance donnée.
math.log() renvoie l'inverse de ceci. e a la valeur retournée près math.exp(1).
> = math.exp(0)
1
> = math.exp(1)
2.718281828459
> =
math.exp(27)
532048240601.8
> = math.log(532048240601)
26.999999999998
> = math.log(3)
1.0986122886681
Renvoie le logarithme base 10 d'un nombre donné. Le nombre doit être positif.
> = math.log10(100)
2
> = math.log10(256)
2.4082399653118
> = math.log10(-1)
-1.#IND
math.pow() porte le premier paramètre à la puissance du
deuxième paramètre et renvoie le résultat. L'opérateur ^ binaire exécute le même travail que math.pow(),
c.-à-d.. math.pow(x, y) == x^y.
> = math.pow(100,0)
1
> = math.pow(7,2)
49
> =
math.pow(2,8)
256
> = math.pow(3,2.7)
19.419023519771
> = 5 ^ 2
25
> =
2^8
256
Renvoie la valeur minimum ou maximum d'une liste de longueur variable d'arguments.
> = math.min(1,2)
1
> = math.min(1.2, 7, 3)
1.2
> =
math.min(1.2, -7, 3)
-7
> = math.max(1.2, -7, 3)
3
> = math.max(1.2,
7, 3)
7
Divisez le premier argument par la seconde et renvoie le reste.
> = math.mod(7,3)
1
> = math.mod(9,3)
0
> =
math.mod(100,2.3)
1.1
Renvoie la racine carrée d'un nombre donné. Seulement on permet des arguments positifs.
> = math.sqrt(100)
10
> = math.sqrt(1234)
35.128336140501
> = math.sqrt(-7)
-1.#IND
math.random() produit des nombres pseudo-aléatoires
uniformément distribués. L'argument fourni change
son comportement :
math.random() sans arguments produit d'un nombre entre 0 et 1.
math.random(upper) produit des nombres entiers entre 1 et upper.
math.random(lower, upper) produit des nombres entiers entre lower et upper.
> = math.random()
0.0012512588885159
> = math.random()
0.56358531449324
> = math.random(100)
20
> = math.random(100)
81
> =
math.random(70,80)
76
> = math.random(70,80)
75
lower et upper doivent être des nombres entiers sinon Lua convertit upper en un nombre entier.
L'utilisation de math.floor(upper) et
math.ceil(upper), donne des résultats inattendus (idem pour lower).
math.randomseed() La fonction utilise une base pour le générateur pseudo-aléatoire : Les
bases égales produisent des ordres égaux de nombres.
> math.randomseed(1234)
> = math.random(), math.random(),
math.random()
0.12414929654836 0.0065004425183874 0.3894466994232
>
math.randomseed(1234)
> = math.random(), math.random(), math.random()
0.12414929654836 0.0065004425183874 0.3894466994232
Une bonne base est os.time(), mais il faut attendre au moins une seconde avant d'appeler la fonction pour obtenir un autre nombre aléatoire ! Pour obtenir une suit de nombres aléatoires :
math.randomseed(os.time())
Si Lua pourrait obtenir des millisecondes de os.time() l'init pourrait être meilleur fait. Néanmoins, dans certains cas nous avons besoin d'un ordre d'exécution des instructions, comme celle obtenu avec une base connue.
Mais prenez garde ! Le premier nombre aléatoire que vous obtenez 'n'est pas vraiment randomisé '(au moins dans Windows 2K et OS X). Pour obtenir à un meilleur nombre pseudo-aléatoire il faut générer quelques nombres aléatoires avant d'en obtenir un vrai :
-- initialisez le pseudo générateur de nombre aléatoire
math.randomseed(os.time())
math.random() ; math.random() ;
math.random() -- fait : -)
-- ce pas exactement vrai. Le premier nombre aléatoire est aussi bon (ou mauvais) que le second et les autres. La qualité du générateur dépend d'autre chose. Pour améliorer légèrement le générateur intégré nous pouvons employer une table.
Ce sont les fonctions de normalisation . math.frexp() . La fonction est
employée pour couper la valeur de nombre en fraction normale et
exposant. Deux valeurs sont retournées : le premier est
une valeur toujours dans la gamme 1/2 (incluse) à 1 (exclusivité) et
la seconde est un exposant. math.ldexp() La fonction prend un nombre
normalisé et renvoie la représentation de virgule flottante.
C'est la valeur multipliée par 2 à la puissance de l'exposant.
> = math.frexp(2)
0.5 2
> = math.frexp(3)
0.75 2
> =
math.frexp(128)
0.5 8
> = math.frexp(3.1415927)
0.785398175 2
> =
math.ldexp(0.785,2)
3.14
> = math.ldexp(0.5,8)
128
 www.loriotpro.com |
|