choose(val0, val1, val2... val15);
Argumento | Descripción |
---|---|
val0... val15 | El (los) argumento(s) puede ser string, entero, variable o una constant. |
Devuelve: Uno de los argumentos dados.
En ocasiones se requiere especificar algo más que números en una selección aleatoria, o los números requeridos no presentan ningún orden o rango específico. En estos casos se puede recurrir a choose() para obtener un resultado aleatorio. Por ejemplo, digamos que deseas crear un objeto con un sprite aleatorio al inicio, entonces podrias usar esta función para establecer el sprite index de entre uno hasta 16 sprites.
NOTA: Esta función devolverá el mismo valor cada vez que el juego se ejecute debido a que GameMaker:Studio genera la misma semilla aleatoria para facilitar la depuración del código. Para evitar este comportamiento debes usar la función randomize o random_set_seed al inicio de tu juego.
sprite_index = choose(spr_Cactus, spr_Flower, spr_Tree, spr_Shrub);
hp = choose(5, 8, 15, 32, 40);
name = choose("John", "Steven", "Graham", "Jack", "Emily", "Tina", "Jill", "Helen");
random(n);
Argumento | Descripción |
---|---|
n | El límite superior del rango desde el cual se seleccionará el número aleatorio |
Devuelve: Real
Esta función resulta útil para generar probabilidades en las que no son necesarios número enteros. Por ejemplo, random(100) regresará un valor entre 0 y 99, ¡pero ese valor puede ser 22.56473! También puedes utilizar números reales y no enteros en la función de la siguiente manera - random(0.5), la cual regresará un valor entre 0 y 0.4999999.
NOTA: Esta función devolverá el mismo valor cada vez que el juego se ejecute de nuevo debido a que GameMaker:Studio genera la misma semilla aleatoria una y otra vez, de manera que la depuración del código resulte más sencilla. Para evitar este comportamiento puedes utilizar randomize o random_set_seed al inicio de tu juego para generar una nueva semilla aleatoria.
if random(10) >= 9
{
score += 100;
}
Esto producirá aproximadamente una oportunidad en diez de agregar 100 a la variable score.
random_range(n1, n2);
Argumento | Descriptción |
---|---|
n1 | Límite inferior del rango de números elegibles. |
n2 | Límite superior del rango de números elegibles. |
Devuelve: Real
Esta función devuelve un número aleatorio dentro del rango especificado, número que no necesariamente debe ser entero. Por ejemplo, random_range(20,50) devolverá un número aleatorio entre 20 y 49, pero el valor puede ser un número real como 38,65265. Se pueden utilizar número reales como argumentos de entrada.
NOTA: Esta función devolverá el mismo valor cada vez que el juego se ejecute de nuevo debido a que GameMaker:Studio genera la misma semilla aleatoria con la finalidad de facilitar la depuración del código. Para evitar este comportamiento puedes utilizar la función randomize o random_set_seed al inicio de tu juego para generar una nueva semilla aleatoria.
score += random_range(500, 600);
Esto sumará un número entre 500 y 600, al valor total de la variable score.
irandom(n);
Argumento | Descripción |
---|---|
n | El límite superior para escoger un número al azar. |
Devuelve: Entero
Esta muy útil función solo devuelve enteros. Así pues, por ejemplo, para obtener un número al azar desde 0 a 9 puedes utilizar irandom(9) lo cual devolverá un número desde 0 a 9 incluído. Si se utiliza un número real como límite superior, éste será excluído del rango, así irandom(9.7) devolverá simplemente un valor entre 0 y 9.
NOTA: Esta función devolverá el mismo valor cada vez que el juego vuelva a ejecutarse debido a que GameMaker:Studio genera una y otra vez la misma semilla aleatoria inicial, con la finalidad de simplificar la depuración del código (debugging). Para evitar este comportamiento utiliza randomize o random_set_seed
al inicio de tu juego.
if irandom(9) = 1
{
score += 100;
}
Esto producirá una posibilidad de 1/10 (ya que el 0 esta incluido) de que se sume 100 al puntaje.
irandom_range(n1, n2);
Argumento | Descripción |
---|---|
n1 | Límite inferior del rango de números elegibles. |
n2 | Límite superior del rango de números elegibles. |
Devuelve: Entero
Esta función es similar a random_range(), sólo que con números enteros como argumento. Así, irandom_range(10, 35) devolverá un número entero entre 10 y 35. Es posible usar números reales como con la función irandom(), en cuyo caso se redondearán al entero más cercano, por ejemplo: irandom_range(6.2,9.9) devolverá un valor entre 6 y 9.
NOTA: Esta función devolverá el mismo valor cada vez que el juego se ejecute de nuevo debido a que GameMaker:Studio genera la misma semilla aleatoria con la finalidad de facilitar la depuración del código. Para evitar este comportamiento puedes utilizar la función randomize o random_set_seed al inicio de tu juego para generar una nueva semilla aleatoria.
score += irandom_range(500, 600);
Esto agregará un número entre 500 y 600, al valor total de la variable score.
random_set_seed(val);
Argumento | Descripción |
---|---|
val | La semilla (seed) a establecer. |
Devuelve: N/A
Para generar un número aleatorio GameMaker:Studio inicia con un número aleatorio o semilla (seed). Con esta función se puede establecer la semilla (seed) a un número conocido y así "forzar" el resultado de todos los eventos aleatorios para que sean iguales cada vez que el programa sea ejecutado. Por ejemplo, esta función puede ser usada en conjunto con random_get_seed para crear contenido generado de manera procesal y guardar los resultados evitando partidas guardadas de gran tamaño (solamente se guarda la semilla, sin necesidad de nada más). Si necesitas resultados realmente aleatorios para todo, debes usar la función randomize().
NOTA: Aunque la semilla da resultados consistentes en la plataforma que elijas, los resultados pueden variar entre plataformas debido a las diferentes formas en que cada plataforma trabaja.
if debug random_set_seed(1);
Este código establece una semilla aleatoria en 1 solo si la variable "debug" es verdadera.
random_get_seed();
Returns: Real
To generate a random number GameMaker:Studio starts with a random seed number. With this function you can retrieve that seed, which can then be stored to reproduce a specific
series of random events. For example, say you have a procedurally generated game, but want the player to be able to go back to previously discovered areas. Well, at the start of each area, you
can store the random seed with this function and so every time you need to go back there, you can use random_set_seed to set the seed to what it
was previously and so force GameMaker:Studio to reproduce the same set of "random" functions that it used previously.
ini_open("Save.ini")
ini_write_real("Levels", string(level), random_get_seed());
ini_close();
The above code will get the random seed and store it in an ini file.
randomize();
Returns: No aplica
Esta función ajusta la semilla a un valor aleatorio. Si se requiere un valor consistente a lo largo de distintas ejecuciones del juego, se debería optar por la función random_set_seed(). Se debe notar que cuando se utilizan funciones aleatorias en GameMaker:Studio la semilla inicial siempre es la misma con el objeto de facilitar la depuración de errores. Si se desea hacer pruebas con un valor realmente aleatorio, hay que llamar a esta función al inicio del juego.
randomize();
El código anterior ajustará aleatoriamente el valor de la semilla.
arccos(x)
Argumento | Descripción |
---|---|
x | El ángulo (en radianes) del cual obtener el coseno inverso. |
Devuelve: Real
val = arccos(0);
Esto ajustará val a pi/2.
arcsin(x);
Argumentoo | Descripción |
---|---|
x | El ángulo (en radianes) del cual se devolverá el seno inverso. . |
Devuelve: Real
Devuelve el seno inverso de x, de modo que si sin(x)=n, arcsin(n)=x y el número resultante estará entre -pi/2 y pi/2.
NOTA: Esta función solo acepta números
entre -1 and 1 (cualquier otro generará un error), y
el valor devuelto estará en grados, no radianes.
val = arcsin(0);
Esto hará que "val" tome el valor de 0.
arctan(x);
Argumento | Descripción |
---|---|
x | El ángulo (en radianes) del cual calcular la tangente inversa. |
Devuelve: Real
Devuelve la yangente inversa de x. Esta función acepta cualquier número, ya que a diferencia de la función tan, las asíntotas de arctan se hallan en el eje y por lo que nunca se obtiene mayor a pi/2 o menor a -pi/2.
NOTA: El valor devuelto está en radianes, no grados.
val = arctan( 0 );
Esto pondrá a val en 0.
arctan2(y, x);
Argumento | Descripción |
---|---|
y | The y coordinate to calculate. |
x | The x coordinate to calculate. |
Devuelve: Real
Esta función devuelve la tangente inversa de un ángulo y/x, donde y = cateto opuesto de un triangulo y x = cateto adyacente del triangulo. A diferencia de arctan(x), la función arctan2(y, x) es valida para todos los ángulos y puede ser usada para convertir un vector en un ángulo sin que haya división entre cero, y también devolverá el resultado en el cuadrante correcto.
NOTA: El valor devuelto está en radianes, no en grados.
val = arctan2(1, 1);
Esto ajustará val al ángulo correcto, en este caso 0.79.
sin(val);
Argumento | Descripción |
---|---|
val | El ángulo (en radianes). |
Devuelve: Real
En un triangulo rectángulo, seno(val) = cateto opuesto / hipotenusa, donde val es uno de los tres ángulos.
NOTA: El valor devuelto está en radianes, no grados.
val = sin( pi/2 );
Esto pondrá a val en 1.
cos(val);
Argumento | Descripción |
---|---|
val | El ángulo (en radianes). |
Devuelve: Real
En un triángulo rectángulo cos(val) = cateto adyacente / hipotenusa, donde val es uno de los tres ángulos. Esta función siempre devuelve un número entre 1 y -1.
NOTA: El valor devuelto está en radianes, no en grados.
val = cos( 0 );
Esto pondrá a val en 1.
tan(val);
Argumento | Descripción |
---|---|
val | El ángulo del que se calculará la tangente (en radianes). |
Devuelve: Real
En un triángulo rectángulo, tan(val) = Opuesto / Adyacente donde val es uno de los tres ángulos.
NOTA:El valor devuelto está en radianes, no grados.
NOTA 2: Pi/2, (3 pi/2), -pi/2 y otro gran número de valores producirán error con esta función debido a que devuelve infinito. Una representación gráfica produciria asíntotas en esos valores.
val = tan( pi );
Esto hace que val sea 0.
darccos(x)
Argumento | Descripción |
---|---|
x | El ángulo (en grados) del que se desea calcular el coseno inverso. |
Devuelve: Real
Devuelve el coseno inverso de x, de manera que si dcos(val)=x, darccos(x)=val, y el número resultante estará entre 180 y 0.
NOTA: Sólo se acepta un número entre -1 y 1 (acualquier otro valor arrojará un error). El resultado está en grados, no radianes.
val = darccos(-1);
Esto pone "val" a 180.
darcsin(x);
Argumento | Descripción |
---|---|
x | El seno inverso del ángulo(en grados) . |
Devuelve: Real
Devuelve el seno inverso de x, de modo que si dsin(x)=n, darcsin(n)=x, el número resultante estará entre -90 y 90.
NOTA: Esta función solo acepta números
entre -1 and 1 (cualquier otro generará un error), y
el valor devuelto estará en grados, no radianes.
val = darcsin(-1);
Esto le dará a "val" el valor de -90.
arctan2(y, x);
Argumento | Descripción |
---|---|
y | La coordenada y. |
x | La coordenada x. |
Devuelve: Real
Esta función devuelve la tangente inversa de un ángulo y/x, donde y = cateto opuesto de un triangulo y x = cateto adyacente del triangulo. Al contrario de darctan(x) la función darctan2(y, x) es valida para todos los ángulos y puede ser usada para convertir un vector en un ángulo sin que haya división entre cero, y también devolverá el resultado del cuadrante correcto.
NOTA: El valor resultante está en grados, no en radianes.
val = darctan2(1, 1);
Esto le dará a val el ángulo correcto.
degtorad(deg);
Argumento | Descripción |
---|---|
deg | La cantidad de grados a convertir. |
Devuelve: Real
Desde versiones anteirores de GM, todas las funciones trigonométricas han trabajado en radianes, pero la mayoría de personas usan grados, por lo que para convertir grados en radianes debes usar esta función. Ejemplo: degtorad(180) devuelve 3.14159265 radianes. Esta función calcula los radianes mediante la fómula:
ángulo(radianes) = ángulo(grados) * pi / 180
val = degtorad(90);
Esto ajusta val al valor pi/2.
radtodeg(rad);
Argumento | descripción |
---|---|
rad | Los radianes a convertir. |
Devuelve: Real
Una vez que hallas terminado de hacer tus cálculos usando seno, coseno etc... el resultado estará en radianes. Esto no siempre es lo deseado, por tanto, para convertir radianes a grados existe esta función. Por ejemplo, radtodeg(sin(180)) devuelve -45 grados. En la conversión se utiliza la siguiente formula:
angulo_en_grados = angulo_en_radianes * 180 / pi;
val = radtodeg( pi );
Esto ajustará val a 180.
lengthdir_x(len, dir);
Argumentoo | Descripción |
---|---|
len | La longitud del vector (a partir del origen de la instancia). |
dir | La dirección del vector. |
Devuelve: Real
Esta función se usa para obtener la componente x de una posición ubicada a "len" pixels del punto inicial y en dirección "dir". Imagina un círculo rodeando a la instancia, ahora imagina un punto en cualquier lugar de esa circunferencia. Para llegar hasta ese punto necesitamos mover el objeto tantos pixels en esa dirección... esta función (cuando se usa en conjunto con lengthdir_y) obtiene la posición de ese punto, la cual se usará para mover la instancia. Consulta la siguiente imagen para mayor detalle:
Como puedes ver, el valor "len" define al radio de la circunferencia.
instance_create(x + lengthdir_x(64, image_angle), y + lengthdir_y(64, image_angle), obj_bullet);
Este código crea la instancia de una bala en el punto (x,y), pero con 64 pixels sumados en dirección del ángulo definido por image_angle. Esta es una técnica común para "sincronizar" la posición inicial de una bala con la punta de la pistola (la cual puede rotar y desplazarse) en un juego.
lengthdir_y(len, dir);
Argumento | Descripción |
---|---|
len | La longitud del vector (a partir del origen de la instancia). |
dir | La dirección del vector. |
Devuelve: Real
Esta función se usa para obtener la componente y de una posición ubicada a "len" pixels del punto inicial y con una dirección "dir". Imagina un círculo rodeando a la instancia, ahora imagina un punto en cualquier lugar de esa circunferencia. Para llegar hasta ese punto necesitamos mover el objeto tantos pixels en esa dirección... esta función (cuando se usa en conjunto con lengthdir_x) obtiene la posición de ese punto, la cual se usará para mover la instancia. Consulta la siguiente imagen para mayor detalle:
Como puedes ver, "len" define el radio de la circunferencia.
instance_create(x + lengthdir_x(64, image_angle), y + lengthdir_y(64, image_angle), obj_bullet);
Este código crea la instancia de una bala en el punto (x,y), pero con 64 pixels sumados en dirección del ángulo definido por image_angle. Esta es una técnica común para "sincronizar" la posición inicial de una bala con la punta de la pistola (la cual puede rotar y desplazarse) en un juego.
round(n);
Argumento | Descripción |
---|---|
n | El número a redondear. |
Devuelve: Entero
Tal como lo indica su nombre, round() toma un número real y lo redondea hacia arriba o abajo al entero más cercano. En el caso especial en el que el número proporcionado esté exactamente a la mitad entre dos enteros (1.5, 17.5, -2.5, etc), el número será redondeado al entero par más cercano, por ejemplo, 2.5 sería redondeado a 2, mientras que 3.5 se redondearía a 4. A este tipo de redondeo se le llama redondeo de banquero y para iteraciones grandes u operaciones de punto flotante proporciona un redondeo estadísticamente mejor que el enfoque más tradicional "sube si es mayor a 0.5 o de lo contrario baja".
Esto implica que si el decimal de un valor es 0.5, el resultado redondeado es el entero par más cercano al valor de entrada. Así que, por ejemplo, 23.5 resulta en 24, igual que 24.5, mientras que -23.5 resulta en -24, igual que -24.5. Este método trata simétricamente tanto valores positivos como negativos, así que está libre de error, y aun más importante, para una distribución de valores razonable, el valor esperado (en promedio) de números redondeados es el mismo que el de números originales.
score += round(hp / 5);
El código anterior agrega un valor redondeado a la puntuación.
floor(n);
Argumento | Descripción |
---|---|
n | El número a redondear. |
Devuelve: Entero
Devuelve el "suelo" de n, es decir, n redondeado a un entero hacia abajo. Esto es similar a la función round(), pero sólo redondea hacia abajo, sin importar el valor decimal, por lo que por ejemplo floor(5.99999) devolverá 5, como lo hará floor(5.2), floor(5.6457) etc...
val = floor( 3.9 );
Esto pone val en 3.
frac(n);
Argumento | Descripción |
---|---|
n | El número a cambiar. |
Devuelve: Real
Esta función devuelve la parte no entera de n, es decir, la parte después del punto decimal. Por lo tanto frac(3.125) devolverá 0.125, frac(6.921) devolverá 0.921, etc...
val = frac(3.4);
Esto hará que val tome el valor de 0.4.
abs(val)
Argumento | Descripción |
---|---|
val | El número a convertir en absoluto. |
Devuelve: Real
Esta función devuelve el valor absoluto de un argumento de entrada, de modo que si se strata de un valor positivo, se mantendrá igual, pero si es negativo se multiplicará por -1 para hacerlo positivo.
x += abs (x - mouse_x)
Este código sumará una cantidad igual al valor absoluto de la diferencia entre la posición x de la instancia y la posición x del ratón.
sign(n);
Argumento | Descripción |
---|---|
n | El número del cual se desea conocer el signo. |
Devuelve: Entero
Esta función indica si un número es positivo, negativo o ninguno, devolviendo 1, -1, 0 respectivamente. Por ejemplo - sign(458) devolverá 1, sign(-5) devolverá -1 y sign(0) devolverá 0.
y += sign(y - mouse_y);
El código de arriba sumará 1, -1 o 0 dependiendo del resultado de la resta y - mouse_y.
ceil(val);
Argumento | Descripción |
---|---|
x | El número a redondear. |
Devuelve: Entero
Esta función toma cualquier número real y lo redondea hacia arriba hasta el entero más cercano. Hay que tener cuidado en cómo se usa esta función, pues comunmente se comete el error de usarla para redondear hacia arriba un valor aleatorio esperando que siempre sea 1, ejemplo:
int = ceil(random(5));
Se puede suponer que este código siempre dará un entero entre 1 y 5, pero no siempre va a ser el caso, dado que existe la pequeña posibilidad de que la función random devuelva 0, y redondear 0 hacia arriba siempre dará 0. Esta es un posibilidad remota pero se debe tomar en cuenta cuando se usa esta función.
val = ceil( 3.4 );
Esto pondrá val en 4.
max(val1, val2, ... val15);
Argumento | Descripción |
---|---|
val0 ... val15 | Los valores a comparar. |
Devuelve: Real
Esta función devuelve el máximo de los valores de entrada (argumentos), de los cuales puede haber hasta 16. Por ejemplo max(12, 96, 32, 75) devolverá 96 dado que es el valor mas alto de los valores suministrados.
x = max(x, 0);
Esto evitará que el jugador salga de la habitación. Funciona al ajustar constantemente su coordenada x ya sea a cero o a x misma, dependiendo de qué valor sea mayor. Si el jugador sale por la izquierda, su x tendría un valor menor que 0 (negativo), por tanto seria colocado de vuelta en la habitación.
mean(val1, val2, ... val15);
Argumento | Descripción |
---|---|
val0 ... val15 | Los valores a comparar. |
Devuelve: Real
Esta función suma todos los valores de entrada (argumentos) para después dividirlos por su propio número. Por tanto, mean(2, 6, 9, 32) devuelve 12.25 ya que 2+6+9+32=49 y 49/4=12.25.
xmiddle = mean(obj_player1.x, obj_player2.x, obj_player3.x);
ymiddle = mean(obj_player1.y, obj_player2.y, obj_player3.y);
Esto ubicará a xmiddle y a ymiddle en las coordinadas promedio x,y de los tres objetos player obj_player1, obj_player2 and obj_player3. Podrías, por ejemplo, usar esto para mantener la cámara del juego enfocada sobre los tres jugadores en lugar de solo uno.
median(val1, val2, ... val15);
Argumento | Descripción |
---|---|
val0 ... val15 | Los valores con los que trabajará la función . |
Devuelve: Real
Esta función devuelve la mediana de los valores introducidos, es decir, el valor de en medio. Cuando el número de argumentos es par, se devuelve el valor más pequeño del medio. Esta función puede tener un máximo de 16 argumentos los cuales deben ser TODOS valores de tipo real. De acuerdo con lo anterior, por ejemplo, median(43, 12, 25, 19, 6) devolvería 19.
x = median( 0, x, room_width );
y = median( 0, y, room_height );
Este código evita que el jugador salga de la habitación al usar la mediana como un cerco. Si por ejemplo, el jugador se mueve a la izquierda del límite de la habitación, su posición x será menor que 0. Esto resultará en que el número de en medio de la primera función será 0, por lo que el jugador será posicionado en (0,y).
min(val1, val2, ... val15);
Argumento | Descripción |
---|---|
val0 ... val15 | Los valores a comparar. |
Devuelve: Real
Esta función devuelve el menor de los valores de entrada, de los ucales puede haber hasta 16. Por ejemplo, min(12, 96, 32, 75) devolverá 12 como el valor más bajo.
x = min(x, room_width);
Este código evita que el jugador salga por el extremo derecho de la habitación. Esto funciona al ajustar paso a paso su x a su propio valor o la variable room_width variable (el que sea menor). Si el jugador sale de la habitación por la derecha, su posición x sería mayor que el ancho de la habitación, por lo que volvería a quedar dentro.
lerp(a, b, amt)
Argumento | Descripción |
---|---|
a | El primer valor. |
b | El segundo valor. |
amt | El grado de interpolación. |
Devuelve: Real.
Esta función calcula el valor correspondiente a la posición entre otros dos valores según un porcentaje dado. Por ejemplo, si se hace:
lerp(0, 10, 0.5)
se obtendría el valor de 5, el cual es el 50% de los valores de entrada. También se puede usar esta función para extrapolar, al pasar un valor positivo o negativo para la cantidad de interpolación de esta manera:
lerp(0, 10, 2)
devolverá un valor de 20.
xx = lerp(x, x + hspeed, room_speed); yy = lerp(y, y + vspeed, room_speed);
El código anterior usa la función de interpolación lineal para predecir a dónde se habrá movido una instancia después de un segundo (en tiempo de juego).
clamp(val, min, max)
Argumento | Descripción |
---|---|
val | El valor a cercar. |
min | El mínimo del valor para cercar. |
max | El máximo del valor para cercar. |
Devuelve: Real.
Mediante esta función se puede mantener un valor de entrada entre un rango especificado.
speed = clamp(speed, 1, 10);
El código anterior 'cercará' (limitará) la velocidad de manera que nunca disminuirá por debajo de 1 ni excederá a 10.
is_real(n);
Argumento | Descripción |
---|---|
n | El argumento a revisar. |
Devuelve: Booleano
Esta función devuelve si un valor dado es real o no. A veces se necesita comprobar si una variable en GameMaker:Studio contiene un valor numérico real, aquí es donde entra en juego esta función. No devuelve el número, sino true o false, por lo que un valor para n como "fish" devolvería false, pero un valor de 200 para n devolvería true.
if is_real(val)
{
score += val;
}
Este código revisa si la variable "val" es un número real y si lo es, suma el número al marcador del juego.
is_string(n);
Argumento | Descripción |
---|---|
n | El argumento a revisar. |
devuelve: Boleano
Esta función indica si una variable dada es una cadena. En ocasiones se desea revisar si una variable en GameMaker:Studio contiene una cadena y no un número de tipo real, para lo que se usa esta función. No se devuelve la cadena, sino true o false, por lo que por ejemplo, un valor de n como "hola" devolverá true, pero un valor de 200 devolvería false.
if is_string(val)
{
name = "Player: " + val;
}
El código anterior revisa la variable "val" para ver si contiene una cadena y en el caso de ser cierto, el valor se concatena con otra cadena y se asigna a la variable "name".
exp(n);
Argumento | Descripción |
---|---|
n | La potencia de e. |
Devuelve: Real
Esta es la función de potencia (e, n), donde e es aproximadamente 2.718281828 (también conocida como el número de Euler), y n es el número de veces que debe ser multiplicado por si mismo. Esto se puede traducir como "cuánto incremento obtendré después de n unidades de tiempo (y 100% de incremento continuo)?". Entonces exp(3) devuelve 20.08, lo que significa que después de 3 unidades de tiempo tenemos 20.08 veces la cantidad con la que iniciamos.
val = exp(2);
Esto ajusta la variable val a e^2, aproximadamente 7.4.
ln(n);
Argumento | Descripción |
---|---|
n | The input value. |
Devuelve: Real
El logaritmo natural ln(n) es la cantidad de tiempo necesario para alcanzar cierto nivel de crecimiento continuo, donde n es el nivel ha alcanzar. Entonces si queremos encontrar cuantas unidades de tiempo necesitamos para crecer hasta 20, usamos ln(20) el cual retornará 2.99 unidades de tiempo para llegar a esa cantidad de crecimiento.
alarm[0] = ln(age) * room_speed;
El código anterior usa el logaritmo natural del valor guardado en la variable "age" para ajustar el valor de la alarma.
power(x, n);
Argumento | Descripción |
---|---|
x | El número a elevar (base). |
n | Cuántas veces multiplicar x por si mismo (potencia). |
Devuelve: Real
Esta función devuelve el valor de un número multiplicado por si mismo "n" número de veces. Por ejemplo, power(5,3) multiplicará 5 por si mismo tres veces y devolverá 125, lo cual es lo mismo que decir 5*5*5=125. Por favor ten en cuenta que el valor "x" no puede ser un número negativo.
score += power(dmg, 3);
Este código suma al marcador el valor de la variable "dmg" al cubo.
sqr(val);
Argumento | Descripción |
---|---|
val | The number to square. |
Devuelve: Real
Multiplica un número por si mismo, es decir, devuelve el cuadrado de ese número. Ejemplo: sqr(5) devuelve 25 pues 5*5=25.
score += sqr(dmg);
Este código sumará el cuadrado de la variable "dmg" al marcador.
sqrt(val);
Argumento | Descripción |
---|---|
val | El número del que quieres conocer su raiz cuadrada. |
Devuelve: Real
Si multiplicas un número por si mismo, obtienes el cuadrado de ese número, pero a veces quieres hacer la operación inversa y obtener la raíz cuadrada de un número. Así que para saber qué número ha sido multiplicado por si mismo para obtener cualquier número positivo, usamos esta función. Por ejemplo: sqrt(9) devolverá 3 ya que 3*3=9.
num = sqrt(exp);
El código de arriba asignará a la variable "num" la raiz cuadrada del valor contenido en "exp".
log2(n);
Argumento | Descripción |
---|---|
n | El valor de entrada. |
Devuelve: Real
Esta función pregunta "¿Cuántos 2's se necesitan multiplicar para obtener n?". En programación, uno de sus usos más comunes es por ejemplo, calcular el número de bits necesarios para representar un número. Esto se hace calculando log2(x) de ese número, luego redondeandolo hacia abajo y agregándole 1. Por ejemplo log2(100) devuelve 6.643856, que redondeado es 6, al que agregarle uno nos da 7. Por lo tanto, necesitamos siete bits para representar el número 100. También se usa para describir crecimiento o decrecimiento exponencial, y comúnmente se le llama logaritmo binario.
colorbits = floor(log2(color)) - 1;
El código anterior guarda el número de bits necesarios para representar el valor almacenado en la variable "color".
log10(n);
Argumento | Descripción |
---|---|
n | El valor de entrada. |
Devuelve: Real
Esta función es similar a la función log2(n), sólo que log10(n) calcula el número de 10's que se necesitan multiplicar para obtener n. Por lo tanto, tt>log10(100) devuelve 2, ya que multiplicar 10 por si mismo da como resultado 100. log10(1000) devuelve 3, pues 10x10x10=1000 etc... El número de entrada no tiene que ser divisible entre 10, de todas maneras la función devolverá un valor apropiado, por ejemplo, si tenemos log10(101) el resultado es 2.00432137... que es el número de veces que se puede dividir 101 entre 10.
logval = log10(num);
El código anterior obtiene el log10 del valor almacenado en la variable "num".
logn(n, val);
Argumento | Descripción |
---|---|
n | La base del logaritmo. |
val | El valor de entrada. |
Devuelve: Real
Esta función es similar a las funciones log2(n) y log10(n), sólo que ésta permite especificar el valor de la base del logaritmo. Por ejemplo, logn(5,25) devolverá cuántos 5's se necesita multiplicar para obtener 25 (que son 2).
logval = logn(5, num);
Este código obtiene el log5 del valor almacenado en la variable "num".