Calculadora de Matrices

Categoría: Álgebra y General

Entrada de Matriz A

Entrada de Matriz B

Resultados

// Initialize on load document.addEventListener("DOMContentLoaded", () => { initializeMatrices(); }); function initializeMatrices() { createMatrix('A'); createMatrix('B'); } function createMatrix(matrix) { const rows = parseInt(document.getElementById(`rows${matrix}`).value); const columns = parseInt(document.getElementById(`columns${matrix}`).value); const grid = document.getElementById(`matrix${matrix}-grid`); grid.style.gridTemplateColumns = `repeat(${columns}, 1fr)`; grid.style.gridTemplateRows = `repeat(${rows}, 1fr)`; grid.innerHTML = ''; for (let i = 0; i < rows * columns; i++) { const input = document.createElement('input'); input.type = 'number'; input.value = '0'; input.step = 'any'; grid.appendChild(input); } } function getMatrixValues(matrix) { return Array.from(document.querySelectorAll(`#matrix${matrix}-grid input`)) .map(input => parseFloat(input.value) || 0); } function displayMatrixValues(values, rows, cols, operation = '', sourceMatrix = '') { const resultDiv = document.getElementById('results'); resultDiv.innerHTML = '

Resultado

'; let matrixSymbol = ''; switch(operation) { case 'transpose': matrixSymbol = `${sourceMatrix}\u1D40 = `; break; case 'power': const power = document.getElementById(`power${sourceMatrix}`).value; matrixSymbol = `${sourceMatrix}^${power} = `; break; case 'scalar': const scalar = document.getElementById(`scalar${sourceMatrix}`).value; matrixSymbol = `${scalar}${sourceMatrix} = `; break; case 'add': matrixSymbol = 'A + B = '; break; case 'subtract': matrixSymbol = 'A - B = '; break; case 'multiply': matrixSymbol = 'AB = '; break; } const matrixString = matrixSymbol + '[\n' + Array(rows).fill().map((_, i) => values.slice(i * cols, (i + 1) * cols).map(v => Number.isInteger(v) ? v.toString() : v.toFixed(2) ).join(' ') ).join('\n') + '\n]'; const pre = document.createElement('pre'); pre.textContent = matrixString; resultDiv.appendChild(pre); const copyDiv = document.createElement('div'); copyDiv.className = 'copy-buttons'; const copyToABtn = document.createElement('button'); copyToABtn.textContent = 'Copiar a A'; copyToABtn.onclick = () => copyToMatrix('A', values, rows, cols); const copyToBBtn = document.createElement('button'); copyToBBtn.textContent = 'Copiar a B'; copyToBBtn.onclick = () => copyToMatrix('B', values, rows, cols); copyDiv.appendChild(copyToABtn); copyDiv.appendChild(copyToBBtn); resultDiv.appendChild(copyDiv); } function clearMatrix(matrix) { document.querySelectorAll(`#matrix${matrix}-grid input`) .forEach(input => input.value = '0'); } function fillMatrix(matrix, value) { document.querySelectorAll(`#matrix${matrix}-grid input`) .forEach(input => input.value = value.toString()); } function fillRandom(matrix) { document.querySelectorAll(`#matrix${matrix}-grid input`) .forEach(input => input.value = Math.floor(Math.random() * 10)); } function transpose(matrix) { const rows = parseInt(document.getElementById(`rows${matrix}`).value); const cols = parseInt(document.getElementById(`columns${matrix}`).value); const values = getMatrixValues(matrix); const result = Array(rows * cols).fill(0); for (let i = 0; i < rows; i++) { for (let j = 0; j < cols; j++) { result[j * rows + i] = values[i * cols + j]; } } displayMatrixValues(result, cols, rows, 'transpose', matrix); } function powerMatrix(matrix) { const power = parseInt(document.getElementById(`power${matrix}`).value); if (power < 1) return; const rows = parseInt(document.getElementById(`rows${matrix}`).value); const cols = parseInt(document.getElementById(`columns${matrix}`).value); if (rows !== cols) { alert("La matriz debe ser cuadrada para la operación de potencia"); return; } let result = getMatrixValues(matrix); const original = [...result]; for (let p = 1; p < power; p++) { result = multiplyArrays(result, original, rows, cols, cols); } displayMatrixValues(result, rows, cols, 'power', matrix); } function determinant(matrix) { const rows = parseInt(document.getElementById(`rows${matrix}`).value); const cols = parseInt(document.getElementById(`columns${matrix}`).value); if (rows !== cols) { alert("La matriz debe ser cuadrada para calcular el determinante"); return; } const values = getMatrixValues(matrix); const det = calculateDeterminant(values, rows); alert(`Determinante de la Matriz ${matrix}: ${det.toFixed(2)}`); } function calculateDeterminant(matrix, n) { if (n === 1) return matrix[0]; if (n === 2) return matrix[0] * matrix[3] - matrix[1] * matrix[2]; let det = 0; for (let i = 0; i < n; i++) { det += Math.pow(-1, i) * matrix[i] * calculateDeterminant( getMinor(matrix, 0, i, n), n - 1 ); } return det; } function getMinor(matrix, row, col, n) { const minor = []; for (let i = 0; i < n; i++) { if (i === row) continue; for (let j = 0; j < n; j++) { if (j === col) continue; minor.push(matrix[i * n + j]); } } return minor; } function inverseMatrix(matrix) { const rows = parseInt(document.getElementById(`rows${matrix}`).value); const cols = parseInt(document.getElementById(`columns${matrix}`).value); if (rows !== cols) { alert("La matriz debe ser cuadrada para calcular la inversa"); return; } const values = getMatrixValues(matrix); const det = calculateDeterminant(values, rows); if (Math.abs(det) < 1e-10) { alert("La matriz no es invertible (el determinante es cero)"); return; } const adjugate = calculateAdjugate(values, rows); const inverse = adjugate.map(value => value / det); displayMatrixValues(inverse, rows, cols); } function calculateAdjugate(matrix, n) { const adj = Array(n * n).fill(0); for (let i = 0; i < n; i++) { for (let j = 0; j < n; j++) { const cofactor = Math.pow(-1, i + j) * calculateDeterminant( getMinor(matrix, i, j, n), n - 1 ); adj[j * n + i] = cofactor; } } return adj; } function scalarMultiply(matrix) { const scalar = parseFloat(document.getElementById(`scalar${matrix}`).value); const values = getMatrixValues(matrix); const result = values.map(val => val * scalar); const rows = parseInt(document.getElementById(`rows${matrix}`).value); const cols = parseInt(document.getElementById(`columns${matrix}`).value); displayMatrixValues(result, rows, cols, 'scalar', matrix); } function addMatrices() { const rowsA = parseInt(document.getElementById('rowsA').value); const colsA = parseInt(document.getElementById('columnsA').value); const rowsB = parseInt(document.getElementById('rowsB').value); const colsB = parseInt(document.getElementById('columnsB').value); if (rowsA !== rowsB || colsA !== colsB) { alert("Las matrices deben tener las mismas dimensiones para la suma"); return; } const valuesA = getMatrixValues('A'); const valuesB = getMatrixValues('B'); const result = valuesA.map((val, index) => val + valuesB[index]); displayMatrixValues(result, rowsA, colsA, 'add'); } function subtractMatrices() { const rowsA = parseInt(document.getElementById('rowsA').value); const colsA = parseInt(document.getElementById('columnsA').value); const rowsB = parseInt(document.getElementById('rowsB').value); const colsB = parseInt(document.getElementById('columnsB').value); if (rowsA !== rowsB || colsA !== colsB) { alert("Las matrices deben tener las mismas dimensiones para la resta"); return; } const valuesA = getMatrixValues('A'); const valuesB = getMatrixValues('B'); const result = valuesA.map((val, index) => val - valuesB[index]); displayMatrixValues(result, rowsA, colsA, 'subtract'); } function multiplyMatrices() { const rowsA = parseInt(document.getElementById('rowsA').value); const colsA = parseInt(document.getElementById('columnsA').value); const rowsB = parseInt(document.getElementById('rowsB').value); const colsB = parseInt(document.getElementById('columnsB').value); if (colsA !== rowsB) { alert("El número de columnas de la Matriz A debe ser igual al número de filas de la Matriz B"); return; } const valuesA = getMatrixValues('A'); const valuesB = getMatrixValues('B'); const result = multiplyArrays(valuesA, valuesB, rowsA, colsA, colsB); displayMatrixValues(result, rowsA, colsB, 'multiply'); } function multiplyArrays(matrixA, matrixB, rowsA, colsA, colsB) { const result = Array(rowsA * colsB).fill(0); for (let i = 0; i < rowsA; i++) { for (let j = 0; j < colsB; j++) { for (let k = 0; k < colsA; k++) { result[i * colsB + j] += matrixA[i * colsA + k] * matrixB[k * colsB + j]; } } } return result; } function swapMatrices() { const valuesA = getMatrixValues('A'); const valuesB = getMatrixValues('B'); const rowsA = document.getElementById('rowsA').value; const colsA = document.getElementById('columnsA').value; const rowsB = document.getElementById('rowsB').value; const colsB = document.getElementById('columnsB').value; document.getElementById('rowsA').value = rowsB; document.getElementById('columnsA').value = colsB; document.getElementById('rowsB').value = rowsA; document.getElementById('columnsB').value = colsA; createMatrix('A'); createMatrix('B'); const inputsA = document.querySelectorAll('#matrixA-grid input'); const inputsB = document.querySelectorAll('#matrixB-grid input'); inputsA.forEach((input, index) => input.value = valuesB[index] || 0); inputsB.forEach((input, index) => input.value = valuesA[index] || 0); } function copyToMatrix(matrix, values, rows, cols) { document.getElementById(`rows${matrix}`).value = rows; document.getElementById(`columns${matrix}`).value = cols; createMatrix(matrix); const inputs = document.querySelectorAll(`#matrix${matrix}-grid input`); inputs.forEach((input, index) => { if (index < values.length) { input.value = values[index]; } }); }

