28. Dominio, imagen y evaluación de funciones

28.1 Introducción

En el tema anterior vimos que una función relaciona entradas con salidas. Ahora agregaremos dos ideas importantes: qué entradas son válidas y qué salidas puede generar.

El dominio ayuda a evitar valores inválidos. La imagen ayuda a comprender el rango de resultados posibles. En programación, estas ideas se traducen en validación de argumentos, restricciones y manejo de errores.

Evaluar funciones con cuidado es esencial para construir programas confiables.

28.2 Qué es el dominio

El dominio de una función es el conjunto de valores de entrada para los cuales la función está definida.

function inversa(x) {
  if (x === 0) {
    return "x no puede ser cero";
  }

  return 1 / x;
}

console.log(inversa(2));
console.log(inversa(0));

28.3 Qué es la imagen

La imagen de una función es el conjunto de valores de salida que la función puede producir.

function cuadrado(x) {
  return x ** 2;
}

console.log(cuadrado(-3));
console.log(cuadrado(0));
console.log(cuadrado(3));

Aunque la entrada sea negativa, la salida de x² es siempre cero o positiva.

28.4 Evaluar una función

Evaluar una función significa reemplazar la entrada por un valor y calcular la salida.

function f(x) {
  return 2 * x + 3;
}

console.log(f(5));
console.log(f(10));

28.5 Dominio restringido por división

Si una función tiene una división, el denominador no puede ser cero. Esa restricción forma parte del dominio.

function f(x) {
  if (x === 2) {
    return "Entrada fuera del dominio";
  }

  return 10 / (x - 2);
}

console.log(f(4));
console.log(f(2));

28.6 Dominio restringido por raíz cuadrada

Si trabajamos con números reales, la raíz cuadrada solo acepta valores mayores o iguales que cero.

function raiz(x) {
  if (x < 0) {
    return "Entrada fuera del dominio real";
  }

  return Math.sqrt(x);
}

console.log(raiz(25));
console.log(raiz(-9));

28.7 Dominio en una aplicación

En programación, el dominio no siempre viene de una fórmula matemática. También puede venir de reglas del problema.

function esPorcentajeValido(valor) {
  return valor >= 0 && valor <= 100;
}

console.log(esPorcentajeValido(75));
console.log(esPorcentajeValido(130));

28.8 Imagen en funciones lineales simples

Una función lineal como f(x) = 2x + 1, si acepta todos los números reales, puede producir cualquier número real como salida.

function f(x) {
  return 2 * x + 1;
}

console.log(f(-10));
console.log(f(0));
console.log(f(10));

Al cambiar la entrada, la salida puede crecer o disminuir sin límite.

28.9 Imagen en funciones acotadas por reglas

Algunas funciones de programa limitan la salida. Por ejemplo, una función que restringe un valor entre un mínimo y un máximo.

function limitar(valor, minimo, maximo) {
  if (valor < minimo) return minimo;
  if (valor > maximo) return maximo;
  return valor;
}

console.log(limitar(-10, 0, 100));
console.log(limitar(50, 0, 100));
console.log(limitar(150, 0, 100));

La imagen de esta función queda limitada al intervalo entre mínimo y máximo.

28.10 Tabla de valores

Una tabla de valores ayuda a observar entradas y salidas. Es una forma práctica de explorar el comportamiento de una función.

function f(x) {
  return x ** 2;
}

for (let x = -3; x <= 3; x++) {
  console.log({ entrada: x, salida: f(x) });
}

Al ver la tabla, notamos que las salidas no son negativas.

28.11 Evaluar funciones con listas

En programación es común evaluar una función para muchos valores de entrada usando arreglos.

function convertirCelsiusAFahrenheit(celsius) {
  return celsius * 9 / 5 + 32;
}

const entradas = [0, 10, 20, 30];
const salidas = entradas.map(convertirCelsiusAFahrenheit);

console.log(salidas);

El método map() aplica la función a cada elemento.

28.12 Validar antes de evaluar

Una función robusta verifica que la entrada pertenezca al dominio antes de calcular.

function calcularPromedio(suma, cantidad) {
  if (cantidad <= 0) {
    return "La cantidad debe ser mayor que cero";
  }

  return suma / cantidad;
}

console.log(calcularPromedio(80, 10));
console.log(calcularPromedio(80, 0));

28.13 Dominio discreto

A veces el dominio no es continuo, sino un conjunto de opciones permitidas. Por ejemplo, un sistema puede aceptar solo ciertos niveles.

function costoPorNivel(nivel) {
  const costos = {
    basico: 1000,
    intermedio: 1800,
    avanzado: 2500
  };

  if (!(nivel in costos)) {
    return "Nivel inválido";
  }

  return costos[nivel];
}

console.log(costoPorNivel("basico"));
console.log(costoPorNivel("experto"));

El dominio está formado por las claves permitidas: básico, intermedio y avanzado.

28.14 Errores comunes

• Evaluar una función con valores fuera de su dominio.
• Olvidar que una división no admite denominador cero.
• Calcular raíces reales de números negativos sin validar.
• Confundir dominio con imagen: dominio son entradas, imagen son salidas.
• No documentar restricciones de entrada en funciones de programa.
• Asumir que toda función acepta cualquier número.

function segura(x) {
  if (x <= 0) {
    return "x debe ser positivo";
  }

  return Math.sqrt(x) + 1 / x;
}

console.log(segura(4));
console.log(segura(0));

28.15 Qué debes recordar de este tema

• El dominio es el conjunto de entradas válidas de una función.
• La imagen es el conjunto de salidas que una función puede producir.
• Evaluar una función significa calcular la salida para una entrada concreta.
• Las divisiones restringen el dominio cuando el denominador puede ser cero.
• Las raíces cuadradas reales requieren valores mayores o iguales que cero.
• En programación, las reglas del negocio también definen dominios válidos.
• Validar entradas antes de evaluar evita errores y resultados inválidos.

28.16 Conclusión

Dominio, imagen y evaluación permiten comprender mejor cómo se comporta una función. Estas ideas ayudan a validar datos, evitar errores y razonar sobre las salidas posibles de un programa.

En el próximo tema estudiaremos funciones lineales, una de las familias de funciones más importantes y frecuentes en programación.