From 113c20204dc8086eb99ecc5228884f9fbc3a9c23 Mon Sep 17 00:00:00 2001 From: Mireya Cueto Garrido Date: Mon, 23 Mar 2026 11:04:28 +0100 Subject: [PATCH 1/2] =?UTF-8?q?A=C3=B1adido=20endpoint=20para=20el=20c?= =?UTF-8?q?=C3=A1lculo=20de=20referencias?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/api/routes.py | 56 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 54 insertions(+), 2 deletions(-) diff --git a/backend/api/routes.py b/backend/api/routes.py index f52258d..a5b50bb 100644 --- a/backend/api/routes.py +++ b/backend/api/routes.py @@ -1,8 +1,60 @@ from fastapi import FastAPI +from pydantic import BaseModel +from typing import List, Dict app = FastAPI() +# 1. Definimos el modelo de datos basado en el JSON que se enviará desde el frontend +class ValueFunctionRequest(BaseModel): + criterion_name: str + levels: List[str] + blank_cards: List[int] + references: Dict[str, float] + +# Ruta prueba para probar que todo funciona @app.get("/prueba") def ruta_de_prueba(): - # En FastAPI si devuelves un diccionario, se transforma a JSON - return {"mensaje": "¡Hola desde FastAPI! El contenedor de docker está funcionando"} \ No newline at end of file + return {"mensaje": "¡Hola desde FastAPI! El contenedor de docker está funcionando"} + +# 2. Endpoint POST para recibir los datos y calcular los valores +@app.post("/api/criteria/doc/value-function") +def calcular_funcion_valor(request: ValueFunctionRequest): + levels = request.levels + blank_cards = request.blank_cards + refs = request.references + + # Extraemos las claves de referencia y las convertimos a enteros + claves_ref = sorted(int(k) for k in refs.keys()) # ejemplo: [0, 4] + p, q = claves_ref # p = 0, q = 4 + + # Valores de referencia + up = refs[str(p)] + uq = refs[str(q)] + + # PASO A: Calculamos el número total de unidades elementales 'h' entre p y q + h = sum(blank_cards[r] + 1 for r in range(p, q)) + + # PASO B: Calculamos el valor fraccional de una sola unidad 'alpha' + alpha = (uq - up) / h if h != 0 else 0 + + # Inicializamos la lista de valores V con el tamaño de los niveles + V = [0.0] * len(levels) + V[p] = up + + # PASO C: Calculamos los valores hacia adelante (niveles por encima de p) + for i in range(p + 1, len(levels)): + suma_unidades = sum(blank_cards[r] + 1 for r in range(p, i)) + V[i] = up + alpha * suma_unidades + + # PASO D: Calculamos los valores hacia atrás (niveles por debajo de p) + for i in range(p - 1, -1, -1): + suma_unidades = sum(blank_cards[r] + 1 for r in range(i, p)) + V[i] = up - alpha * suma_unidades + + # Formateamos la respuesta + resultado_valores = {levels[i]: round(V[i], 4) for i in range(len(levels))} + + return { + "criterion_name": request.criterion_name, + "values": resultado_valores + } From 7deda89ad0f2667d19f3c496524ec434225a5a5f Mon Sep 17 00:00:00 2001 From: Mireya Cueto Garrido Date: Mon, 23 Mar 2026 11:16:37 +0100 Subject: [PATCH 2/2] =?UTF-8?q?Optimizaci=C3=B3n=20c=C3=B3digo=20del=20POS?= =?UTF-8?q?T?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/api/routes.py | 72 ++++++++++++++++++++----------------------- 1 file changed, 33 insertions(+), 39 deletions(-) diff --git a/backend/api/routes.py b/backend/api/routes.py index a5b50bb..e84950b 100644 --- a/backend/api/routes.py +++ b/backend/api/routes.py @@ -4,57 +4,51 @@ from typing import List, Dict app = FastAPI() -# 1. Definimos el modelo de datos basado en el JSON que se enviará desde el frontend class ValueFunctionRequest(BaseModel): criterion_name: str levels: List[str] blank_cards: List[int] references: Dict[str, float] -# Ruta prueba para probar que todo funciona @app.get("/prueba") -def ruta_de_prueba(): +def prueba(): return {"mensaje": "¡Hola desde FastAPI! El contenedor de docker está funcionando"} -# 2. Endpoint POST para recibir los datos y calcular los valores @app.post("/api/criteria/doc/value-function") -def calcular_funcion_valor(request: ValueFunctionRequest): +def calcular(request: ValueFunctionRequest): levels = request.levels - blank_cards = request.blank_cards - refs = request.references - - # Extraemos las claves de referencia y las convertimos a enteros - claves_ref = sorted(int(k) for k in refs.keys()) # ejemplo: [0, 4] - p, q = claves_ref # p = 0, q = 4 + cards_between_levels = request.blank_cards + reference_values = request.references + + # Índices de referencia (por ejemplo 0 y 4) + ref_indices = sorted(int(k) for k in reference_values) + lower_ref, upper_ref = ref_indices + + # Valores asignados a esas referencias + lower_value = reference_values[str(lower_ref)] + upper_value = reference_values[str(upper_ref)] + + # Total de unidades entre las referencias + total_units = sum(cards_between_levels[i] + 1 for i in range(lower_ref, upper_ref)) + + # Valor por unidad + unit_value = (upper_value - lower_value) / total_units if total_units else 0 + + # Lista de valores finales + values = [0] * len(levels) + values[lower_ref] = lower_value + + # Hacia arriba + for i in range(lower_ref + 1, len(levels)): + units = sum(cards_between_levels[r] + 1 for r in range(lower_ref, i)) + values[i] = lower_value + unit_value * units + + # Hacia abajo + for i in range(lower_ref - 1, -1, -1): + units = sum(cards_between_levels[r] + 1 for r in range(i, lower_ref)) + values[i] = lower_value - unit_value * units - # Valores de referencia - up = refs[str(p)] - uq = refs[str(q)] - - # PASO A: Calculamos el número total de unidades elementales 'h' entre p y q - h = sum(blank_cards[r] + 1 for r in range(p, q)) - - # PASO B: Calculamos el valor fraccional de una sola unidad 'alpha' - alpha = (uq - up) / h if h != 0 else 0 - - # Inicializamos la lista de valores V con el tamaño de los niveles - V = [0.0] * len(levels) - V[p] = up - - # PASO C: Calculamos los valores hacia adelante (niveles por encima de p) - for i in range(p + 1, len(levels)): - suma_unidades = sum(blank_cards[r] + 1 for r in range(p, i)) - V[i] = up + alpha * suma_unidades - - # PASO D: Calculamos los valores hacia atrás (niveles por debajo de p) - for i in range(p - 1, -1, -1): - suma_unidades = sum(blank_cards[r] + 1 for r in range(i, p)) - V[i] = up - alpha * suma_unidades - - # Formateamos la respuesta - resultado_valores = {levels[i]: round(V[i], 4) for i in range(len(levels))} - return { "criterion_name": request.criterion_name, - "values": resultado_valores + "values": {levels[i]: round(values[i], 4) for i in range(len(levels))} }