Guía de la Herramienta Calculadora de Matrices

La Calculadora de Matrices es una herramienta fácil de usar que te permite realizar una amplia gama de operaciones con matrices con solo unos pocos clics. Esta guía explicará el propósito y las características de la calculadora, cómo usarla y los tipos de cálculos que admite.

Propósito de la Calculadora de Matrices

La Calculadora de Matrices está diseñada para cualquier persona que necesite manejar operaciones con matrices de manera rápida y eficiente. Ya seas un estudiante, un profesor o un profesional que trabaja con datos, esta calculadora puede ayudarte a:

  • Optimizar Cálculos Complejos: Realiza operaciones matemáticas en matrices sin cálculos manuales.
  • Explorar Conceptos de Matrices: Experimenta con propiedades de matrices como determinantes, inversas y transposiciones.
  • Ahorrar Tiempo: Genera rápidamente resultados para operaciones comúnmente utilizadas, como la suma de matrices, multiplicación y transformaciones escalares.

Características Clave de la Calculadora

La calculadora proporciona dos entradas de matriz, Matriz A y Matriz B, donde los usuarios pueden ingresar valores y establecer dimensiones (filas y columnas). Aquí hay un resumen rápido de las principales características:

  • Dimensiones Personalizables: Define el número de filas y columnas para cada matriz.
  • Opciones de Entrada Simples: Llena matrices con valores específicos (0, 1 o valores aleatorios).
  • Operaciones Específicas de Matrices: Realiza cálculos como transposición, encontrar el determinante, calcular la inversa o elevar una matriz a una potencia.
  • Operaciones de Matriz a Matriz: Suma, resta o multiplica matrices para ver resultados combinados.
  • Multiplicación Escalar: Multiplica cada elemento de una matriz por un número especificado.
  • Funciones de Copia e Intercambio: Copia resultados entre matrices o intercambia matrices según sea necesario.

