21. Cálculo iterativo del monto período a período

21.1 Qué significa iterar

Iterar es repetir una secuencia de instrucciones mientras cambia el estado del cálculo. En una capitalización, cada repetición representa un período completo.

21.2 El estado del algoritmo

El estado mínimo contiene la información necesaria para continuar:

También podemos conservar una traza con los estados anteriores para explicar o auditar el recorrido.

21.3 Inicializar correctamente

Antes del primer período, el acumulador contiene el capital inicial y el contador vale cero:

const capital = 150000;
let periodo = 0;
let monto = capital;

console.log("Período inicial:", periodo);
console.log("Monto inicial:", monto.toFixed(2));

En t = 0 todavía no se calculó ningún interés. Esta fila inicial es útil para no confundir capital con el monto del primer cierre.

21.4 Las instrucciones de cada paso

El orden importa: si actualizamos el monto antes de guardar la base, perdemos el valor sobre el que se calculó el interés.

21.5 El ciclo for

Cuando conocemos la cantidad de períodos, un ciclo for expresa claramente el recorrido:

const capital = 150000;
const tasa = 0.03;
const periodos = 4;

let monto = capital;

for (let periodo = 1; periodo <= periodos; periodo++) {
  const interes = monto * tasa;
  monto = monto + interes;
  console.log(`Período ${periodo}: ${monto.toFixed(2)}`);
}

console.log("Monto final:", monto.toFixed(2));

La condición periodo <= periodos asegura que se ejecuten exactamente n iteraciones. El ejemplo declara sus datos y muestra el monto de cada cierre.

21.6 Traza manual de cuatro períodos

Con $150.000 y 3 % por período, el recorrido es:

21.7 Actualización y asignación

La instrucción monto = monto + interes no es una igualdad algebraica: es una asignación. Primero evalúa el lado derecho con el estado anterior y luego guarda el resultado.

21.8 Construir una traza

Guardar cada paso permite mostrar tablas y comprobar relaciones:

const capital = 150000;
const tasa = 0.03;
const periodos = 4;

const traza = [{ periodo: 0, base: null, interes: 0, monto: capital }];
let monto = capital;

for (let periodo = 1; periodo <= periodos; periodo++) {
  const base = monto;
  const interes = base * tasa;
  monto = base + interes;
  traza.push({ periodo, base, interes, monto });
}

traza.forEach(fila => {
  const base = fila.base === null ? "—" : fila.base.toFixed(2);
  console.log(
    `Período ${fila.periodo}: base = ${base}, ` +
    `interés = ${fila.interes.toFixed(2)}, monto = ${fila.monto.toFixed(2)}`
  );
});

El arreglo conserva el proceso; la variable monto conserva solo el estado actual. El recorrido final imprime toda la traza en el área de resultados.

21.9 Invariantes útiles

Un invariante es una condición que debe cumplirse en cada iteración. Con tasa no negativa y sin retiros:

• la base del período coincide con el monto anterior;
• el interés del período no es negativo;
• el monto nuevo es mayor o igual que la base;
• el contador aumenta exactamente una unidad;
• la traza conserva el orden temporal.

Comprobar invariantes ayuda a detectar errores en el algoritmo.

21.10 Precisión dentro del ciclo

Redondear el monto en cada iteración puede cambiar las bases posteriores. Conservar precisión y redondear solo al mostrar puede producir otro resultado.

La política debe definirse: una norma o contrato puede exigir redondear en cada cierre. El algoritmo debe implementar esa regla de forma explícita, no accidental.

21.11 Validación y límites

Antes de iniciar el ciclo verificamos que el capital sea positivo, que la tasa sea finita y que la cantidad de períodos sea un entero no negativo. Durante la ejecución también controlamos que el monto siga siendo finito.

Limitar la cantidad de iteraciones evita bloquear la interfaz o crear arreglos innecesariamente grandes.

21.12 Una función completa

function calcularIterativamente(capital, tasa, periodos) {
  if (!Number.isFinite(capital) || capital <= 0) {
    throw new Error("Capital no válido");
  }
  if (!Number.isFinite(tasa) || tasa < 0) {
    throw new Error("Tasa no válida");
  }
  if (!Number.isInteger(periodos) || periodos < 0) {
    throw new Error("Cantidad de períodos no válida");
  }

  const traza = [{ periodo: 0, base: null, interes: 0, monto: capital }];
  let monto = capital;

  for (let periodo = 1; periodo <= periodos; periodo++) {
    const base = monto;
    const interes = base * tasa;
    monto = base + interes;
    traza.push({ periodo, base, interes, monto });
  }

  return { monto, traza };
}

const ejemplo = calcularIterativamente(150000, 0.03, 4);
console.log("Monto final:", ejemplo.monto.toFixed(2));
console.log("Filas de la traza:", ejemplo.traza.length);

21.13 Simulador paso a paso

Usá los botones o el deslizador para inspeccionar una iteración. La fila activa muestra el estado que entra, el cambio calculado y el estado que sale.

21.14 Ejercicio propuesto

Calculá iterativamente el monto de un capital de $200.000 durante 5 períodos a una tasa de 2 % por período.

1. Inicializá el acumulador.
2. Registrá base, interés y monto de cada paso.
3. Comprobá que cada base coincida con el monto anterior.
4. Obtené el monto final y el interés acumulado.
5. Implementá el recorrido sin utilizar potencias.

function calcularIterativamente(capital, tasa, periodos) {
  const traza = [{ periodo: 0, base: null, interes: 0, monto: capital }];
  let monto = capital;

  for (let periodo = 1; periodo <= periodos; periodo++) {
    const base = monto;
    const interes = base * tasa;
    monto = base + interes;
    traza.push({ periodo, base, interes, monto });
  }

  return { monto, traza };
}

const resultado = calcularIterativamente(200000, 0.02, 5);
const interesAcumulado = resultado.monto - 200000;

console.log("Monto final:", resultado.monto.toFixed(2));
console.log("Interés acumulado:", interesAcumulado.toFixed(2));
resultado.traza.forEach(fila => {
  console.log(`Período ${fila.periodo}: ${fila.monto.toFixed(2)}`);
});

21.15 Ideas para recordar

• El acumulador comienza con el capital inicial.
• Cada iteración representa un período completo.
• El interés se calcula antes de actualizar el monto.
• El monto nuevo se convierte en la base siguiente.
• Una traza conserva información que el acumulador reemplaza.
• La validación y la política de redondeo forman parte del algoritmo.

En el próximo tema deduciremos la fórmula del monto compuesto y el factor de acumulación.