mazex/Python-2019
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added to polynome the function to get the roots, in all cases.

Browse Source
This commit is contained in:
marc
2019-03-31 16:27:45 +02:00
parent 2096713838
commit 51b1bd06e9
9 changed files with 559 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Info/.DS_Store
Vendored
BIN
View File
Binary file not shown.
Info/Td/TD11: Marc, Louise et Hugues.py
+130
View File
@@ -0,0 +1,130 @@
import random
"""Partie 1: Tri par sélection."""
def reperer(liste,n):
"""Repere la position du plus grand element parmi les n premiers elements d'une liste."""
maximum=liste[0] #Affecte a maximum la valeur du premier élément de la liste.
position=0 #Affecte a position la valeur de 0.
for i in range(1,n): #Fait varier les valeurs de i de 1 à n.
if liste[i]>maximum: #Verifie si la ie valeur de la liste est supérieur a la valeur de maximum.
maximum=liste[i] #Si oui, affecte a maximum la valeur du ie valeur de la liste.
position=i #Recupere la position de cet élément.
return position #Renvoie la position de cet élément.
def echanger(liste,position1,position2):
"""Echange 2 éléments d'une liste de positions données."""
valeur=liste[position1] #Affecte a valeur la valeur de position1e terme de la liste.
liste[position1]=liste[position2] #Mets en position1 le position2e terme de la liste.
liste[position2]=valeur #Affecte au position2e terme de la liste la valeur de valeur.
return liste #Renvoie la nouvelle liste de termes échangés.
def TriParSelection(liste):
"""Tri une liste."""
for n in range(len(liste)-1,0,-1): #Fait varier les valeurs de n de len(liste)-1 à 1.
r=reperer(liste,n) #Recupere la position du plus grand élément parmi les n premiers.
liste=echanger(liste,n,r) #Echange les éléments de position n et r.
return liste #Renvoie la liste triée.
def test(a,b,taille,nombre=10):
"""Test:"""
for i in range(nombre): #Fait nombre tests et affiche les résultats.
liste=[random.randint(a,b) for i in range(taille)]
print("Test:",i+1)
print(liste)
print(principale(liste))
print("")
#test(0,10,100)
"""Partie 2: Tri par insertion
10)
ALGORITHME: TRIPARINSERTION:
DONNES: L :
LT <- []
POUR i DE 0 JUSQU A LA LONGUEUR DE LA LONGUEUR DE L FAIRE
AJOUTER A LT LA VALEUR L[i]
k <- i
cle <- LT[-1]
TANT QUE cle<LT[k-1] and k>0 FAIRE
LT[k] <- LT[k-1]
k <- k-1
FIN TANT QUE
LT[k] <- cle
FIN POUR
AFFICHER LT
11)
"""
def TriParInsertion(L):
"""Tri une liste par insertion."""
LT=[]
#Recupere les éléments de L et les ajoute dans LT de façon a ce que LT soit triée
for i in range(len(L)):
#Ajoute la valeur de L considérée et stocke la valeur de la clé
LT.append(L[i])
k=i
cle=LT[-1]
#Décale la valeur de la clé dans LT tant que la clé est supérieur a ses éléments en partant de la fin
while cle<LT[k-1] and k>0:
LT[k]=LT[k-1] #Réaffecte la valeur de l'élément k a la valeur de l'élément k-1.
k-=1
#Une fois que l'on trouve que la clé est inférieure à un élément ou que l'on a considéré tous les éléments de LT
LT[k]=cle
#Renvoie la liste triée
return LT
"""
13) Justesse du tri par sélection
Algorithme: Reperer
Pas de boucle
Algorithme: Echanger
Pas de boucle
Algorithme: TriParSelection
Invariant de boucle: ...
Algorithme: Test
Invariant de boucle: ...
14) Justesse du tri par insertion
Algorithme: Tri par insertion
Invariant de boucle: ...
15)
"""
def TriParInsertionEtComplexite(L):
complexite=0
LT=[]
complexite+=1
for i in range(len(L)):
LT.append(L[i])
k=i
cle=LT[-1]
complexite+=4
while cle<LT[k-1] and k>0:
LT[k]=LT[k-1]
k-=1
complexite+=4
complexite+=1
LT[k]=cle
complexite+=1
complexite+=1
return [LT,complexite]
#16)
L=[random.randint(0,10) for e in range(100)]
Trie,complexite=TriParInsertionEtComplexite(L)
print("Liste triee:",Trie)
print("Complexite:",complexite)
Info/Td/__pycache__/converter.cpython-36.pyc
BIN
View File
Binary file not shown.
Info/Td/converter.py
+260
View File
@@ -0,0 +1,260 @@
import inspect
def test(arg1,arg2):
a = arg1 + arg2
return a
#do something with args
keywords=["assert","break","class","continue","def","del","elif","else","except","finally","for",
"from","global","if","import","in","pass","print","raise","return","try","while","yield"]
conversion1 = {"assert":"ASSERT",
"break":"SORTIR DE LA BOUCLE",
"class":"CLASSE",
"continue":"CONTINER",
"def":"DONNEES",
"del":"SUPPRIMER",
"elif":["SINON SI","FAIRE"],
"else":["SINON","FAIRE"],
"except":"EXCEPTE",
"finally":"FINALLEMENT",
"for":["POUR","FAIRE"],
"from":"DEPUIS",
"global":"GLOBAL",
"if":"SI",
"import":"IMPORTER",
"in":"DANS",
"pass":"PASSER",
"print":"AFFICHER",
"raise":"RELEVER",
"return":"AFFICHER",
"try":"ESSAYER",
"while":["TANT QUE","FAIRE"],
"yield":"PASSER AU TOUR SUIVANT",
"==":"=",
"=":"<-"}
def algorithm(name):
lines = inspect.getsource(name)
print(lines)
output = []
lines = lines.split("\n")
lines=removeUselessIndent(lines)
lines=Converter(lines)
for line in lines:
output.append(Converter(line)())
#print("output: ",output)
return "\n".join(output)
class Converter:
def __init__(self,name):
self.name=name
self.code=inspect.getsource(name)
print(self.code)
self.lines=self.code.split("\n")
self.indent_historic=[]
self.indent=0
self.cleanCode()
self.conversion= {"assert": [[None,"assert",None], [None,"ASSERT",None]],
"break": [[None,"break"], [None,"SORTIR DE LA BOUCLE"]],
"class": [["class",None], ["CLASS",None]],
"continue": [[None,"continue",None], [None,"CONTINUER",None]],
"def": [["def",None,"(",None,"):"], [None,":\nDONNES: ",None," :"]],
"del": [[None,"del",None], [None,"SUPPRIMER",None]],
"elif": [[None,"elif",None,":"], [None,"SINON SI",None," FAIRE"]],
"else": [[None,"else:",None], [None,"SINON",None," FAIRE"]],
"except": [[None,"except:",None], [None,"EXCEPTE",None]],
"finally": [[None,"finally:",None], [None,"FINALLEMENT",None]],
"for": [["for",None," in ",None,":"], ["POUR",None," DANS ",None," FAIRE"]],
"from": [["from",None,"import",None], ["DEPUIS",None,"IMPORTER",None]],
"global": [["global",None], ["GLOBAL",None]],
"if": [[None,"if",None], [None,"SI",None]],
"import": [[None,"import",None], [None,"IMPORTER",None]],
" in ": [[None," in ",None], [None, "DANS ",None]],
" is ": [[None," is ",None], [None," EST ",None]],
"lambda": [[None,"lambda",None,":",None], [None,":\nDONNEES: ",None," :\nRENVOIE",None]],
"pass": [[None,"pass"], [None,"PASSER",None]],
"print": [[None,"print",None,"(",None,")"], [None,"AFFICHER: ",None,None]],
"raise": [[None,"raise",None], [None,"RELEVER",None]],
"return": [[None,"return",None], [None,"AFFICHER",None]],
"try": [[None,"try:",None], [None,"ESSAYER",None]],
"while": [["while ",None,":"], ["TANT QUE ",None," FAIRE"]],
"yield": [[None,"yield"], [None,"PASSER AU TOUR SUIVANT"]],
"True": [[None,"True",None], [None,"VRAI",None]],
"False": [[None,"False",None], [None,"FAUX",None]],
"==": [[None,"==",None], [None,"=",None]],
"!=": [[None,"!=",None], [None,"≠",None]],
"=": [[None,"=",None], [None," <- ",None]],
"append": [[None,".append(",None,")"], ["AJOUTER A ",None," LA VALEUR ",None]],
"not": [[None,"not",None], [None,"NON",None]]}
def cleanCode(self):
self.cleanIndents()
def cleanIndents(self):
self.line=self.lines[0]
count=self.countIndent(self.line)
for i in range(len(self.lines)):
self.lines[i]=self.lines[i][4*count:]
def trackIndent(self,i):
print(i)
indent=self.countIndent(self.lines[i])
if indent>len(self.indent_historic):
self.addElementIndentHistoric(i)
if indent<len(self.indent_historic):
self.delElementIndentHistoric(i)
print("i:",i)
print("self.lines[i]:",self.lines[i])
print("indent:",indent)
print("historic:",self.indent_historic)
print("")
self.indent=indent
self.removeIndent(i)
#self.indent_historic.append()
def addElementIndentHistoric(self,i):
l={ " while ":" TANT QUE ",
" for ": " POUR ",
" if ": " SI "}
for e in l:
if e in self.lines[i]:
self.indent_historic.append(l[e])
print(self.lines[i])
print(e)
print(e in self.lines[i])
def delElementIndentHistoric(self,i):
print(len(self.lines))
print(i+1)
self.lines[i]+="\n"+" "*4*(self.countIndent(self.lines[i+1])+1)+"FIN "+self.indent_historic[-1]
del self.indent_historic[-1]
def countIndent(self,line):
i=0
for i in range(len(line)):
if line[i]!=" ":
break
return int(i/4)
def removeIndent(self,i):
count=self.countIndent(self.lines[i])
self.line=self.line[count*4:]
def removeCommentaries(self):
self.commentaries=""
if "#" in self.line:
i=self.next(self.line,"#")
self.commentaries=self.line[i:]
self.line=self.line[:i]
if "\"\"\"" in self.line:
i=self.next(self.line,"\"\"\"")
self.commentaries=self.line[i:]
self.line=self.line[:i]
def convert(self):
breaking=False
for key in self.conversion:
if key=="==":
breaking=True
if key in self.line:
self.apply(key)
if breaking:
break
def apply(self,key):
#print("key:",key)
l=self.missing(self.conversion[key][0])
#print("l:",l)
filled=self.fill(self.conversion[key][1],l)
#print("filled:",filled)
self.line="".join(filled)
#print(self.line)
def missing(self,l):
"""
l= ["def ",None,"(",None,"):"]
self.line= "def algorithm(name):"
l1=["def","(","):"]
"""
line=[]
if l[0]==None:
i=self.next(self.line,l[1])
line.append(self.line[:i])
for i in range(1,len(l)-1):
#print("missing loop:",l[i-1],l[i],l[i+1])
if l[i]==None:
a=self.between(self.line,l[i-1],l[i+1])
line.append(a)
#print("a",a)
if l[-1]==None:
i=self.next(self.line,l[-2])+len(l[-2])
line.append(self.line[i:])
return line
def removeNone(self,l):
l1=[]
for word in l:
if word!=None:
l1.append(word)
return l1
def between(self,text,word1,word2):
i1=self.next(text,word1)+len(word1)
i2=i1+self.next(text[i1:],word2)
return text[i1:i2]
def cut(self,text,word):
for i in range(len(text)-len(word)+1):
if text[i:i+len(word)]==word:
break
return [text[:i],word,text[i+len(word):]]
def next(self,text,word):
for i in range(len(text)-len(word)+1):
if text[i:i+len(word)]==word:
break
return i
def fill(self,l1,l2):
line=[]
for e1 in l1:
if e1==None:
line.append(l2[0])
del l2[0]
else:
line.append(e1)
return line
def assemble(self):
pass
def __call__(self):
for i in range(len(self.lines)):
if i<len(self.lines)-1:
self.trackIndent(i)
self.indent=self.countIndent(self.lines[i])
self.line=self.lines[i]
self.removeCommentaries()
self.convert()
self.lines[i]= " "*4*self.indent+self.line+" "+self.commentaries
self.cleanCode()
l1,l2=self.lines[0].split("\n")
l1="ALGORITHME: "+l1.upper() +"\n\n"
self.lines[0]=l1+l2
return "\n".join(self.lines)
if __name__=="__main__":
print(Converter(test)())
#c=Converter("def test(arg1,arg2):")
#print(c.between("def test(arg1,arg2):","(",")"))
Info/Td/tpServignyRUBINdeCERVENSPartenskyTD10.py
+126
View File
@@ -0,0 +1,126 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Feb 11 16:23:27 2019
@author: hurc60248
"""
"""
I) Choisir le bon type de données
1) a) Chaîne de caractère
b) t uple
c) chaîne de caractére
d) chaîne de caractére
II)Prévoir ce que fait un script
2) Ce script affichera un message d'erreur car t=(1,2,3) est un t uple et t+4 est une opération sur les entiers
3) Ce script affichera "str"
4) Ce script affichera "isepparis"
5) Ce script affichera le crochet quand on demande a[0], et la virgule, quand on demande a[2]
III) Listes
6)a) "randint(self, a, b) method of random.Random instance
Return random integer in range [a, b], including both end points."
1er methode
b) import random
a=[]
for i in range(50):
a.append(random.randint(0,1))
2eme methode
a=[random.randint(0,1) for i in range(50)]
7)a) Données : liste, element
compteur <- 0
Pour e dans liste FAIRE
Si e=element FAIRE
compteur <- compteur + 1
Fin si
Fin pour
Afficher compteur
FIN
b) def compter(liste, élément):
compteur=0
for e in liste:
if e==element:
compteur+=1
return compteur
8)a) Données : liste, element
sortie <- []
pour i dans (0,longueur(liste)) faire
si liste(i)=element FAIRE
Ajouter a sortie l'indice i
FIN si
Afficher(sortie)
FIN
b)def Compter(liste, element):
sortie=[]
for i in range(len(liste)):
if liste[i]==element:
sortie.append(i)
return sortie
9)a)Données : liste
somme=0
Pour element dans liste FAIRE
somme <- element + somme
Fin pour
moyenne=somme/longueur(liste)
somme2=0
Pour element dans liste FAIRE
somme2 <- somme2 + (element-moyenne)²
variance=somme2/longueur(liste)
Afficher moyenne, variance
FIN
b)def stats(liste):
moyenne=sum(liste)/len(liste)
variance=sum([(x-moyenne)**2 for x in liste])/len(liste)
return (moyenne, variance)
10)a) Données : entnat1, entnat2
Si entnat1 divise entnat2 FAIRE
res <- vrai
Sinon FAIRE
res <-faux
fin si
Afficher resultat
b) Divise=lambda a,b:(b%a==0)
11)a) Données : entier
liste=[]
Pour element dans liste qui prend toutes les valeurs entre 1 et entier Faire
Si element divise entier Faire
Ajouter element dans liste
fin si
fin pour
Afficher liste
b) ListeDiv=lambda a:[e for e in range(1,a+1) if Divise(e,a)]
12)a) Données : liste1, liste2
commun=[]
pour element dans liste1 faire
Si element dans liste2 faire
Ajouter element a commun
fin si
fin pour
Afficher commun
b) ComListe=lambda a,b:list(set([e for e in a if e in b]))
13)a)
PGCDN=lambda a,b:max(ComListe(ListDiv(a),ListDiv(b)))
"""
Teletype/Polynome.py
+42 -59
View File
@@ -16,18 +16,18 @@ Features:
"""
from copy import deepcopy
from mymaths.infinity import Infinity
from mymaths.limit import lim
import matplotlib.pyplot as plt
#import matplotlib.pyplot as plt #Old way to show the polynome on screen. Not very nice though...
from mygrapher.grapher import Grapher
from mygrapher.mycolors import *
from mygrapher.grapher import Grapher #Used to show the polynome on screen with the ability to move within it.
import random #Used only to generate random polynomes.
class Polynomial:
def __init__(self, coefficients):
"""Create a polynomial using its coefficients."""
self.coefficients = coefficients
self.definition=[-10**20,10**20]
def __repr__(self):
"""Return the usual representation of a polynomial."""
if self.coefficients==[]:
@@ -203,65 +203,48 @@ class Polynomial:
sum+=c*x**n
return sum
def getTrivialRoots(self):
"""Return the list of trivial roots found."""
l=[]
for e in range(-10,11,1):
if self(e)==0:
l.append(e)
return l
def roots(self):
"""Return the list of all the roots of the polynomial."""
#print("Trivial Roots:",self.getTrivialRoots())
B=deepcopy(A)
derivatives=[deepcopy(A)]
roots=[]
def allDerivatives(self):
"""Return the list of all derivatives of the polynome until the zero polynome."""
B=deepcopy(self)
derivatives=[deepcopy(self)]
while B.degree()>1:
B.derivate()
derivatives.append(deepcopy(B))
return derivatives
def roots(self):
"""Return the list of all the roots of the polynomial."""
"""Does that by finding where all the derivates cancel, to find new extrema and applying tvi."""
roots=[]
derivatives=self.allDerivatives()
print(derivatives)
derivatives.reverse()
oldextrema=[]
old_extrema=[]
for derivative in derivatives:
newextrema=[]
neglim=lim(derivative,-Infinity())
poslim=lim(derivative,Infinity())
if type(neglim)==Infinity:
neglim=~neglim
if type(poslim)==Infinity:
poslim=~poslim
extrema=[neglim]+oldextrema+[poslim]
new_extrema=[]
neglim=self.definition[0]
poslim=self.definition[1]
extrema=[neglim]+old_extrema+[poslim]
for i in range(len(extrema)-1):
print("extrema:",extrema[i],extrema[i+1])
print("derivatives:",derivative(extrema[i]),derivative(extrema[i+1]))
print("")
if derivative(extrema[i])*derivative(extrema[i+1])<=0:
newextrema.append(derivative.gradientDescent(extrema[i],extrema[i+1]))
print("newextrema:",newextrema)
print("")
print("")
oldextrema=newextrema[:]
return newextrema
new_extrema.append(derivative.gradientDescent(extrema[i],extrema[i+1]))
old_extrema=new_extrema[:]
return new_extrema
def gradientDescent(self,a,b,precision=10e-10):
"""Return a int value x between a and b for which the polynomial canceled itself."""
print("descent",self(a),self(b))
if (self(a)>0 and self(b)>0) or (self(a)<0 and self(b)<0):
def gradientDescent(self,xa,xb,precision=10e-10):
"""Return a float value x between a and b for which the polynomial canceled itself."""
"""Does that based on theoreme of intermediate value with dichotomy."""
if self(xa)*self(xb)>0:
raise Exception("The polynomial cannot cancel itself within this interval.")
return None
if a>b:
c=a
a=b
b=c
a=min(xa,xb)
b=max(xa,xb)
x=(a+b)/2
while abs(self(x))>precision:
print("descending:",x,self(x))
if self(x)>0:
if self(x)*self(b)>0:
b=x
if self(x)<0:
if self(x)*self(a)>0:
a=x
x=(a+b)/2
return x
@@ -271,21 +254,21 @@ class Polynomial:
"""Return a string of the decomposition in simple elements of the polynomial."""
pass
def show(self,zone=[-5,5],precision=0.1):
"""Show the polynomial using matplotlib."""
Grapher([self])()
"""
def show(self):
"""Show the polynomial with grapher."""
Grapher([self])() #Instance Grapher only takes the list of the functions in parameter and can be called to display them.
def matplotlibShow(self,zone=[-5,5],precision=0.1):
"""Show the polynomial with matplotlib using optional zone and precision."""
z,Z=zone
X=list([precision*x for x in range(int(z/precision),int(Z/precision))])
Y=list([self(x) for x in X])
plt.plot(X,Y,label="Polynomial")
plt.show()
print("executed")
"""
if __name__ == "__main__":
#suite_random = [random.randint(0,10) for i in range(10)] #Create polynome as big as needed.
#X=Polynomial(suite_random)
suite1 = [3,2,4,5,1]
suite2 = [1,4,1]
suite3 = [4,5]
@@ -302,6 +285,6 @@ if __name__ == "__main__":
print("Unit polynomial of C =",C.unit())
print("HCF (PGCD en francais) of A and B (written A^B) =",A^B)
print("LCM (PPCM en francais) of A and B (written A|B) =",A|B)
#print(A.gradientDescent(-10,10))
print(A.roots())
print("Roots of A:",A.roots())
print("Show A on screen:")
A.show()
Teletype/matrices.py
+1 -2
View File
@@ -8,7 +8,6 @@ from copy import deepcopy
def pgcd(a,b):
t = b
b = a % b
if b == 0:
return t
else:
@@ -71,7 +70,7 @@ def pgcdl(l):
if __name__=="__main__":
c=5 #taille de la matrice carre de depart
c=6 #taille de la matrice carre de depart
a=np.array([[random.randint(0,10) for i in range(c)] for j in range(c)])
print(a)
b=triangular(a)
Teletype/mymaths/__pycache__/infinity.cpython-36.pyc
BIN
View File
Binary file not shown.
Teletype/mymaths/infinity.py
-2
View File
@@ -42,7 +42,6 @@ class Infinity:
def __mul__(self,other):
if other==0:
raise Exception("Undetermined")
return None
else:
if sign(other)!=sign(self):
return Infinity(0)
@@ -51,7 +50,6 @@ class Infinity:
def __truediv__(self,other):
if type(other)==Infinity:
raise Exception("Undetermined")
return None
else:
if sign(other)!=sign(self):
return Infinity(0)