import math

class Archivo:

    def leerArchivo(self,nombreArchivo):
        datosW = []
        datosX = []
        datosY = []
        datosZ = []
        iterador = 0
        archivo = open(nombreArchivo,"r")
        for linea in archivo.readlines():
            separarDatos = linea.split()
            datosW.append(float(separarDatos[0]))
            datosX.append(float(separarDatos[1]))
            datosY.append(float(separarDatos[2]))
            datosZ.append(float(separarDatos[3]))
        archivo.close()
        return datosW,datosX,datosY,datosZ

class CalcularBetas:

    def crearMatriz(self,vectorW,vectorX,vectorY,vectorZ):
        sumatoriaW=sumatoriaX=sumatoriaY=sumatoriaZ = 0.0
        wCuadrada=xCuadrada=yCuadrada=zCuadrada = 0.0
        wPorX=wPorY=wPorZ=xPorY=xPorZ=yPorZ = 0.0


        for iterador in range(len(vectorW)):
            sumatoriaW += vectorW[iterador]
            sumatoriaX += vectorX[iterador]
            sumatoriaY += vectorY[iterador]
            sumatoriaZ += vectorZ[iterador]

            wCuadrada += pow(vectorW[iterador],2)
            xCuadrada += pow(vectorX[iterador],2)
            yCuadrada += pow(vectorY[iterador],2)

            wPorX += vectorW[iterador] * vectorX[iterador]
            wPorY += vectorW[iterador] * vectorY[iterador]
            wPorZ += vectorW[iterador] * vectorZ[iterador]
            xPorY += vectorX[iterador] * vectorY[iterador]
            xPorZ += vectorX[iterador] * vectorZ[iterador]
            yPorZ += vectorY[iterador] * vectorZ[iterador]

        numeroDatos = len(vectorW)
        matrizBetas = [[numeroDatos,sumatoriaW,sumatoriaX,sumatoriaY],
                [sumatoriaW,wCuadrada,wPorX,wPorY],
                [sumatoriaX,wPorX,xCuadrada,xPorY],
                [sumatoriaY,wPorY,xPorY,yCuadrada]]

        vectorResultados = [sumatoriaZ,wPorZ,xPorZ,yPorZ]

        return matrizBetas,vectorResultados

    def calcularGauss(self,matrizDeBetas,vectorResultados):
        size = 4
        resultados = [0,0,0,0]
        for recorre in range(0,size):
            for renglon in range(recorre+1,size):
                factor=(matrizDeBetas[renglon][recorre]/matrizDeBetas[recorre][recorre])
                print(matrizDeBetas[renglon][recorre], matrizDeBetas[recorre][recorre], renglon,recorre)
                vectorResultados[renglon]=vectorResultados[renglon]-(factor*vectorResultados[recorre])
            for columnas in range(0,size):
                matrizDeBetas[renglon][columnas]=matrizDeBetas[renglon][columnas]-(factor*matrizDeBetas[recorre][columnas])
        resultados[size-1]=vectorResultados[size-1]/matrizDeBetas[size-1][size-1]

        for renglon in range(size-2,-1,-1):
            suma = 0
            for columnas in range(0,size):
                suma=suma+matrizDeBetas[renglon][columnas]*resultados[columnas]
            resultados[renglon]=(vectorResultados[renglon]-suma)/matrizDeBetas[renglon][renglon]
        return resultados

class Programa5: #m
    datosW = []
    datosX = []
    datosY = []
    datosZ = []
    vectorResultados = []
    resultadoHoras = 0
    resultados = []


    archivo = Archivo() #b
    calculos = CalcularBetas()
    nombreArchivo = input("ingresa el nombre del archivo de prueba: ") #b
    datosW,datosX,datosY,datosZ = archivo.leerArchivo(nombreArchivo)#b
    matriz,vectorResultados = calculos.crearMatriz(datosW,datosX,datosY,datosZ)
    resultados = calculos.calcularGauss(matriz,vectorResultados)

    lineasAgregadas = float(input("ingrese las lineas agregadas "))
    lineasReusadas = float(input("ingrese las lineas reusadas "))
    lineasModificadas = float(input("ingrese las lineas modificadas "))

    resultadoHoras = resultados[0]+(resultados[1]*lineasAgregadas)+(resultados[2]*lineasReusadas)+(resultados[3]*lineasModificadas)

    print("B0",resultados[0],"B1",resultados[1],"B2",resultados[2],"B3",resultados[3])
    print(resultadoHoras," horas")