11. Multiplicación de una matriz por un escalar

Multiplicar una matriz por un escalar consiste en multiplicar todos sus elementos por el mismo número. La operación conserva las dimensiones y permite ampliar, reducir, invertir o anular los valores de la matriz.

11.1 Introducción

Un escalar es un único número. Cuando multiplicamos una matriz por un escalar, aplicamos ese mismo factor a todos los elementos de la matriz.

A diferencia de la suma de matrices, esta operación no necesita otra matriz del mismo orden. Solo requiere un número y una matriz válida.

Si A es de orden m × n y k es un escalar, entonces kA también es de orden m × n.

11.2 Definición

Sea A = [aij] una matriz de orden m × n y sea k un escalar. El producto kA se define mediante:

kA = [kaij]

Cada elemento del resultado cumple:
cij = k · aij

La posición de cada elemento se conserva. Solo cambia su valor.

11.3 Ejemplo con un escalar positivo

A = [ 1   2 ]
    [ 3   4 ]

3A = [ 3·1   3·2 ] = [3    6]
      [ 3·3   3·4 ]   [9   12] 
const A = [[1, 2], [3, 4]];
const k = 3;

const resultado = A.map(fila =>
  fila.map(valor => k * valor)
);

console.log(resultado);

11.4 Escalares negativos y cero

Un escalar negativo cambia el signo de los elementos además de modificar su magnitud. El escalar cero convierte todos los elementos en cero.

Valor de k Efecto sobre A Resultado especial
k > 1 Aumenta las magnitudes Ampliación
0 < k < 1 Reduce las magnitudes Contracción
k = 0 Anula todos los valores Matriz nula
k = -1 Cambia todos los signos Matriz opuesta
k < -1 Invierte signos y aumenta magnitudes Reflexión y ampliación 
const A = [[2, -3], [5, 1]];

const negativa = A.map(fila => fila.map(valor => -2 * valor));
const nula = A.map(fila => fila.map(valor => 0 * valor));

console.log("-2A:", negativa);
console.log("0A:", nula);

11.5 Escalares fraccionarios

Multiplicar por una fracción reduce proporcionalmente los valores. Dividir una matriz por un número distinto de cero equivale a multiplicarla por su recíproco.

A / k = (1/k)A, con k ≠ 0 
const A = [[8, 12], [20, 4]];
const mitad = A.map(fila =>
  fila.map(valor => 0.5 * valor)
);

console.log(mitad);

El resultado es [[4, 6], [10, 2]].

11.6 Función reutilizable en JavaScript

La operación puede implementarse recorriendo cada fila y cada elemento.

function multiplicarPorEscalar(matriz, escalar) {
  return matriz.map(fila =>
    fila.map(valor => escalar * valor)
  );
}

const A = [[1, 2, 3], [4, 5, 6]];

console.log(multiplicarPorEscalar(A, 4));

La función funciona con matrices cuadradas, rectangulares, fila o columna porque no modifica su forma.

11.7 Dimensiones y tipos de matrices

La multiplicación por un escalar conserva la cantidad de filas y columnas. También conserva muchos tipos estructurales.

  • Una matriz diagonal multiplicada por k continúa siendo diagonal.
  • Una matriz triangular continúa siendo triangular.
  • Una matriz simétrica continúa siendo simétrica.
  • Una matriz nula continúa siendo nula.

Existe una excepción de nombre: al multiplicar la identidad por un número distinto de 1 obtenemos una matriz diagonal escalar, pero ya no una matriz identidad.

11.8 Propiedad distributiva respecto de la suma

Multiplicar la suma de dos matrices por un escalar equivale a multiplicar cada matriz y luego sumar los resultados.

k(A + B) = kA + kB 
const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];
const k = 3;

const izquierda = A.map((fila, i) =>
  fila.map((valor, j) => k * (valor + B[i][j]))
);

const derecha = A.map((fila, i) =>
  fila.map((valor, j) => k * valor + k * B[i][j])
);

console.log(izquierda);
console.log(derecha);

11.9 Propiedad distributiva respecto de escalares

La suma de dos escalares multiplicada por una matriz puede distribuirse.

(k + h)A = kA + hA 
const A = [[2, 4], [6, 8]];
const k = 2;
const h = 3;

const izquierda = A.map(fila =>
  fila.map(valor => (k + h) * valor)
);

const derecha = A.map(fila =>
  fila.map(valor => k * valor + h * valor)
);

console.log(izquierda);
console.log(derecha);

11.10 Asociación de escalares

Aplicar un escalar y luego otro equivale a multiplicar ambos escalares primero.

k(hA) = (kh)A 
const A = [[1, -2], [3, 5]];
const k = 4;
const h = -2;

const dosPasos = A.map(fila =>
  fila.map(valor => k * (h * valor))
);

const unPaso = A.map(fila =>
  fila.map(valor => (k * h) * valor)
);

console.log(dosPasos);
console.log(unPaso);

11.11 Escalares especiales

Los escalares 1, 0 y -1 producen resultados fundamentales.

1A = A
0A = O
(-1)A = -A 
const A = [[3, -1], [6, 2]];

const porUno = A.map(fila => fila.map(valor => valor));
const porCero = A.map(fila => fila.map(() => 0));
const opuesta = A.map(fila => fila.map(valor => -valor));

