|
Documentation language LUA |
Fonctions mathématiques |
Renvoyez l'absolu, ou la valeur positive, d'une
valeur donnée.
> = math.abs(-100) 100
> = math.abs(25.67) 25.67
Renvoyez la tangente inverse. Nous pouvons
faire ceci en fournissant y/x nous-mêmes employant math.atan ou
nous pouvons passer y et x à math.atan2 pour faire ceci pour nous.
> c, s = math.cos(0.8), math.sin(0.8) > = math.abronzage(s/c) 0.8 > = math.atan2(s, c) 0.8
math.atan2 si habituellement soyez préféré, en particulier
quand convertir rectangulaire coordonne à polaire coordonne. math.atan2 emploie le signe des deux arguments de 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
> = math.floor(0.5) 0 > = math.ceil(0.5) 1
> = math.cos(math.pi/4) 0.70710678118655 > = math.sin(0.123) 0.12269009002432 > = math.tan(5/4) 3.0095696738628 > = math.tan(.77) 0.96966832796149
> = 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
> = math.log10(100) 2 > = math.log10(256) 2.4082399653118 > = math.log10(-1) -1.#IND
math.pow() soulève 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 comme 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
> = 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
> = math.mod(7,3) 1 > = math.mod(9,3) 0 > = math.mod(100,2.3) 1.1
> = 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 d'approvisionnement change
son comportement :
math.random() sans des arguments produit d'un vrai nombre entre 0 et 1.
math.random(upper) produit des nombres de nombre entier entre 1 et du haut.
math.random(lower, upper) produit des nombres de nombre entier entre inférieur et le
haut.
> = 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
math.floor(upper) et
autres math.ceil(upper), avec les résultats inattendus (les mêmes pour inférieur).
math.randomseed() La fonction place une graine pour le générateur pseudo-aléatoire : Les
graines égales produisent des ordres égaux des 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 'graine 'est os.time(), mais attend une seconde avant d'appeler la fonction pour obtenir un autre ordre ! Pour obtenir l'utilisation gentille 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 obtenu avec une graine 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 le bruit juste un certain nombre aléatoire avant de les employer pour 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 le mauvais) que le second et les autres. La qualité du générateur dépend d'autres choses. Pour améliorer légèrement le générateur intégré nous pouvons employer une table sous la forme :
-- en améliorant le générateur pseudo-aléatoire
intégré faites randomtable local local d'oldrandom = de math.random
math.random = fonction () si zéro randomtable de == puis randomtable
= {} pour I = 1, 97 font le randomtable[i ] = extrémité
d'extrémité d'oldrandom() locale des gens du pays de x =
d'oldrandom() i = 1 + math.floor(97*x) x, randomtable[i ] =
randomtable[i ], l'extrémité de retour d'extrémité de x x
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 |
|