# Matemáticas

> Aritmética, funciones de un valor (sin, fract, abs...), mix, clamp, smoothstep y remap: el pegamento de todo grafo.

Source: https://albakore.github.io/pyzed/es/shading/nodes/math/

Cada ejemplo de esta página se ejecuta después de estas dos líneas y termina enviando un color al nodo Salida:

```python
from pyzed import shading

g = shading.Graph("demo")
```

## Matemáticas

Todos los nodos de matemáticas funcionan con números **y** con vectores: con un `vec3` trabajan en cada componente (rojo, verde y azul a la vez). Sus entradas y salidas tienen el tipo genérico `T`.

### Matemáticas

*Math* · `math` · Matemáticas · `g.math(...)`

Una operación aritmética entre dos valores (de cualquier tipo: los vectores se procesan por componente).

Dos valores entran, uno sale. En Python casi nunca lo añades a mano: `a + b`, `a * 2` o `a ** 2` sobre puertos añaden nodos Matemáticas por ti. Cada operación es su propia entrada en la barra lateral (Sumar, Multiplicar, Escalón...).

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `a` | `T` | `0` |
| `b` | `T` | `1` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `T` |

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `op` | `add`, `subtract`, `multiply`, `divide`, `modulo`, `power`, `min`, `max`, `step`, `atan2`, `snap` | `add` |

**Entradas de la barra lateral**

| Entrada | Qué hace | En Python |
| --- | --- | --- |
| Sumar | a + b | `g.add(...)` |
| Restar | a − b | `g.subtract(...)` |
| Multiplicar | a × b | `g.multiply(...)` |
| Dividir | a ÷ b | `g.divide(...)` |
| Módulo | El resto de a ÷ b (siempre con el signo de b). | `g.modulo(...)` |
| Potencia | a elevado a b. | `g.power(...)` |
| Mínimo | El menor de a y b. | `g.min(...)` |
| Máximo | El mayor de a y b. | `g.max(...)` |
| Escalón | 0 donde b está por debajo del borde a, 1 a partir de ahí. | `g.step(...)` |
| Atan2 | El ángulo del punto (b, a) en radianes: a es y, b es x. | `g.atan2(...)` |
| Ajustar | a redondeado al múltiplo de b más cercano. | `g.snap(...)` |

```python title="Ejemplo"
uv = g.uv()
stripes = g.step(0.5, g.fract(uv["x"] * 8.0))
g.output(g.rgba(stripes * 0.8 + 0.1, 1.0))
```

### Función

*Function* · `func` · Matemáticas · `g.func(...)`

Una función de un valor (los vectores se procesan por componente).

Un valor entra, uno sale: redondeos, raíces, potencias, trigonometría y más. Cada función es su propia entrada en la barra lateral (Sin, Fract, Abs...) y un método en Python (`g.sin(x)`, `g.fract(x)`).

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `x` | `T` | `0` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `T` |

| Ajuste | Valores | Por defecto |
| --- | --- | --- |
| `op` | `abs`, `negate`, `sign`, `floor`, `ceil`, `round`, `fract`, `trunc`, `sqrt`, `inverse_sqrt`, `square`, `exp`, `exp2`, `log`, `log2`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `one_minus`, `reciprocal`, `saturate`, `degrees`, `radians` | `sin` |

**Entradas de la barra lateral**

| Entrada | Qué hace | En Python |
| --- | --- | --- |
| Abs | x sin signo. | `g.abs(...)` |
| Negar | −x | `g.negate(...)` |
| Signo | −1, 0 o 1: el signo de x. | `g.sign(...)` |
| Floor | x redondeado hacia abajo. | `g.floor(...)` |
| Ceil | x redondeado hacia arriba. | `g.ceil(...)` |
| Redondear | x redondeado al entero más cercano. | `g.round(...)` |
| Fract | La parte decimal: x − floor(x). Se repite cada 1. | `g.fract(...)` |
| Truncar | x sin su parte decimal. | `g.trunc(...)` |
| Raíz | La raíz cuadrada de x. | `g.sqrt(...)` |
| Raíz inversa | 1 / √x | `g.inverse_sqrt(...)` |
| Cuadrado | x × x | `g.square(...)` |
| Exp | e elevado a x. | `g.exp(...)` |
| Exp2 | 2 elevado a x. | `g.exp2(...)` |
| Log | El logaritmo natural de x. | `g.log(...)` |
| Log2 | El logaritmo en base 2 de x. | `g.log2(...)` |
| Sin | El seno de x (radianes). | `g.sin(...)` |
| Cos | El coseno de x (radianes). | `g.cos(...)` |
| Tan | La tangente de x (radianes). | `g.tan(...)` |
| Asin | El arcoseno de x, en radianes. | `g.asin(...)` |
| Acos | El arcocoseno de x, en radianes. | `g.acos(...)` |
| Atan | La arcotangente de x, en radianes. | `g.atan(...)` |
| Sinh | El seno hiperbólico de x. | `g.sinh(...)` |
| Cosh | El coseno hiperbólico de x. | `g.cosh(...)` |
| Tanh | La tangente hiperbólica de x: una curva en S de −1 a 1. | `g.tanh(...)` |
| Uno menos | 1 − x: invierte 0..1. | `g.one_minus(...)` |
| Recíproco | 1 / x | `g.reciprocal(...)` |
| Saturar | x limitado entre 0 y 1. | `g.saturate(...)` |
| Grados | Radianes a grados. | `g.degrees(...)` |
| Radianes | Grados a radianes. | `g.radians(...)` |

```python title="Ejemplo"
t = g.time()["time"]
wave = g.abs(g.sin(g.uv()["x"] * 10.0 + t))
g.output(g.rgba(wave, 1.0))
```

### Mezclar

*Mix* · `mix` · Matemáticas · `g.mix(...)`

Mezcla de a (t = 0) a b (t = 1): una interpolación lineal.

Mezcla dos valores: `t` = 0 da `a`, 1 da `b`, 0.5 mitad de cada uno. El nodo que más usarás para combinar colores.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `a` | `T` | `0` |
| `b` | `T` | `1` |
| `t` | `T` | `0.5` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `T` |

```python title="Ejemplo"
uv = g.uv()
sky = g.mix([0.1, 0.2, 0.5], [0.9, 0.6, 0.3], uv["y"])
g.output(g.rgba(sky, 1.0))
```

### Limitar

*Clamp* · `clamp` · Matemáticas · `g.clamp(...)`

x limitado entre min y max.

Mantiene un valor dentro de un rango, para que un punto brillante nunca pase de 1 ni uno oscuro baje de 0.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `x` | `T` | `0` |
| `min` | `T` | `0` |
| `max` | `T` | `1` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `T` |

```python title="Ejemplo"
v = g.uv()["x"] * 2.0 - 0.5
g.output(g.rgba(g.clamp(v, 0.0, 1.0), 1.0))
```

### Paso suave

*Smoothstep* · `smoothstep` · Matemáticas · `g.smoothstep(...)`

0 por debajo de edge0, 1 por encima de edge1 y una curva suave entre ambos.

Un umbral suave: 0 por debajo de `edge0`, 1 por encima de `edge1` y una curva suave entre ambos. Úsalo para convertir una distancia o un ruido en una máscara de borde suave.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `edge0` | `T` | `0` |
| `edge1` | `T` | `1` |
| `x` | `T` | `0.5` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `T` |

```python title="Ejemplo"
n = g.noise(scale=6.0)
mask = g.smoothstep(0.45, 0.55, n)
g.output(g.rgba(mask, 1.0))
```

### Reasignar rango

*Remap* · `remap` · Matemáticas · `g.remap(...)`

x llevado del rango in_min..in_max a out_min..out_max.

Pasa un valor de un rango a otro: de −1..1 (un seno) a 0..1 (un color), o de 0..1 a 0.2..0.8.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `x` | `T` | `0.5` |
| `in_min` · entrada mín. | `T` | `0` |
| `in_max` · entrada máx. | `T` | `1` |
| `out_min` · salida mín. | `T` | `-1` |
| `out_max` · salida máx. | `T` | `1` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `T` |

```python title="Ejemplo"
s = g.time()["sin"]
v = g.remap(s, -1.0, 1.0, 0.2, 0.8)
g.output(g.rgba(v, 1.0))
```

### Multiplicar y sumar

*Multiply add* · `multiply_add` · Matemáticas · `g.multiply_add(...)`

a × b + c

`a × b + c` en un solo nodo: escala y desplaza un valor, como `sin × 0.5 + 0.5` para llevar −1..1 a 0..1.

| Entrada | Tipo | Por defecto |
| --- | --- | --- |
| `a` | `T` | `1` |
| `b` | `T` | `1` |
| `c` | `T` | `0` |

| Salida | Tipo |
| --- | --- |
| `result` · resultado | `T` |

```python title="Ejemplo"
s = g.time()["sin"]
g.output(g.rgba(g.multiply_add(s, 0.5, 0.5), 1.0))
```

**Siempre al día:**

Esta página se genera a partir del catálogo de nodos de `pyzed.shading`, así que los puertos, tipos y valores por defecto son siempre los de esta versión. Cada ejemplo se compila al construir la documentación.

**Ver también:** [Primeros pasos](https://albakore.github.io/pyzed/es/shading/getting-started/) · [La vista Shader](https://albakore.github.io/pyzed/es/shading/shader-designer/) · [Recetas](https://albakore.github.io/pyzed/es/shading/recipes/) · [Grafos de shader en Python](https://albakore.github.io/pyzed/es/shading/shader-graphs/)