%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

Univariate Polynomial Ring in r over Real Field with 53 bits of precision

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)

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

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)

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')

nbPM=self.forme_parametrique()
nbPM2=self2.forme_parametrique()
nbPM3=self3.forme_parametrique()
Y=nbPM2.trace2()
Y.save('filename2.png')

Symbolic Ring
6.36396103067893*sqrt(r) - 5
-9*sqrt(-0.500000000000000*r + 0.500000000000000) + 4

/projects/sage/sage-6.10/local/lib/python2.7/site-packages/ipykernel/__main__.py:4: DeprecationWarning:

Substitution using function-call syntax and unnamed arguments is deprecated and will be removed from a future release of Sage; you can use named arguments instead, like EXPR(x=..., y=...)
See http://trac.sagemath.org/5930 for details.

print(nbPM)

[3*sqrt(-log(-1.00000000000000*r + 1.00000000000000)) - 5,-2*sqrt(2)*sqrt(-log(-1.00000000000000*r + 1.00000000000000)) + 14] , Exp - Exp

nb = NombreFlou(1,3,4,2,"Lin","Quad")
print(nb), nb.trace()

(1,3,4,2), Lin - Quad None

nbPM = nb.forme_parametrique()
nbPM.bas

J=nbPM.trace2()
J.save('filename.png')

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)

6.15076656653791

f.parent()

r.parent()

sqrt(r).parent()

var('x')
assume(r>0); bool(sqrt(r**2)==r)

r.parent()

Expression

SR

sqrt(x).parent()

sqrt(r).parent()
r.parent()

B = RR[sqrt(r)]
r = B.gen()
B

plot(nbPM.bas[0](x),(x,0,1))

open filename.png

G=nbPM.trace2()
show(1)

H=plot(nbPM.bas[0](x),(x,0,1))
H.plot()

A = PolynomialRing(R,n)


TypeErrorTraceback (most recent call last)
<ipython-input-156-56030b93e09d> in <module>()
----> 1 A = PolynomialRing(R,n)

/projects/sage/sage-6.10/local/lib/python2.7/site-packages/sage/rings/polynomial/polynomial_ring_constructor.pyc in PolynomialRing(base_ring, arg1, arg2, sparse, order, names, name, var_array, implementation)
    432         arg2 = repr(arg2)
    433 
--> 434     if not m.ring.is_Ring(base_ring):
    435         raise TypeError('base_ring must be a ring')
    436 

/projects/sage/sage-6.10/src/sage/rings/ring.pyx in sage.rings.ring.is_Ring (/projects/sage/sage-6.10/src/build/cythonized/sage/rings/ring.c:19595)()
   2464     # TODO: use the idiom `x in _Rings` as soon as all rings will be
   2465     # in the category Rings()
-> 2466     return isinstance(x, Ring) or x in _Rings

/projects/sage/sage-6.10/src/sage/categories/category_singleton.pyx in sage.categories.category_singleton.Category_contains_method_by_parent_class.__call__ (/projects/sage/sage-6.10/src/build/cythonized/sage/categories/category_singleton.c:1508)()
     80         except TypeError: # this is for objects that aren't CategoryObjects
     81             try:
---> 82                 return PyType_IsSubtype(<type>(x.category().parent_class), self._parent_class_of_category)
     83             except AttributeError:
     84                 return False

TypeError: descriptor 'category' of 'sage.structure.parent.Parent' object needs an argument

A = PolynomialRing(QQ, 'x', 10,order ='invlex')
var=A.gens()
A
var
n = len(var)
n

y=var[0]
x=var[1]
y<x

F = [x*y+x+y, x*(y**2)+x+y,x,y,y**22,x**2]
len(F)
G=[]
len(G)
F.sort()
F

F[0]

def basicSet(F):
    
    B = []
    
    while len(F) != 0 :
        
        B = B
    
    return 0

basicSet(F)

F.sort?