Cómo Usar la Calculadora de Matrices

Sigue estos simples pasos para comenzar con los cálculos de matrices:

1. Configurar Dimensiones de la Matriz

  • Matriz A y Matriz B tienen opciones para establecer el número de filas y columnas.
  • Usa las cajas de entrada junto a "Fila" y "Columna" debajo de cada matriz para definir el tamaño de la matriz.
  • Nota: Para ciertas operaciones como potencia o determinante, la matriz debe ser cuadrada (filas y columnas iguales).

2. Ingresar Valores de la Matriz

  • Ingresa manualmente valores en cada celda de la cuadrícula o usa botones para llenar celdas automáticamente.
  • Opciones de Llenado:
    • Limpiar: Restablece todas las celdas en la matriz a cero.
    • Todo 0 / Todo 1: Llena toda la matriz con ceros o unos.
    • Aleatorio: Llena cada celda con un valor aleatorio, ideal para propósitos de prueba.

3. Realizar Operaciones de Matriz Única

Cada matriz puede ser transformada o modificada de manera independiente. Aquí están las acciones disponibles:

  • Transponer: Voltea la matriz a lo largo de su diagonal, intercambiando filas con columnas.
  • Potencia: Eleva la matriz a una potencia especificada (ingresa el valor de la potencia en la caja proporcionada).
  • Determinante: Calcula el determinante para matrices cuadradas, mostrando si la matriz es invertible.
  • Inversa: Genera la inversa de la matriz si es posible.
  • Multiplicación Escalar: Multiplica cada elemento por un escalar elegido (ingresado en la caja proporcionada).

