Analizador de Código

Código de Entrada:

// ============================================================
// Metodo de Biseccion - XNK SimpliCode
//
// Algoritmo:
//   Dados f(x), intervalo [a,b], tolerancia y maxIter:
//   1. Verifica que f(a)*f(b) < 0  (condicion de Bolzano)
//   2. En cada iteracion calcula el punto medio p = a + (b-a)/2
//   3. Actualiza el intervalo segun el signo de f(a)*f(p)
//   4. Converge cuando error = |b-a|/2 < tolerancia
// ============================================================

// --- Valor absoluto ---
funcion decimal abs(decimal val) {
    si (val < 0.0) {
        retornar -val;
    }
    retornar val;
}

// --- Funcion objetivo: cambiar esta expresion segun el problema ---
// Ejemplo: f(x) = x^3 - x - 2   (raiz real cerca de x = 1.5214)
funcion decimal f(decimal x) {
    retornar x ^ 3.0 - x - 2.0;
}

// --- Procedimiento principal de biseccion ---
procedimiento biseccion(decimal a, decimal b, decimal tol, entero maxIter) {

decimal fa = ejecutar f(a);
    decimal fb = ejecutar f(b);

// Validaciones de entrada
    si (tol <= 0.0) {
        imprimir nl "Error: la tolerancia debe ser mayor que 0";
        retornar;
    }
    si (maxIter <= 0) {
        imprimir nl "Error: el numero maximo de iteraciones debe ser mayor que 0";
        retornar;
    }
    si (a >= b) {
        imprimir nl "Error: a debe ser menor que b";
        retornar;
    }

// Condicion de Bolzano: f(a)*f(b) debe ser negativo
    si (fa * fb >= 0.0) {
        imprimir nl "Error: f(a) y f(b) tienen el mismo signo, no se garantiza raiz en el intervalo";
        retornar;
    }

// Raiz exacta en los extremos del intervalo
    si (ejecutar abs(fa) < 0.00000000001) {
        imprimir nl "Raiz exacta en a = ";
        imprimir nl a;
        retornar;
    }
    si (ejecutar abs(fb) < 0.00000000001) {
        imprimir nl "Raiz exacta en b = ";
        imprimir nl b;
        retornar;
    }

// Encabezado de tabla de resultados
    imprimir nl "i    a                  b                  p                  f(p)               error";
    imprimir nl "--------------------------------------------------------------------------------------";

// Variables de iteracion
    entero i = 1;
    decimal p = 0.0;
    decimal fp = 0.0;
    decimal error = 0.0;
    decimal aActual = a;
    decimal bActual = b;
    decimal faActual = fa;
    decimal fbActual = fb;

mientras (i <= maxIter) {

p      = aActual + (bActual - aActual) / 2.0;
        fp     = ejecutar f(p);
        error  = ejecutar abs((bActual - aActual) / 2.0);

// Fila de la tabla
        imprimir i;
        imprimir "    ";
        imprimir aActual;
        imprimir "    ";
        imprimir bActual;
        imprimir "    ";
        imprimir p;
        imprimir "    ";
        imprimir fp;
        imprimir "    ";
        imprimir nl error;

// Raiz exacta hallada en p
        si (ejecutar abs(fp) < 0.00000000001) {
            imprimir nl "Raiz exacta encontrada en iteracion ";
            imprimir nl i;
            imprimir nl "Resultado: p = ";
            imprimir nl p;
            retornar;
        }

// Convergencia: error menor que tolerancia
        si (error < tol) {
            imprimir nl "Convergencia en iteracion ";
            imprimir nl i;
            imprimir nl "Resultado: p = ";
            imprimir p;
            imprimir "    error = ";
            imprimir nl error;
            retornar;
        }

// Actualizar subintervalo segun signo de f(a)*f(p)
        si (faActual * fp > 0.0) {
            aActual  = p;
            faActual = fp;
        } de lo contrario {
            bActual  = p;
            fbActual = fp;
        }

i++;
    }

// Maximo de iteraciones alcanzado sin convergencia
    imprimir nl "Maximo de iteraciones (";
    imprimir maxIter;
    imprimir ") alcanzado sin convergencia";
    imprimir nl "Mejor aproximacion: p = ";
    imprimir p;
    imprimir "    error = ";
    imprimir nl error;
}

// ============================================================
// Casos de prueba
// ============================================================

imprimir nl "=== METODO DE BISECCION ===";
imprimir nl "Funcion: f(x) = x^3 - x - 2";
imprimir nl "";

// Caso 1: convergencia normal
imprimir nl "-- Caso 1: [1.0, 2.0], tol=0.0001, maxIter=50";
ejecutar biseccion(1.0, 2.0, 0.0001, 50);
imprimir nl "";

// Caso 2: tolerancia mas estricta
imprimir nl "-- Caso 2: [1.0, 2.0], tol=0.000001, maxIter=100";
ejecutar biseccion(1.0, 2.0, 0.000001, 100);
imprimir nl "";

// Caso 3: error - mismo signo en extremos
imprimir nl "-- Caso 3 (error esperado): [2.0, 3.0]";
ejecutar biseccion(2.0, 3.0, 0.0001, 50);
imprimir nl "";

// Caso 4: error - tolerancia invalida
imprimir nl "-- Caso 4 (error esperado): tol=-1";
ejecutar biseccion(1.0, 2.0, -1.0, 50);
imprimir nl "";

// Caso 5: error - intervalo invertido
imprimir nl "-- Caso 5 (error esperado): a > b";
ejecutar biseccion(2.0, 1.0, 0.0001, 50);

Resultado:

Tabla de Errores

#	Tipo	Descripción	Línea	Columna	Detalles

No se encontraron errores

Tabla de Símbolos

#	Nombre	Tipo	Valor	Ámbito	Entorno	Línea	Columna

No se encontraron símbolos

Visualización AST (DOT):