In [1]:
%matplotlib inline
import matplotlib.pyplot as plt # side-stepping mpl backend
import matplotlib.gridspec as gridspec # subplots
import plotly.plotly as py
from plotly.graph_objs import *
import plotly.tools as tls
# Make a legend for specific lines.
import matplotlib.pyplot as plt
import numpy as np
from numpy import *
from sage.all import *
from sage.plot.line import Line
A = RR['r']
r = A.gen()
var('x')
A
Out[1]:
In [99]:
from operator import truediv
from fractions import Fraction
class NombreFlou :
"""Cette classe permet de créer et de manipuler des nombres flous trapézoïdaux"""
def __init__(self, leftMode, rightMode, leftSpread, rightSpread, leftType, rightType) :
"""Constructeur de NombreFlouTrap.
leftMode : la borne gauche du noyau du nombre flou
rightMode : la borne droite du noyau du nombre flou
leftSpread : la propagation du nombre flou à gauche du mode
rightSpread : la propagation du nombre flou à droite du mode"""
self.leftMode = leftMode
self.rightMode = rightMode
self.leftSpread=leftSpread
self.rightSpread=rightSpread
self. leftType = leftType
self.rightType = rightType
def __str__(self) :
"""Affiche le nombre flou sous la forme du quadruplet (tuple)
(leftMode, rightMode, leftSpread, rightSpread) et précise sa famille"""
return "({0},{1},{2},{3}), {4} - {5}".format(self.leftMode, self.rightMode, self.leftSpread, self.rightSpread, self.leftType, self.rightType)
def cmp_family(nombreFlou1, nombreFlou2):
if(nombreFlou1.leftType == nombreFlou2.leftType) and (nombreFlou1.rightType == nombreFlou2.rightType):
return "Egales"
if(nombreFlou1.leftType == nombreFlou2.rightType) and (nombreFlou1.rightType == nombreFlou2.leftType):
return "Symetriques"
else:
return "Incompatibles"
def oppose(self) :
"""Renvoie l'opposé du nombre flou passé en entrée"""
return NombreFlou(-self.rightMode,\
-self.leftMode,\
self.rightSpread,\
self.leftSpread,\
self.rightType,\
self.leftType)
def __add__(self, autre) :
"""Surcharge de +"""
if cmp_family(self,autre)!= "Egales":
print("L'opération ne peut aboutir car les familles des opérandes sont différentes")
else :
return NombreFlou(self.leftMode + autre.leftMode,\
self.rightMode + autre.rightMode,\
self.leftSpread + autre.leftSpread,\
self.rightSpread + autre.rightSpread,\
self.leftType,\
self.rightType)
def __sub__(self,autre) :
"""Surcharge de -"""
if cmp_family(self,autre)!= "Symetriques":
print("L'opération ne peut aboutir car les familles des opérandes ne sont pas symétriques")
else :
oppose=autre.oppose()
return self + oppose
def __mul__(self, autre) :
"""Surcharge de *"""
if cmp_family(self,autre)!= "Egales":
print("L'opération ne peut aboutir car les familles des opérandes sont différentes")
else :
return NombreFlou(min(self.leftMode*autre.leftMode,self.leftMode*autre.rightMode,self.rightMode*autre.leftMode,\
self.rightMode*autre.rightMode),max(self.leftMode*autre.leftMode,self.leftMode*autre.rightMode,\
self.rightMode*autre.leftMode, self.rightMode*autre.rightMode),\
(abs(self.leftMode) * autre.leftSpread) + (abs(autre.leftMode) * self.leftSpread),\
(abs(self.rightMode) * autre.rightSpread) + (abs(autre.rightMode) * self.rightSpread),\
self.leftType,\
self.rightType)
def inverse(self) :
"""Renvoie l'inverse du nombre flou passé en entrée"""
if(self.leftMode.denominator**2 == self.leftSpread.denominator) :
inverse = NombreFlou(min(Fraction(1,self.leftMode),Fraction(1,self.rightMode)),\
max(Fraction(1,self.leftMode),Fraction(1,self.rightMode)),\
Fraction(self.rightSpread, (self.rightMode**2)),\
Fraction(self.leftSpread , (self.leftMode**2)),\
self.rightType,\
self.leftType)
else :
inverse = NombreFlou(min(Fraction(1,self.leftMode),Fraction(1,self.rightMode)),\
max(Fraction(1,self.leftMode),Fraction(1,self.rightMode)),\
Fraction(self.rightSpread, (self.leftMode**2)),\
Fraction(self.leftSpread , (self.rightMode**2)),\
self.rightType,\
self.leftType)
if isinstance(inverse.leftMode,Fraction) * (inverse.leftMode.denominator == 1):
inverse.leftMode = inverse.leftMode.numerator
if isinstance(inverse.rightMode,Fraction) * (inverse.rightMode.denominator == 1):
inverse.rightMode = inverse.rightMode.numerator
if isinstance(inverse.leftSpread,Fraction) * (inverse.leftSpread.denominator == 1):
inverse.leftSpread = inverse.leftSpread.numerator
if isinstance(inverse.rightSpread,Fraction) * (inverse.rightSpread.denominator == 1):
inverse.rightSpread = inverse.rightSpread.numerator
return inverse
def __div__(self,autre) :
"""Surcharge de /"""
if cmp_family(self,autre)!= "Symétriques":
print("L'opération ne peut aboutir car les familles des opérandes ne sont pas symétriques")
else :
inverse = autre.inverse()
return self * inverse
def maxi(cls,nombreFlou1,nombreFlou2) :
"""Renvoie le max de deux nombres flous"""
if nombreFlou2.rightMode > nombreFlou1.rightMode :
print("etape 1")
return nombreFlou2
elif nombreFlou1.rightMode == nombreFlou2.rightMode :
print("etape 2")
return NombreFlou(max(nombreFlou1.leftMode , nombreFlou2.leftMode),\
max(nombreFlou1.rightMode , nombreFlou2.rightMode),\
min(nombreFlou1.leftSpread , nombreFlou2.leftSpread),\
max(nombreFlou1.rightSpread , nombreFlou2.rightSpread),\
self.leftType,\
self.rightType)
else :
print("etape 3")
return nombreFlou1
maxi = classmethod(maxi)
def mini(cls,nombreFlou1,nombreFlou2) :
"""Renvoie le min de deux nombres flous"""
if nombreFlou2.leftMode > nombreFlou1.leftMode :
return nombreFlou1
elif nombreFlou1.leftMode == nombreFlou2.leftMode :
return NombreFlou(min(nombreFlou1.leftMode , nombreFlou2.leftMode),\
min(nombreFlou1.rightMode , nombreFlou2.rightMode),\
max(nombreFlou1.leftSpread , nombreFlou2.leftSpread),\
min(nombreFlou1.rightSpread , nombreFlou2.rightSpread),\
self.leftType,\
self.rightType)
else :
return nombreFlou2
mini = classmethod(mini)
def equivalent(self, autre):
"""Surcharge de =="""
if (self.leftMode == autre.leftMode) * (self.rightMode == autre.rightMode) * (self.leftSpread == autre.leftSpread) * (self.rightSpread == autre.rightSpread)\
* (self.leftType == autre.leftType) * (self.rightType == autre.rightType):
return True
else:
return False
def plusgrand(self,autre) :
"""Surcharge de > comme ordre partiel"""
maximum = NombreFlou.maxi(self,autre)
if(maximum == self):
return True
elif(maximum == autre):
return False
else:
print("Ces deux arguments ne sont pas comparables pour cette relation d'ordre partiel")
def pluspetit(self,autre) :
"""Surcharge de > comme ordre partiel"""
minimum = NombreFlou.mini(self,autre)
if(minimum == self):
return True
elif(minimum == autre):
return False
else:
print("Ces deux arguments ne sont pas comparables pour cette relation d'ordre partiel")
def trace(self):
if self.leftType == "Lin":
g = np.arange(self.leftMode-self.leftSpread, self.leftMode,0.001)
lg = plt.plot(g, ((g-self.leftMode)/self.leftSpread) +1)
elif self.leftType == "Quad" :
g1 = np.arange(self.leftMode-self.leftSpread, self.leftMode-(self.leftSpread/2),0.001)
g2 = np.arange(self.leftMode-(self.leftSpread/2), self.leftMode,0.001)
lg1 = plt.plot(g1, 2 * ( (g1- self.leftMode + self.leftSpread) / (self.leftSpread))**2)
lg2 = plt.plot(g2, 1 - 2 * ( (g2- self.leftMode) / (self.leftSpread))**2)
if self.rightType == "Lin" :
d = np.arange(self.rightMode, self.rightMode + self.rightSpread,0.001)
ld = plt.plot(d, ((-d+self.rightMode)/self.rightSpread) +1)
elif self.rightType == "Quad" :
d1 = np.arange(self.rightMode, self.rightMode+(self.rightSpread/2),0.001)
d2 = np.arange(self.rightMode+(self.rightSpread/2), self.rightMode+self.rightSpread,0.001)
ld1 = plt.plot(d1, 1 - 2 * ( (d1 - self.rightMode) / (self.rightSpread))**2)
ld2 = plt.plot(d2, 2 * ( ( d2 - self.rightMode - self.rightSpread) / (self.rightSpread))**2)
def trace2(self):
if self.leftType == "Lin" :
G = plot((x -self.leftMode)/self.leftSpread+1,(x,self.leftMode - self.leftSpread,self.leftMode),color='red')
elif self.leftType == "Exp" :
G = plot(1 - exp((-(x - self.leftMode + self.leftSpread)**2)/self.leftSpread),(x,self.leftMode - self.leftSpread,self.leftMode),color='red')
elif self.leftType == "Quad" :
G1 = plot(2 * ( (x- self.leftMode + self.leftSpread) / (self.leftSpread))**2,(x,self.leftMode-self.leftSpread, self.leftMode-(self.leftSpread/2)),color='red')
G2 = plot(1 - 2 * ( (x- self.leftMode) / (self.leftSpread))**2,(x,self.leftMode-(self.leftSpread/2), self.leftMode),color='red')
G=G1+G2
if self.rightType == "Lin" :
D = plot((self.rightMode - x)/self.rightSpread+1,(x,self.rightMode,self.rightMode + self.rightSpread),color='green')
elif self.rightType == "Exp" :
D = plot( 1 - exp((-( -x + self.rightMode + self.rightSpread)**2)/self.rightSpread),(x,self.rightMode,self.rightMode + self.rightSpread),color='green')
elif self.rightType == "Quad":
D1 = plot( 1 - 2 * ( (x - self.rightMode) / (self.rightSpread))**2,(x,self.rightMode, self.rightMode+(self.rightSpread/2)),color='green')
D2 = plot(2 * ( ( x - self.rightMode - self.rightSpread) / (self.rightSpread))**2,(x,self.rightMode+(self.rightSpread/2), self.rightMode+self.rightSpread),color='green')
D=D1+D2
M = plot(1,(x,self.leftMode,self.rightMode))
return (G+M+D)
def forme_parametrique(self):
if self.leftType == "Lin" :
bas = self.leftMode + self.leftSpread * (r-1)
elif self.leftType == "Exp" :
bas = self.leftMode - self.leftSpread + sqrt(-self.leftSpread*log(1-r))
elif self.leftType == "Quad" :
bas1 = self.leftMode + self.leftSpread * (sqrt(r/2)-1)
bas2 = self.leftMode - self.leftSpread * sqrt((-r+1)/2)
print(bas2.parent())
bas = array( [bas1,bas2] )
if self.rightType == "Lin" :
haut = self.rightMode + self.rightSpread * (1-r)
elif self.rightType == "Exp" :
haut = self.rightMode + self.rightSpread - sqrt(-self.rightSpread*log(1-r))
elif self.rightType == "Quad" :
haut1 = -(-self.rightMode - self.rightSpread * sqrt((-r+1)/2))
haut2 = -(-self.rightMode + self.rightSpread * (sqrt(r/2)-1) )
haut = array( [haut1,haut2] )
return NombreFlouPM(bas, haut, self.leftType + " - " + self.rightType)
In [ ]:
In [100]:
class NombreFlouRed(NombreFlou):
"""Cette classe permet de créer et de manipuler des nombres flous triangulaires.
Elle hérite de la classe des nombres flous trapézoïdaux"""
def __init__(self, mode, leftSpread, rightSpread, leftType, rightType) :
"""Constructeur de NombreFlou.
leftMode : la borne gauche du noyau du nombre flou
rightMode : la borne droite du noyau du nombre flou
leftSpread : la propagation du nombre flou à gauche du mode
rightSpread : la propagation du nombre flou à droite du mode"""
self.leftMode = self.rightMode = mode
self.leftSpread=leftSpread
self.rightSpread=rightSpread
self.leftType = leftType
self.rightType = rightType
def __str__(self) :
"""Affiche le nombre flou sous la forme du triplet (tuple)
(mode, leftSpread, rightSpread) et précise sa famille"""
return "({0},{1},{2}), {3} - {4}".format(self.leftMode, self.leftSpread, self.rightSpread, self.leftType, self.rightType)
def oppose(self) :
"""Renvoie l'opposé du nombre flou passé en entrée"""
return NombreFlouRed(-self.leftMode,\
self.rightSpread,\
self.leftSpread)
def __add__(self, autre) :
"""Surcharge de +"""
if self.__class__.__name__ != autre.__class__.__name__:
print("L'opération ne peut aboutir car les familles des opérandes sont différentes")
else :
return NombreFlouRed(self.leftMode + autre.leftMode,\
self.leftSpread + autre.leftSpread,\
self.rightSpread + autre.rightSpread)
def __mul__(self, autre) :
"""Surcharge de *"""
if self.__class__.__name__ != autre.__class__.__name__:
print("L'opération ne peut aboutir car les familles des opérandes sont différentes")
else :
return NombreFlouRed(self.leftMode*autre.leftMode,\
(abs(self.leftMode) * autre.leftSpread) + (abs(autre.leftMode) * self.leftSpread),\
(abs(self.rightMode) * autre.rightSpread) + (abs(autre.rightMode) * self.rightSpread))
def inverse(self) :
"""Renvoie l'inverse du nombre flou passé en entrée"""
inverse = NombreFlouRed(Fraction(1,self.leftMode), Fraction(self.rightSpread,(self.rightMode**2)),\
Fraction(self.leftSpread , (self.leftMode**2)))
if isinstance(inverse.leftMode,Fraction) * (inverse.leftMode.denominator == 1):
inverse.leftMode = inverse.leftMode.numerator
if isinstance(inverse.rightMode,Fraction) * (inverse.rightMode.denominator == 1):
inverse.rightMode = inverse.rightMode.numerator
if isinstance(inverse.leftSpread,Fraction) * (inverse.leftSpread.denominator == 1):
inverse.leftSpread = inverse.leftSpread.numerator
if isinstance(inverse.rightSpread,Fraction) * (inverse.rightSpread.denominator == 1):
inverse.rightSpread = inverse.rightSpread.numerator
return inverse
In [153]:
class NombreFlouPM :
"""Cette classe permet de créer et de manipuler des nombres flous sous la forme paramétrique"""
def __init__(self, bas, haut, famille, A=None) :
"""Constructeur de NombreFlou.
bas : le polynôme qui donne pour chaque r dans [0,1] la borne gauche de la coupe-r correspondante
haut : le polynôme qui donne pour chaque r dans [0,1] la borne droite de la coupe-r correspondante
famille : la famille du nombre flou
para : le générateur de l'anneau donné en paramètre (ou par défaut le générateur de l'anneau de polynômes à une variable sur le corps de rationnels)
"""
if A is None:
self.bas=bas
self.haut=haut
self.famille = famille
self.para = r
else :
self.bas = bas
self.haut = haut
self.famille = famille
self.para = A.gen()
def __str__(self) :
"""Affiche le nombre flou sous la forme d'une liste
[bas, haut], famille"""
return "[{0},{1}] , {2}".format(self.bas, self.haut, self.famille)
def oppose(self):
return NombreFlouPM( - self.haut, - self.bas, self.famille, self.para.parent())
def __add__(self, autre):
"""Surcharge de +"""
if self.famille != autre.famille :
print("L'opération ne peut aboutir car les familles des opérandes sont différentes")
else :
return NombreFlouPM(self.bas + autre.bas, self.haut + autre.haut, self.famille, self.para.parent())
def __sub__(self, autre):
"""Surcharge de -"""
return NombreFlouPM(self.bas - autre.haut, self.haut - autre.bas, self.famille, self.para.parent())
def __mul__(self, autre):
"""Surcharge de *"""
if self.famille != autre.famille :
print("L'opération ne peut aboutir car les familles des opérandes sont différentes")
else :
# Premier cas : cas d'un produit par un scalaire
if isinstance(autre,float) :
if(autre < 0):
return NombreFlouPM(autre * self.haut, autre * self.bas, self.famille, self.para.parent())
else :
return NombreFlouPM(autre * self.bas, autre * self.haut, self.famille, self.para.parent())
# Second cas : cas d'un produit par un autre nombre flou
else:
return NombreFlouPM( min(self.bas * autre.bas,self.bas * autre.haut,self.haut * autre.bas,self.haut * autre.haut) ,\
max(self.bas * autre.bas,self.bas * autre.haut,self.haut * autre.bas,self.haut * autre.haut),\
self.famille, self.para.parent())
def __div__(self, autre):
"""Surcharge de /"""
if autre.bas(0) < 0 < autre.haut(0):
return NombreFlouPM( min(self.bas / autre.bas,self.bas / autre.haut,self.haut / autre.bas,self.haut / autre.haut) ,\
max(self.bas / autre.bas,self.bas / autre.haut,self.haut / autre.bas,self.haut / autre.haut),\
self.famille, self.para.parent())
def get_types(self):
tiret = False
leftType = ''
rightType = ''
for lettre in self.famille :
if lettre == '-':
tiret = True
elif tiret == False:
leftType += lettre
else :
rightType += lettre
leftType = leftType.strip()
leftType = leftType.capitalize()
rightType = rightType.strip()
rightType = rightType.capitalize()
return leftType, rightType
def forme_tuple(cls,nombreFlouPM):
leftMode = nombreFlouPM.bas(1)
rightMode = nombreFlouPM.haut(1)
leftSpread = (-1) * (nombreFlouPM.bas(0) - leftMode)
rightSpread = (nombreFlouPM.haut(0) - rightMode)
if(nombreFlouPM.famille == 'NombreFlouTrap') :
return NombreFlouTrap(leftMode, rightMode, leftSpread, rightSpread)
if(nombreFlouPM.famille == 'NombreFlouTri') :
return NombreFlouTri(leftMode, leftSpread, rightSpread)
forme_tuple = classmethod(forme_tuple)
def ff(self):
r=self.para
Bas=self.bas
Haut=self.haut
return (Bas(r) + Haut(r) + Bas(1) + Haut(1))*r
#return (self.bas(r) + self.haut(r) + self.bas(1) + self.haut(1))*r
def mag2(self):
return integral(self.ff(),r)
def mag(self):
r=self.para
"""Calcule la magnitude du nombre flou"""
f=(self.bas(r) + self.haut(r) + self.bas(1) + self.haut(1))*r
integrale = integral(f(r),r)
res = truediv(integrale(1) - integrale(0),2)
return res
def momag(self):
"""Calcule la momagnitude du nombre flou"""
f=(self.bas(r) - self.haut(r) + self.bas(1) - self.haut(1))
integrale = integral(f(r),r)
res = truediv(integrale(1) - integrale(0),2)
return res
def R(self, autre):
"""À partir de 2 nombres flous sous forme paramétrique A et B, calcule les quantités
R(A,lambda) = Mag(A) + lambda * Momag(A) et R(B,lambda) = Mag(B) + lambda * Momag(B),
où lambda = 0 si Mag(A) != Mag(B)
1 si Mag(A) == Mag(B) et z >= 0
-1 si Mag(A) == Mag(B) et z < 0
avec z = (A.bas(1) + A.haut(1))/2
et renvoie ces deux valeurs dans un tuple"""
if (self.mag()!= autre.mag()) :
return (self.mag(),autre.mag())
else:
z = truediv(self.bas(1) + self.haut(1),2)
if(z >=0):
return (self.mag() + self.momag(), autre.mag() + autre.momag())
else :
return (self.mag() - self.momag(), autre.mag() - autre.momag())
def __eq__(self, autre):
"""Surcharge de =="""
if(self.R(autre)[0] == self.R(autre)[1]) :
return True
else :
return False
def __ne__(self, autre):
"""Surcharge de !="""
if(self.R(autre)[0] != self.R(autre)[1]) :
return True
else :
return False
def __lt__(self, autre):
"""Surcharge de <"""
if(self.R(autre)[0] < self.R(autre)[1]) :
return True
else :
return False
def __le__(self, autre):
"""Surcharge de <="""
if(self.R(autre)[0] <= self.R(autre)[1]) :
return True
else :
return False
def __gt__(self, autre):
"""Surcharge de >"""
if(self.R(autre)[0] > self.R(autre)[1]) :
return True
else :
return False
def __ge__(self, autre):
"""Surcharge de >="""
if(self.R(autre)[0] >= self.R(autre)[1]) :
return True
else :
return False
def maximum(cls,nombreFlou1,nombreFlou2) :
"""Renvoie le max de deux nombres flous pour l'ordre total"""
if nombreFlou1 == nombreFlou2 :
print("Les deux nombres flous sont équivalents, renvoi du premier passé en paramètre")
return nombreFlou1
elif nombreFlou1 > nombreFlou2 :
return nombreFlou1
else :
return nombreFlou2
maximum = classmethod(maximum)
def minimum(cls,nombreFlou1,nombreFlou2) :
"""Renvoie le min de deux nombres flous pour l'ordre total"""
if nombreFlou1 == nombreFlou2 :
print("Les deux nombres flous sont équivalents, renvoi du premier passé en paramètre")
return nombreFlou1
elif nombreFlou1 < nombreFlou2 :
return nombreFlou1
else :
return nombreFlou2
minimum = classmethod(minimum)
def maxi(cls,nombreFlou1,nombreFlou2) :
"""Renvoie le max de deux nombres flous pour l'ordre partiel"""
if truediv(nombreFlou1.haut(1)+nombreFlou1.bas(1),2) == truediv(nombreFlou2.haut(1)+nombreFlou2.bas(1),2):
if nombreFlou1.bas(0) >= nombreFlou2.bas(0):
bas = nombreFlou1.bas
else :
bas = nombreFlou2.bas
if nombreFlou1.haut(0) >= nombreFlou2.haut(0):
haut = nombreFlou1.haut
else :
haut = nombreFlou2.haut
return NombreFlouPM(bas,haut)
elif truediv(nombreFlou1.haut(1)+nombreFlou1.bas(1),2) > truediv(nombreFlou2.haut(1)+nombreFlou2.bas(1),2):
return nombreFlou1
else :
return nombreFlou2
maxi = classmethod(maxi)
def mini(csl,nombreFlou1,nombreFlou2) :
"""Renvoie le min de deux nombres flous pour l'ordre partiel"""
if truediv(nombreFlou1.haut(1)+nombreFlou1.bas(1),2) == truediv(nombreFlou2.haut(1)+nombreFlou2.bas(1),2):
if nombreFlou1.bas(0) < nombreFlou2.bas(0):
bas = nombreFlou1.bas
else :
bas = nombreFlou2.bas
if nombreFlou1.haut(0) < nombreFlou2.haut(0):
haut = nombreFlou1.haut
else :
haut = nombreFlou2.haut
return NombreFlouPM(bas,haut)
elif truediv(nombreFlou1.haut(1)+nombreFlou1.bas(1),2) < truediv(nombreFlou2.haut(1)+nombreFlou2.bas(1),2):
return nombreFlou1
else :
return nombreFlou2
mini = classmethod(mini)
def equivalent(self, autre):
"""Surcharge de =="""
if (self.bas == autre.bas) * (self.haut == autre.haut) :
return True
else:
return False
def plusgrand(self,autre) :
"""Surcharge de > comme ordre partiel"""
maximum = NombreFlouPM.maxi(self,autre)
if(maximum == self):
return True
elif(maximum == autre):
return False
else:
print("Ces deux arguments ne sont pas comparables pour cette relation d'ordre partiel")
def pluspetit(self,autre) :
"""Surcharge de > comme ordre partiel"""
minimum = NombreFlouPM.mini(self,autre)
if(minimum == self):
return True
elif(minimum == autre):
return False
else:
print("Ces deux arguments ne sont pas comparables pour cette relation d'ordre partiel")
def trace(self):
t = np.arange(0.0, 1.0,0.001)
if self.get_types()[0] == "Quad":
bas1=self.bas[0]
bas2=self.bas[1]
print(bas2)
lg1 = plt.plot(t, bas1(t))
lg2 = plt.plot(t, bas2(t))
else:
lg = plt.plot(t, self.bas(t))
if self.get_types()[1] == "Quad":
ld1 = plt.plot(t, self.haut[0](t))
ld2 = plt.plot(t, self.haut[1](t))
else:
ld = plt.plot(t, self.haut(t))
def trace2(self):
if self.get_types()[0] == "Quad":
G1 = plot(self.bas[0](x),(x,0,0.5),color='red')
G2 = plot(self.bas[1](x),(x,0.5,1),color='red')
print(self.bas[0])
print(self.bas[1])
G=G1+G2
leftLim = self.bas[1](1)
else:
G = plot(self.bas(x),(x,0,1),color='red')
leftLim = self.bas(1)
if self.get_types()[1] == "Quad":
D1 = plot(self.haut[0](x),(x,0.5,1),color='green')
D2 = plot(self.haut[1](x),(x,0,0.5),color='green')
D=D1+D2
rightLim = self.haut[0](1)
else:
D = plot(self.haut(x),(x,0,1),color='green')
rightLim = self.haut(1)
M = line([(1,rightLim), (1,leftLim)])
return (G+M+D)
In [154]:
self=NombreFlou(4,6,9,8,"Exp","Exp")
self2=NombreFlou(4,6,9,8,"Quad","Quad")
self3=NombreFlou(4,6,9,8,"Lin","Lin")
J=self.trace2()+self2.trace2()+self3.trace2()
J.save('filename.png')
In [155]:
nbPM=self.forme_parametrique()
nbPM2=self2.forme_parametrique()
nbPM3=self3.forme_parametrique()
Y=nbPM2.trace2()
Y.save('filename2.png')
In [134]:
print(nbPM)
In [111]:
nb = NombreFlou(1,3,4,2,"Lin","Quad")
print(nb), nb.trace()
In [ ]:
nbPM = nb.forme_parametrique()
nbPM.bas
In [ ]:
J=nbPM.trace2()
J.save('filename.png')
In [ ]:
self = NombreFlouRed(3,2,2,"Lin","Quad")
var('x')
print(2 * ( (x- self.leftMode + self.leftSpread) / (self.leftSpread))**2)
print(1 - 2 * ( (x- self.leftMode) / (self.leftSpread))**2)
In [152]:
Out[152]:
In [ ]:
f.parent()
In [ ]:
r.parent()
In [ ]:
sqrt(r).parent()
In [ ]:
var('x')
assume(r>0); bool(sqrt(r**2)==r)
In [ ]:
r.parent()
In [ ]:
Expression
In [ ]:
SR
In [ ]:
sqrt(x).parent()
In [ ]:
sqrt(r).parent()
r.parent()
In [ ]:
B = RR[sqrt(r)]
r = B.gen()
B
In [ ]:
plot(nbPM.bas[0](x),(x,0,1))
In [ ]:
open filename.png
In [ ]:
G=nbPM.trace2()
show(1)
In [ ]:
H=plot(nbPM.bas[0](x),(x,0,1))
H.plot()
In [156]:
A = PolynomialRing(R,n)
In [ ]:
A = PolynomialRing(QQ, 'x', 10,order ='invlex')
var=A.gens()
A
var
n = len(var)
n
In [ ]:
y=var[0]
x=var[1]
y<x
In [ ]:
F = [x*y+x+y, x*(y**2)+x+y,x,y,y**22,x**2]
len(F)
G=[]
len(G)
F.sort()
F
In [ ]:
F[0]
In [ ]:
def basicSet(F):
B = []
while len(F) != 0 :
B = B
return 0
In [ ]:
basicSet(F)
In [ ]:
F.sort?
In [ ]: