Una tabla de valores organiza todos los pares de una función en filas y columnas. Es la forma más directa de visualizar, compartir y verificar el comportamiento completo de una función discreta.
Cuando el dominio de una función es finito, es posible listar explícitamente todos los pares (a, f(a)). Organizar esos pares en una tabla hace que la función sea fácil de leer, comparar y verificar.
La representación tabular es especialmente útil en informática: las tablas de verdad de las funciones booleanas, los diccionarios, las tablas de base de datos y los arrays asociativos son todos ejemplos de funciones en formato tabular.
Una tabla de valores tiene dos columnas: la columna del dominio y la columna de la imagen. Cada fila corresponde a un elemento del dominio y su valor bajo la función.
Cada fila tiene exactamente un valor en la columna de imagen: la condición de función se verifica visualmente.
Con un dominio y una función definida por fórmula, podemos generar la tabla completa automáticamente.
const dominio = [1, 2, 3, 4, 5];
function f(n) {
return n * n - n;
}
// Construir la tabla como array de objetos
const tabla = dominio.map(n => ({ entrada: n, salida: f(n) }));
// Mostrar la tabla fila por fila
tabla.forEach(fila => console.log(fila));
// {"entrada":1,"salida":0}
// {"entrada":2,"salida":2}
// {"entrada":3,"salida":6}
// {"entrada":4,"salida":12}
// {"entrada":5,"salida":20}Una vez construida la tabla, podemos extraer información relevante de la función directamente.
const dominio = [1, 2, 3, 4, 5];
function f(n) { return n * n - n; }
const tabla = dominio.map(n => [n, f(n)]);
// Imagen de la función
const imagen = [...new Set(tabla.map(([, b]) => b))];
console.log('Imagen:', imagen); // [0, 2, 6, 12, 20]
// Valor máximo alcanzado
const max = Math.max(...imagen);
console.log('Máximo:', max); // 20
// Valor mínimo alcanzado
const min = Math.min(...imagen);
console.log('Mínimo:', min); // 0
// Elemento con mayor imagen
const argmax = tabla.reduce((acc, cur) => cur[1] > acc[1] ? cur : acc);
console.log('Argmax:', argmax); // [5, 20]El dominio puede ser cualquier conjunto finito. La tabla funciona igual: una columna de entradas y una columna de salidas.
const g = new Map([
['norte', 0],
['este', 90],
['sur', 180],
['oeste', 270]
]);
// Mostrar la tabla completa
for (const [dir, ang] of g) {
console.log(`${dir.padEnd(8)} → ${ang}°`);
}
// Evaluar un punto
console.log(g.get('sur')); // 180Una función de dos variables f : A × B → C puede representarse como una tabla bidimensional: las filas corresponden a los valores de A y las columnas a los de B.
const A = [0, 1, 2];
const B = [0, 1, 2];
function f(a, b) { return a + b; }
// Construir la tabla bidimensional
const tablaBi = A.map(a =>
Object.fromEntries([['a\\b', a], ...B.map(b => [b, f(a, b)])])
);
// Mostrar la tabla bidimensional fila por fila
tablaBi.forEach(fila => console.log(fila));
// {"a\\b":0,"0":0,"1":1,"2":2}
// {"a\\b":1,"0":1,"1":2,"2":3}
// {"a\\b":2,"0":2,"1":3,"2":4}La tabla de verdad es una tabla de valores donde el dominio es un conjunto de combinaciones de valores booleanos y la imagen es un valor booleano. Es uno de los usos más frecuentes de la representación tabular en informática.
const valores = [false, true];
function and(p, q) { return p && q; }
// Generar tabla de verdad automáticamente
for (const p of valores) {
for (const q of valores) {
const resultado = and(p, q);
console.log(`${String(p).padEnd(5)} AND ${String(q).padEnd(5)} = ${resultado}`);
}
}
// false AND false = false
// false AND true = false
// true AND false = false
// true AND true = trueLa tabla permite verificar propiedades de la función con inspección directa.
| Propiedad | Qué buscar en la tabla |
|---|---|
| Es función | Cada entrada aparece exactamente una vez en la columna de entradas |
| Es inyectiva | Ningún valor aparece dos veces en la columna de salidas |
| Es sobreyectiva | Todo elemento del codominio aparece al menos una vez en la columna de salidas |
| Es biyectiva | Cada valor del codominio aparece exactamente una vez en la columna de salidas |
| Es constante | Todos los valores de la columna de salidas son iguales |
| Es identidad | Cada entrada coincide con su salida |
const dominio = [1, 2, 3, 4];
const codominio = [1, 2, 3, 4];
function f(n) { return 5 - n; } // f(1)=4, f(2)=3, f(3)=2, f(4)=1
const tabla = dominio.map(a => [a, f(a)]);
const salidas = tabla.map(([, b]) => b);
// ¿Es inyectiva? (no hay salidas repetidas)
const esInyectiva = new Set(salidas).size === salidas.length;
console.log('Inyectiva:', esInyectiva); // true
// ¿Es sobreyectiva? (todo el codominio aparece)
const esSobreyectiva = codominio.every(b => salidas.includes(b));
console.log('Sobreyectiva:', esSobreyectiva); // true
// ¿Es biyectiva?
console.log('Biyectiva:', esInyectiva && esSobreyectiva); // true
// ¿Es la identidad?
const esIdentidad = tabla.every(([a, b]) => a === b);
console.log('Identidad:', esIdentidad); // falseEn programación, las tablas de funciones se implementan de distintas formas según la necesidad:
| Estructura | Lenguaje | Cuándo usarla |
|---|---|---|
| Array de pares | JavaScript, Python | Dominio pequeño, orden importa |
| Map / Diccionario | JavaScript, Python, Java | Dominio arbitrario, búsqueda eficiente O(1) |
| Array indexado | C, JavaScript | Dominio = enteros consecutivos |
| Tabla de base de datos | SQL | Gran volumen, consultas complejas |
| Enum / switch | Java, C, TypeScript | Dominio fijo y conocido en tiempo de compilación |
Si tenemos una tabla de valores, podemos reconstruir la función como lista de pares o como objeto de búsqueda eficiente.
// Tabla dada como array de objetos
const tablaOriginal = [
{ entrada: 'a', salida: 10 },
{ entrada: 'b', salida: 30 },
{ entrada: 'c', salida: 20 },
{ entrada: 'd', salida: 10 }
];
// Convertir a Map para evaluación eficiente
const funcion = new Map(tablaOriginal.map(({ entrada, salida }) => [entrada, salida]));
// Evaluar
console.log(funcion.get('b')); // 30
console.log(funcion.get('d')); // 10
// Convertir a lista de pares
const pares = [...funcion.entries()];
console.log(pares);
// [['a',10],['b',30],['c',20],['d',10]]La representación tabular convierte una función abstracta en un objeto concreto y manejable. Facilita la verificación de propiedades, la comparación entre funciones y la comunicación de resultados. En programación, las tablas son la base de estructuras como los diccionarios, las tablas de bases de datos y las tablas de verdad.
En el próximo tema estudiaremos la representación gráfica de funciones discretas: cómo visualizar los pares de una función mediante puntos en un plano o mediante diagramas de flechas.