4. Realizar Operaciones Entre Matrices

Usa las siguientes opciones en la sección "Botones de Operación" para combinar Matriz A y Matriz B:

  • A + B: Suma los elementos correspondientes de la Matriz A y la Matriz B.
  • A - B: Resta los elementos de la Matriz B de la Matriz A.
  • AB: Multiplica la Matriz A por la Matriz B, siempre que el número de columnas en la Matriz A sea igual al número de filas en la Matriz B.
  • Intercambiar Matrices: Intercambia los valores y dimensiones de la Matriz A y la Matriz B.

5. Ver y Usar Resultados

El resultado de cada operación aparece en la sección Resultados debajo de las matrices:

  • Una notación de matriz clara muestra los valores calculados.
  • Copiar a Matriz A o B: Transfiere el resultado directamente a la Matriz A o Matriz B para cálculos adicionales.

Ejemplos de Casos de Uso

Aquí hay algunos ejemplos de cómo podrías usar la Calculadora de Matrices:

  • Resolver Sistemas Lineales: Calcula la inversa de una matriz de coeficientes para resolver ecuaciones lineales.
  • Transformación de Datos: Usa la multiplicación y transposición de matrices para aplicar transformaciones a los datos.
  • Probar y Validar Cálculos: Prueba rápidamente las propiedades de las matrices, como simetría o singularidad, experimentando con matrices aleatorias.

Consejos para un Uso Efectivo

  • Verifica las Dimensiones de la Matriz: Asegúrate de que las dimensiones de las matrices sean compatibles para operaciones como multiplicación o suma.
  • Usa Llenados Aleatorios para Exploración: Las matrices generadas aleatoriamente te ayudan a explorar varias operaciones y resultados rápidamente.
  • Copia y Reutiliza Resultados: Los botones "Copiar a A" o "Copiar a B" te permiten reutilizar resultados calculados, perfectos para encadenar múltiples operaciones.

La Calculadora de Matrices es una herramienta versátil para realizar operaciones esenciales con matrices. Con su interfaz intuitiva y múltiples características, es un recurso valioso para cualquiera que trabaje con matrices. ¡Explora varias operaciones, combina cálculos y saca el máximo provecho de tus manipulaciones de matrices!