A. Tipos enteros

Hay distintos tipos de enteros. La diferencia es cuantos números pueden representar y el número de bytes que utilizan.
Una diferencia con las matemáticas es que son circulares. Si al número más positivo le sumas 1, obtienes el más negativo y si al más negativo le restas 1, obtienes el más positivo.

Tipo	Tamaño (bits)	valor mínimo	Valor máximo
Byte	8	-128	127
Short	16	-32768	32767
Int	32	-2,147,483,648	2,147,483,647
Long	64	-9,223,372,036,854,775,808	9,223,372,036,854,775,807

Números naturales

UByte: Enteros sin signo de 8 bits, de 0 a 255.
UShort: Enteros sin signo de 16 bits, de 0 a 65535.
UInt: Enteros sin signo de 32 bits, de 0 a 2³² - 1.
ULong: Enteros sin signo de 64-bits, de 0 a 2⁶⁴ - 1.

B. Tipos de punto flotante

El tipo Float es más pequeño y el tipo Double es el más grande.

Los números a la izquierda son menores que los de la derecha.

0.0: Es el centro de la recta.
MIN_VALUE: Es el valor positivo más cercano a 0.
-MIN_VALUE: Es el valor negativo más cercano a 0.
MAX_VALUE: Es el valor numérico finito más positivo.
-MAX_VALUE: Es el valor numérico finito más negativo.
POSITIVE_INFINITY: Representa a todos los valores mayores que MAX_VALUE.
NEGATIVE_INFINITY: Representa a todos los valores menores que -MAX_VALUE.

C. Operadores numéricos

fun main() {

// Suma

println(5 + 2); // 7

// Resta

println(5 - 2); // 3

// Multiplicación

println(5 * 2); //10

// División entera

println(5 / 2); // 2

// División entera

println(5 / 2.0); // 2.5

// Módulo o residuo

println(5 % 2); // 1

}

D. Operadores con asignación

Aparte del operador de asignación (=), hay otros operadores que permiten cambiar el valor de una variable.
Al declarar una variable, puedes declarar su tipo.

Ejemplo

fun main() {

var b: Int = 4;

val d = 5;

b = d * 2; // b === 10

println(b);

b += d; // b = b + d; b === 15

println(b);

b -= 2; // b = b - 2; b === 13

println(b);

b *= 3; // b = b * 3; b === 39

println(b);

b /= 3; // b = b / 3; b === 13

println(b);

b %= 5; // b = b % 5; b === 3

println(b);

}

E. Incremento y decremento

También hay operadores de incremento y decremento en 1, pero son algo truculentos; es mejor usarlos solos, sin combinarlos con otros operadores.

Ejemplo

fun main() {

var z = 0;

println(z); // 0

// Incremento. Aumenta z en 1.

z++;

// z === 1

println(z); // 1

// Decremento. Disminuye z en 1.

z--;

// z === 0

println(z); // 0

}

F. Operadores de igualdad

fun main() {

// Igual que (==)

println(3 == 3); //true

println(3 == -3); //false

// Diferente de (!==)

println(3 != 3); // false

println(3 != 8); // true

}

G. Operadores de orden

El operador binario < representa el orden natural de los datos. Si el valor a la izquierda va antes que el de la derecha, el resultado es true; en otro caso es false.
El operador binario > representa el orden invertido de los datos. Si el valor a la izquierda va después que el de la derecha, el resultado es true; en otro caso es false.
En el ejemplo que sigue, el orden natural es:

0 < 3 < 8

fun main() {

// Menor que (<)

println(3 < 0); // false

println(3 < 3); // false

println(3 < 8); // true

// Mayor que (>)

println(3 > 0); // true

println(3 > 3); // false

println(3 > 8); // false

}

H. Operadores combinados de orden e Igualdad

En el ejemplo que sigue, el orden natural es:

0 < 3 < 8

fun main() {

// Menor o igual que (<=)

println(3 <= 0); // false

println(3 <= 3); // true

println(3 <= 8); // true

// Mayor o igual que (>=)

println(3 >= 0); // true

println(3 >= 3); // true

println(3 >= 8); // false

}

I. Precedencia de Operadores

