def filtrerFichierSelonNombreLignes(fichier,
resultat,
nbLignes,
separateur=" "):
from LectureEcritureFichier import lireFichier
import sys
precisionInferieure = 0.0
precisionSuperieure = 1.0
precision = (precisionInferieure + precisionSuperieure) / 2.0
epsilon = sys.float_info.epsilon
while True:
filtrerFichierSelonPrecision(fichier, resultat, precision, separateur)
nbLignesFiltrees = len(lireFichier(resultat))
if nbLignesFiltrees < nbLignes:
print "Précision %e trop grande, %d lignes récupérées" % (
precision, nbLignesFiltrees)
precisionSuperieure = precision
precision = (precisionInferieure + precisionSuperieure) / 2.0
elif nbLignesFiltrees > nbLignes:
print "Précision %e trop petite, %d lignes récupérées" % (
precision, nbLignesFiltrees)
precisionInferieure = precision
precision = (precisionInferieure + precisionSuperieure) / 2.0
elif (precisionSuperieure - precisionInferieure) < epsilon:
print "Précision limite %e insuffisante, %d lignes récupérées" % (
precision, nbLignesFiltrees)
break
else:
print "Précision %e suffisante, %d lignes récupérées" % (
precision, nbLignesFiltrees)
break
def filtrerFichierSelonPrecision(fichier, resultat, precision, separateur=" "):
from ComparaisonElements import identiques
from LectureEcritureFichier import ecrireFichier, lireFichier
from OperationsTexte import joindreEtConvertirListeTexte, separerEtConvertirListeTexte
from math import fabs
lignes = separerEtConvertirListeTexte(lireFichier(fichier), separateur)
nbLignes = len(lignes)
deltaColonnes = {}
valeursColonnes = {}
for itLigne in range(nbLignes):
elements = lignes[itLigne]
nbElements = len(elements)
for itElement in range(nbElements):
element = elements[itElement]
if not valeursColonnes.has_key(itElement):
valeursColonnes[itElement] = []
valeursColonnes[itElement].append(element)
nbColonnes = len(valeursColonnes)
for itColonne in range(nbColonnes):
valeurs = valeursColonnes[itColonne]
delta = recupererDeltaValeurs(valeurs)
deltaColonnes[itColonne] = delta
lignesFiltrees = [lignes[0]]
elementsPrecedents = lignes[0]
for itLigne in range(1, nbLignes):
elements = lignes[itLigne]
nbElements = len(elements)
for itElement in range(nbElements):
elementPrecedent = elementsPrecedents[itElement]
element = elements[itElement]
divergence = False
if isinstance(element, str) or isinstance(elementPrecedent, str):
if not identiques(element, elementPrecedent):
divergence = True
else:
delta = deltaColonnes[itElement]
try:
ecart = fabs(element - elementPrecedent) / min(
fabs(element), fabs(elementPrecedent))
except ZeroDivisionError:
ecart = fabs(element - elementPrecedent)
if ecart > (delta * precision):
divergence = True
if divergence:
elementsPrecedents = elements
lignesFiltrees.append(elements)
break
if lignes[nbLignes - 1] not in lignesFiltrees:
lignesFiltrees.append(lignes[nbLignes - 1])
ecrireFichier(resultat,
joindreEtConvertirListeTexte(lignesFiltrees, separateur))
def recupererPolynomeFichier(fichierEntree, degre):
from LectureEcritureFichier import lireFichier
from OperationsTexte import separerEtConvertirTexte
listePoints = Points()
lignesFichierEntree = lireFichier(fichierEntree)
for ligne in lignesFichierEntree:
x = separerEtConvertirTexte(ligne)[0]
y = separerEtConvertirTexte(ligne)[1]
point = Point(x, y)
listePoints.ajouterPoint(point)
return listePoints.recupererPolynome(degre)
def recupererPlaneurs(nomFichier):
from LectureEcritureFichier import lireFichier
from OperationsTexte import separerEtConvertirTexte
from Planeur import Planeur
planeurs = {}
lignesPlaneurs = lireFichier(nomFichier)
for ligne in lignesPlaneurs[1:]:
elements = separerEtConvertirTexte(ligne, ";")
planeur = Planeur(elements[0], elements[1], elements[2], elements[3], elements[4],
elements[5], elements[6], elements[7], elements[8], elements[9], elements[10],
elements[11], elements[12])
planeurs[planeur.nom] = planeur
return planeurs
def recupererPneus(nomFichier):
from LectureEcritureFichier import lireFichier
from OperationsTexte import separerEtConvertirTexte
from Pneu import Pneu
pneus = {}
lignesPneus = lireFichier(nomFichier)
for ligne in lignesPneus[1:]:
elements = separerEtConvertirTexte(ligne, ";")
pneu = Pneu(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5],
elements[6], elements[7], elements[8], elements[9], elements[10], elements[11],
elements[12])
pneus[pneu.nom] = pneu
return pneus
def recupererVehicules(nomFichier):
from LectureEcritureFichier import lireFichier
from OperationsTexte import separerEtConvertirTexte
from Vehicule import Vehicule
vehicules = {}
lignesVehicules = lireFichier(nomFichier)
for ligne in lignesVehicules[1:]:
elements = separerEtConvertirTexte(ligne, ";")
vehicule = Vehicule(elements[0], elements[1], elements[2], elements[3], elements[4],
elements[5], elements[6], elements[7], elements[8], elements[9], elements[10],
elements[11], elements[12])
vehicules[vehicule.nom] = vehicule
return vehicules
def recupererPilotes(nomFichier):
from LectureEcritureFichier import lireFichier
from OperationsTexte import separerEtConvertirTexte
from Pilote import Pilote
pilotes = {}
lignes = lireFichier(nomFichier)
for ligne in lignes[1:]:
elements = separerEtConvertirTexte(ligne, ";")
pilote = Pilote(elements[0], elements[1], elements[2], elements[3], elements[4],
elements[5], elements[6], elements[7], elements[8], elements[9], elements[10],
elements[11], elements[12], elements[13])
pilotes[pilote.nom] = pilote
return pilotes
def interpolerFichier(fichierEntree, fichierSortie, pas):
from LectureEcritureFichier import ecrireFichier, lireFichier
from OperationsTexte import convertirNombreEnTexte, separerEtConvertirTexte
listePoints = Points()
lignesFichierEntree = lireFichier(fichierEntree)
for ligne in lignesFichierEntree:
x = separerEtConvertirTexte(ligne)[0]
y = separerEtConvertirTexte(ligne)[1]
point = Point(x, y)
listePoints.ajouterPoint(point)
listePointsInterpoles = listePoints.interpolerPas(pas)
lignesFichierSortie = [
str("%s %s" % (convertirNombreEnTexte(pointInterpole.getX()),
convertirNombreEnTexte(pointInterpole.getY())))
for pointInterpole in listePointsInterpoles
]
ecrireFichier(fichierSortie, lignesFichierSortie)
# Programme principal
import os
import sys
from LectureEcritureFichier import lireFichier, ecrireFichier
if __name__ == "__main__":
fichierDefinitions = sys.argv[1]
repertoireEntetes = sys.argv[2]
repertoireSources = sys.argv[3]
if not os.path.isdir(repertoireEntetes):
os.mkdir(repertoireEntetes)
if not os.path.isdir(repertoireSources):
os.mkdir(repertoireSources)
lignes = lireFichier(fichierDefinitions)
auteur = Auteur("FirstName", "LastName",
"*****@*****.**")
version = Version("1.0.0", "DD/MM/YYYY")
classe = Classe(None)
for ligne in lignes:
if ligne.startswith("a"):
ligne = ligne.lstrip("a").lstrip()
auteur = Auteur(
ligne.split(";")[0],
ligne.split(";")[1],
ligne.split(";")[2])
elif ligne.startswith("v"):
ligne = ligne.lstrip("v").lstrip()
version = Version(ligne.split(";")[0], ligne.split(";")[1])
elif ligne.startswith("c"):
def comparerFichiers(fichier1, fichier2, resultat, precision, separateur=" "):
from ComparaisonElements import identiques
from LectureEcritureFichier import lireFichier
from OperationsTexte import joindreEtConvertirTexte, separerEtConvertirListeTexte
from math import fabs
from xml.etree import ElementTree
html = ElementTree.Element("html")
head = ElementTree.SubElement(html, "head")
body = ElementTree.SubElement(html, "body")
titre = str("Comparaison de %s et %s avec une précision de %e" %
(fichier1, fichier2, precision)).decode("utf-8")
head_title = ElementTree.SubElement(head, "title")
head_title.text = titre
body_h1 = ElementTree.SubElement(body, "h1")
body_h1.text = titre
lignes1 = separerEtConvertirListeTexte(lireFichier(fichier1), separateur)
lignes2 = separerEtConvertirListeTexte(lireFichier(fichier2), separateur)
nbLignes1 = len(lignes1)
nbLignes2 = len(lignes2)
if nbLignes1 != nbLignes2:
note = str("Nombre de lignes différent").decode("utf-8")
contexte1 = str("Contexte 1 = %d" % (nbLignes1)).decode("utf-8")
contexte2 = str("Contexte 2 = %d" % (nbLignes2)).decode("utf-8")
construireDifference(body, note, contexte1, contexte2)
else:
for itLigne in range(nbLignes1):
elements1 = lignes1[itLigne]
elements2 = lignes2[itLigne]
nbElements1 = len(elements1)
nbElements2 = len(elements2)
if nbElements1 != nbElements2:
note = str("Ligne %d : nombre d'éléments différent" %
(itLigne + 1)).decode("utf-8")
contexte1 = str("Contexte 1 = %s" % (joindreEtConvertirTexte(
elements1, separateur))).decode("utf-8")
contexte2 = str("Contexte 2 = %s" % (joindreEtConvertirTexte(
elements2, separateur))).decode("utf-8")
construireDifference(body, note, contexte1, contexte2)
else:
for itElement in range(nbElements1):
element1 = elements1[itElement]
element2 = elements2[itElement]
if not identiques(element1, element2):
if isinstance(element1, str) or isinstance(
element2, str):
note = str(
"Ligne %d : élément %d différent" %
(itLigne + 1, itElement + 1)).decode("utf-8")
contexte1 = str("Contexte 1 = %s" %
(element1)).decode("utf-8")
contexte2 = str("Contexte 2 = %s" %
(element2)).decode("utf-8")
construireDifference(body, note, contexte1,
contexte2)
else:
try:
ecart = fabs(element1 - element2) / min(
fabs(element1), fabs(element2))
except ZeroDivisionError:
ecart = fabs(element1 - element2)
if ecart > precision:
note = str(
"Ligne %d : précision de l'élément %d non respectée, écart relatif de %e"
% (itLigne + 1, itElement + 1,
ecart)).decode("utf-8")
contexte1 = str("Contexte 1 = %s" %
(element1)).decode("utf-8")
contexte2 = str("Contexte 2 = %s" %
(element2)).decode("utf-8")
construireDifference(body, note, contexte1,
contexte2)
arbre = ElementTree.ElementTree(html)
arbre.write(resultat)