console.log("1A:", porUno);
console.log("0A:", porCero);
console.log("-A:", opuesta);

11.12 Relación con la resta de matrices

La matriz opuesta permite expresar una resta como suma.

A - B = A + (-1)B 
const A = [[8, 6], [5, 9]];
const B = [[3, 1], [2, 4]];

const medianteResta = A.map((fila, i) =>
  fila.map((valor, j) => valor - B[i][j])
);

const medianteOpuesta = A.map((fila, i) =>
  fila.map((valor, j) => valor + (-1) * B[i][j])
);

console.log(medianteResta);
console.log(medianteOpuesta);

11.13 Escalado geométrico

Si una matriz contiene las coordenadas de varios puntos, multiplicarla por k escala todas las coordenadas respecto del origen.

const puntos = [
  [1, 1],
  [4, 1],
  [2, 3]
];
const escala = 2;

const puntosEscalados = puntos.map(punto =>
  punto.map(coordenada => escala * coordenada)
);

console.log(puntosEscalados);

Un factor entre 0 y 1 acerca los puntos al origen. Un factor negativo también los refleja a través del origen.

11.14 Aplicación en imágenes

Una imagen en escala de grises puede representarse mediante una matriz de intensidades. Multiplicar por un factor modifica el brillo relativo.

const imagen = [
  [40, 80, 120],
  [100, 160, 220]
];
const factor = 1.25;

const ajustada = imagen.map(fila =>
  fila.map(pixel => Math.min(255, Math.round(factor * pixel)))
);

console.log(ajustada);

El redondeo y el límite de 255 son reglas del formato de imagen. Por eso el resultado final ya no es exclusivamente la multiplicación matricial pura.

11.15 Combinaciones lineales

Una combinación lineal suma matrices previamente multiplicadas por escalares.

C = kA + hB 
function combinar(A, B, k, h) {
  return A.map((fila, i) =>
    fila.map((valor, j) => k * valor + h * B[i][j])
  );
}

const A = [[1, 2], [3, 4]];
const B = [[4, 3], [2, 1]];

console.log(combinar(A, B, 0.75, 0.25));

Este tipo de mezcla aparece al interpolar datos, combinar imágenes o ponderar resultados.

11.16 Implementación con validación

Una función reutilizable debe verificar la estructura de la matriz y que tanto sus elementos como el escalar sean números finitos.

function escalarMatriz(matriz, escalar) {
  if (!Number.isFinite(escalar)) {
    throw new Error("El escalar debe ser un número finito");
  }
  if (!Array.isArray(matriz) || matriz.length === 0) {
    throw new Error("La matriz no puede estar vacía");
  }

  const columnas = Array.isArray(matriz[0]) ? matriz[0].length : 0;
  const valida = columnas > 0 && matriz.every(fila =>
    Array.isArray(fila) && fila.length === columnas && fila.every(Number.isFinite)
  );

  if (!valida) throw new Error("La matriz debe ser rectangular y numérica");

  return matriz.map(fila =>
    fila.map(valor => escalar * valor)
  );
}

console.log(escalarMatriz([[1, 2, 3], [4, 5, 6]], 2.5));

11.17 Resultado nuevo o modificación en el lugar

Crear una nueva matriz conserva los datos originales. Modificar en el lugar puede reducir memoria, pero cambia la entrada recibida.

const A = [[1, 2], [3, 4]];
const k = 3;

for (let i = 0; i < A.length; i++) {
  for (let j = 0; j < A[i].length; j++) {
    A[i][j] *= k;
  }
}

console.log(A);

Esta versión altera A. Conviene utilizarla solamente cuando el programa no necesita conservar la matriz original.

11.18 Precisión y errores frecuentes

Los productos decimales pueden contener pequeñas aproximaciones de punto flotante.

const A = [[0.1, 0.2], [0.3, 0.4]];
const resultado = A.map(fila =>
  fila.map(valor => 3 * valor)
);

console.log(resultado);

Otros errores frecuentes son:

  • Multiplicar solamente la diagonal o una fila.
  • Modificar las dimensiones durante la operación.
  • Confundir el escalar con otra matriz.
  • Dividir por cero al intentar multiplicar por un recíproco.
  • Aceptar valores NaN o infinitos sin validación.
  • Modificar la matriz original de manera accidental.
  • Aplicar redondeos o límites sin distinguirlos de la operación matemática.

11.19 Qué debes recordar de este tema

  • Multiplicar por un escalar significa multiplicar todos los elementos por el mismo número.
  • El orden de la matriz no cambia.
  • Se cumple k(A + B) = kA + kB.
  • Se cumple (k + h)A = kA + hA.
  • Se cumple k(hA) = (kh)A.
  • Los escalares 1, 0 y -1 producen A, O y -A respectivamente.
  • Dividir por k equivale a multiplicar por 1/k, siempre que k ≠ 0.
  • La operación puede ampliar, contraer, reflejar o anular datos.

11.20 Conclusión

La multiplicación por un escalar transforma uniformemente todos los elementos de una matriz sin cambiar sus dimensiones. Sus propiedades permiten distribuir factores, construir matrices opuestas y expresar combinaciones lineales de forma clara.

En el próximo tema estudiaremos la multiplicación de matrices, una operación diferente en la que las dimensiones internas determinan si el producto puede realizarse.

Volver al índice