Aquí se muestra el orden en que se ejecutan los operadores de JavaScript cuando se combinan en una expresión. Los que aparecen primero son los que se ejecutan primero. Una tabla similar para Kotlin está en desarrollo.

Orden	Descripción	Asociatividad	Operador	ejempo
1	agrupamiento	n/a	`(…)`	`(2 + 3)`
2	miembro	izquierda a derecha	`….…`	`a.b`
	miembro	izquierda a derecha	`…[…]`	`a[0]`
	new	n/a	`new …(…)`	`new Clase(0)`
	invocación a función	izquierda a derecha	`…(…)`	`fn(x)`
3	incremento sufijo	n/a	`…++`	`a++`
3	decremento sufijo	n/a	`…--`	`a--`
4	incremento prefijo	n/a	`++…`	`++a`
	decremento prefijo	n/a	`--…`	`--a`
	not lógico	derecha a izquierda	`!…`	`!a`
	not a nivel de bits	derecha a izquierda	`~…`	`~a`
	+ unario	derecha a izquierda	`+…`	`+a`
	negación unaria	derecha a izquierda	`-…`	`-a`
	typeof	derecha a izquierda	`typeof …`	`typeof a`
	void	derecha a izquierda	`void …`	`void a`
	delete	derecha a izquierda	`delete …`	`delete a.nombre`
5	exponenciación	n/a	`… ** …`	`a ** b`
6	multiplicación	izquierda a derecha	`… * …`	`a * b`
	división	izquierda a derecha	`… / …`	`a / b`
	residuo	izquierda a derecha	`… % …`	`a % b`
7	suma	izquierda a derecha	`… + …`	`a + b`
7	resta	izquierda a derecha	`… - …`	`a - b`
8	corrimiento de bits	izquierda a derecha	`… << …`	`a << b`
			`… >> …`	`a >> b`
			`… >>> …`	`a >>> b`
9	relacional	izquierda a derecha	`… < …`	`a < b`
			`… <= …`	`a <= b`
			`… > …`	`a > b`
			`… >= …`	`a >= b`
	in	izquierda a derecha	`… in …`	`"nombre" in a`
	instanceof	izquierda a derecha	`… instanceof …`	`a instanceof Array`
10	igualdad	izquierda a derecha	`… == …`	`a == b`
			`… != …`	`a != b`
			`… === …`	`a === b`
			`… !== …`	`a !== b`
11	and de bits	izquierda a derecha	`… & …`	`a & b`
12	xor de bits	izquierda a derecha	`… ^ …`	`a ^ b`
13	or de bits	izquierda a derecha	`… \| …`	`a \| b`
14	and lógico	izquierda a derecha	`… && …`	`a && b`
15	or lógico	izquierda a derecha	`… \|\| …`	`a \|\| b`
16	condicional	derecha a izquierda	`… ? … : …`	`a ? b : c`
17	asignación	derecha a izquierda	`… = …`	`a = b`
			`… += …`	`a += b`
			`… -= …`	`a -= b`
			`… *= …`	`a *= b`
			`… /= …`	`a /= b`
			`… %= …`	`a %= b`
			`… <<= …`	`a <<= b`
			`… >>= …`	`a >>= b`
			`… >>>= …`	`a >>>= b`
			`… &= …`	`a &= b`
			`… ^= …`	`a ^= b`
			`… \|= …`	`a \|= b`
18	yield	derecha a izquierda	`yield …`	`yield a`
19	coma	izquierda a derecha	`… , …`	`a , b`

Fuentes:

J. Expresiones

Hay que aprender a estructurar las expresiones matemáticas en el lenguaje de programación.

Ejemplos de expresiones aritméticas expresadas en Kotlin

: x = (-b + Math.sqrt(b**2 - 4*a*c)) / (2*a)
: y = ((y2 - y1) / (x2 - x1)) * (x - x1) + y1

Temas por Investigar

La clase Math.

15. Números

A. Tipos enteros

Números naturales

B. Tipos de punto flotante

C. Operadores numéricos

D. Operadores con asignación

Ejemplo

E. Incremento y decremento

Ejemplo

F. Operadores de igualdad

G. Operadores de orden

H. Operadores combinados de orden e Igualdad

I. Precedencia de Operadores

J. Expresiones

Ejemplos de expresiones aritméticas expresadas en Kotlin

Temas por Investigar