#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 17 19:11:52 2022
@author: jlebovits
"""
from __future__ import division
import os
import random
current_dir = os.getcwd() # Répertoire courant
#parent_dire=os.chdir('..') # On remonte d'un répertoire
#parent_dir= os.getcwd() # Répertoire parent du répertoire courant
#path_1=parent_dir+"/"+'Mes_fctions'#+'Mes_fctions_deterministes'
import sys
#sys.path.append(path_1)
from copy import deepcopy
#import Mes_fctions_generalistes
#from Mes_fctions_generalistes import *
#os.chdir(current_dir) # On revient dans le répertoire de départ i.e. dans current_dir
#from src.scripts.Mes_fctions.Mes_fctions_deterministes import *
#from src.scripts.Mes_fctions.Mes_fctions_generalistes import *
import src.scripts.Mes_fctions.Mes_fctions_deterministes
from src.scripts.Mes_fctions.Mes_fctions_deterministes import *
import src.scripts.Mes_fctions.Mes_fctions_generalistes
from src.scripts.Mes_fctions.Mes_fctions_generalistes import *
#print('toto')
# X = Symbol('X')
# Eerevfdvdf = Poly_with_random_coef_v2('X',2,0)
[docs]
def ecriture_Latex() :
chaine = "ecritureLatex Ok"
return chaine
[docs]
def EcrituredsAlignetoileLatex_one_per_line(L_nom, L):
"""Retourne en TeX, dans un align, les éléments de la liste L,
avec, comme noms les éléments de la liste L_nom,
sous le format, L_nom[i] &= L[i] \\, pour chaque ligne )
"""
q = 1
end_line_sep = ""
doublebackslashlatex="\\"+"\\"
n=len(L)
if n < 1:
raise "La liste est vide"
else:
r = 0
phrase_de_debut ="\\"'begin{align*}\n'
phrase_de_fin="\\"'end{align*}\n'#"\\"'\n'+'end{align*}\n'
phrase_milieu=[None] * n
for i in range(0,n-1,1):
phrase_milieu[i] =L_nom[i]+'&'+'='+str(L[i])+ end_line_sep
phrase_milieu[n-1] =L_nom[n-1]+'&'+'='+str(L[n-1])+'.'
# A ce stade la liste phrase_milieu contient les n cellules élémentaires
# qu'il faudra regrouper par paquet de q
###########################################################################
# if r == 0: #i.e. le reste de la div euclidienne est nul
Lignes=[None] * n
for t in range(0,n,1):
d=""
for j in range(t,t+1,1):
d=d+phrase_milieu[j] #"\\"'\n'
Lignes[t]=d
Lignes[t]=d+doublebackslashlatex
Lignes[n-1]=d # if t != s-1:
longL=len(Lignes)
phrase_du_milieu=""
for a in range(0,longL,1):
phrase_du_milieu=phrase_du_milieu+Lignes[a]+" "'\n'
phrase = phrase_de_debut + phrase_du_milieu + phrase_de_fin
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
phrase=phrase.replace("&&", "& &")
#print(phrase, '\n')
return phrase
##########################################################################################################################################################################################
##
## Début des essais ##
##########################################################################################################################################################################################
# n=10
# #n=3
# La=[None] * n
# for a in range(0,n,1):
# b='E'+"_"+'{'+str(a+1)+'}'
# La[a]=b
# print('La=',La,'\n')
# Lb = range(1,n+1,1)
# print('Lb=',Lb,'\n')
# for b in range(0,n,1):
# print('Lb[b]=',Lb[b],'\n')
# print('EcrituredsAlignetoileLatex_one_per_line(La,Lb)= \n')
# EcrituredsAlignetoileLatex_one_per_line(La,Lb)
# print('EcrituredsAlignetoileLatex(La,Lb,5)= \n')
# EcrituredsAlignetoileLatex(La,Lb,5)
# print('EcrituredsAlignetoileLatex(La,Lb,4)= \n')
# EcrituredsAlignetoileLatex(La,Lb,4)
# print('EcrituredsAlignetoileLatex(La,Lb,3)= \n')
# EcrituredsAlignetoileLatex(La,Lb,3)
# print('EcrituredsAlignetoileLatex(La,Lb,2)= \n')
# EcrituredsAlignetoileLatex(La,Lb,2)
# print('EcrituredsAlignetoileLatex(La,Lb,1)= \n')
# EcrituredsAlignetoileLatex(La,Lb,1)
##########################################################################################################################################################################################
##
## Fin des essais ##
##########################################################################################################################################################################################
[docs]
def EcrituredsAlignetoileLatex_bis(L_nom, L,q):
"""Retourne en TeX, dans un align*, les éléments de la liste L,
avec, comme noms les éléments de la liste L_nom,
sous le format, L_nom[i]= L[i], regroupés par paquet de q
à chaque ligne (où q est un entier)
"""
if q ==1:
end_line_sep = ""
else:
end_line_sep = ','
doublebackslashlatex="\\"+"\\"
n=len(L)
if n < 1:
raise "La liste est vide"
else:
s=int(n/q)
r=n-q*s # donc n=sq+r i.e. r est le reste dans la division euclidienne de n par q
phrase_de_debut ="\\"'begin{align*}\n'
phrase_de_fin="\\"'end{align*}\n'#+'end{align*}\n'
phrase_milieu=[None] * n
for i in range(0,n-1,1):
# phrase_milieu[i] ='&'+str(latex(L_nom[i]))+'='+str(latex(L[i]))+',&'
# phrase_milieu[n-1] ='&'+str(latex(L_nom[n-1]))+'='+str(latex(L[n-1]))+'.&'#car
phrase_milieu[i] ='&'+L_nom[i]+'='+str(L[i])+ end_line_sep+'&'
phrase_milieu[n-1] ='&'+L_nom[n-1]+'='+str(L[n-1])+'.&'#car c'est la dernière.
# A ce stade la liste phrase_milieu contient les n cellules élémentaires
# qu'il faudra regrouper par paquet de q
###########################################################################
if r == 0: #i.e. le reste de la div euclidienne est nul
Lignes=[None] * s
for t in range(0,s,1):
d=""
for j in range(t*q,(t+1)*q,1):
d=d+phrase_milieu[j] #"\\"'\n'
Lignes[t]=d
Lignes[t]=d+doublebackslashlatex
Lignes[s-1]=d # if t != s-1:
# A ce stade, la liste Lignes contient exactement s lignes.
#Chacune de ces lignes contient q termes de la liste L
###########################################################################
else: # Donc ici r diff de 0
Lignes=[None] * (s+1)
for t in range(0,s,1):
d=""
for j in range(t*q,(t+1)*q,1):
d=d+phrase_milieu[j] #"\\"'\n'
Lignes[t]=d+doublebackslashlatex
# A ce stade il ne reste à traiter que les derniers termes de la liste (ceux qui seront sur la dernière ligne)
d=""
for j in range(s*q,n,1):
d=d+phrase_milieu[j]
Lignes[s]=d
longL=len(Lignes)
phrase_du_milieu=""
for a in range(0,longL,1):
phrase_du_milieu=phrase_du_milieu+Lignes[a]+" "'\n'
#print(phrase_du_milieu, '\n')
# A ce stade, phrase_du_milieu contient tout le corps
#du align sauf le begin et le end
phrase = phrase_de_debut + phrase_du_milieu + phrase_de_fin
#phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
phrase=phrase.replace("&&", "& &")
#print(phrase, '\n')
return phrase
[docs]
def EcrituredsAlignetoileLatex(L_nom, L,q):
"""Retourne en TeX, dans un align, les éléments de la liste L,
avec, comme noms les éléments de la liste L_nom,
sous le format, L_nom[i]= L[i], regroupés par paquet de q
à chaque ligne (où q est un entier)
"""
if q ==1:
end_line_sep = ""
else:
end_line_sep = ','
doublebackslashlatex="\\"+"\\"
n=len(L)
if n < 1:
raise "La liste est vide"
else:
s=int(n/q)
r=n-q*s # donc n=sq+r i.e. r est le reste dans la division euclidienne de n par q
#phrase_de_debut ="\\"'begin{align*}\n'
#phrase_de_fin="\\"'end{align*}\n'#"\\"'\n'+'end{align*}\n'
phrase_de_debut ="\\"'begin{equation*}\n'+"\\"'begin{align*}\n'
phrase_de_fin="\\"'end{align*}\n'+"\\"'end{equation*}\n'#+'end{align*}\n'
phrase_milieu=[None] * n
for i in range(0,n-1,1):
# phrase_milieu[i] ='&'+str(latex(L_nom[i]))+'='+str(latex(L[i]))+',&'
# phrase_milieu[n-1] ='&'+str(latex(L_nom[n-1]))+'='+str(latex(L[n-1]))+'.&'#car
phrase_milieu[i] ='&'+L_nom[i]+'='+str(L[i])+ end_line_sep+'&'
phrase_milieu[n-1] ='&'+L_nom[n-1]+'='+str(L[n-1])+'.&'#car c'est la dernière.
# A ce stade la liste phrase_milieu contient les n cellules élémentaires
# qu'il faudra regrouper par paquet de q
###########################################################################
if r == 0: #i.e. le reste de la div euclidienne est nul
Lignes=[None] * s
for t in range(0,s,1):
d=""
for j in range(t*q,(t+1)*q,1):
d=d+phrase_milieu[j] #"\\"'\n'
Lignes[t]=d
Lignes[t]=d+doublebackslashlatex
Lignes[s-1]=d # if t != s-1:
# A ce stade, la liste Lignes contient exactement s lignes.
#Chacune de ces lignes contient q termes de la liste L
###########################################################################
else: # Donc ici r diff de 0
Lignes=[None] * (s+1)
for t in range(0,s,1):
d=""
for j in range(t*q,(t+1)*q,1):
d=d+phrase_milieu[j] #"\\"'\n'
Lignes[t]=d+doublebackslashlatex
# A ce stade il ne reste à traiter que les derniers termes de la liste (ceux qui seront sur la dernière ligne)
d=""
for j in range(s*q,n,1):
d=d+phrase_milieu[j]
Lignes[s]=d
longL=len(Lignes)
phrase_du_milieu=""
for a in range(0,longL,1):
phrase_du_milieu=phrase_du_milieu+Lignes[a]+" "'\n'
#print(phrase_du_milieu, '\n')
# A ce stade, phrase_du_milieu contient tout le corps
#du align sauf le begin et le end
phrase = phrase_de_debut + phrase_du_milieu + phrase_de_fin
#phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
phrase=phrase.replace("&&", "& &")
#print(phrase, '\n')
return phrase
##########################################################################################################################################################################################
##
## Début des essais ##
##########################################################################################################################################################################################
# n=10
# #n=3
# La=[None] * n
# for a in range(0,n,1):
# b='E'+"_"+'{'+str(a+1)+'}'
# La[a]=b
# print('La=',La,'\n')
# Lb = range(1,n+1,1)
# print('Lb=',Lb,'\n')
# for b in range(0,n,1):
# print('Lb[b]=',Lb[b],'\n')
# print('EcrituredsAlignetoileLatex(La,Lb,6)=', EcrituredsAlignetoileLatex(La,Lb,6), '\n')
#EcrituredsAlignetoileLatex(La,Lb,6)
# print('EcrituredsAlignetoileLatex(La,Lb,5)= \n')
# EcrituredsAlignetoileLatex(La,Lb,5)
# print('EcrituredsAlignetoileLatex(La,Lb,4)= \n')
# EcrituredsAlignetoileLatex(La,Lb,4)
# print('EcrituredsAlignetoileLatex(La,Lb,3)= \n')
# EcrituredsAlignetoileLatex(La,Lb,3)
# print('EcrituredsAlignetoileLatex(La,Lb,2)= \n')
# EcrituredsAlignetoileLatex(La,Lb,2)
# print('EcrituredsAlignetoileLatex(La,Lb,1)= \n')
# EcrituredsAlignetoileLatex(La,Lb,1)
##########################################################################################################################################################################################
##
## Fin des essais ##
##########################################################################################################################################################################################
[docs]
def EcrituredsAlignLatex(L_nom, L,q,labellatex):
"""Retourne en TeX, dans un align, les éléments de la liste L,
avec, comme noms les éléments de la liste L_nom,
sous le format, L_nom[i]= L[i], regroupés par paquet de q
à chaque ligne (où q est un entier)
"""
doublebackslashlatex="\\"+"\\"
n=len(L)
if n < 1:
raise "La liste est vide"
else:
s=int(n/q)
r=n-q*s # donc n=sq+r i.e. r est le reste dans la division euclidienne de n par q
phrase_de_debut ="\\"'begin{align}\n'+"\\"'label{'+str(labellatex)+'}\n'
phrase_de_fin="\\"'end{align}\n'#"\\"'\n'+'end{align*}\n'
phrase_milieu=[None] * n
for i in range(0,n-1,1):
# phrase_milieu[i] ='&'+str(latex(L_nom[i]))+'='+str(latex(L[i]))+',&'
# phrase_milieu[n-1] ='&'+str(latex(L_nom[n-1]))+'='+str(latex(L[n-1]))+'.&'#car
phrase_milieu[i] ='&'+L_nom[i]+'='+str(L[i])+',&'
phrase_milieu[n-1] ='&'+L_nom[n-1]+'='+str(L[n-1])+'.&'#car c'est la dernière.
# A ce stade la liste phrase_milieu contient les n cellules élémentaires
# qu'il faudra regrouper par paquet de q
###########################################################################
if r == 0: #i.e. le reste de la div euclidienne est nul
Lignes=[None] * s
for t in range(0,s,1):
d=""
for j in range(t*q,(t+1)*q,1):
d=d+phrase_milieu[j] #"\\"'\n'
Lignes[t]=d
Lignes[t]=d+"\\"'notag'+doublebackslashlatex
Lignes[s-1]=d # if t != s-1:
# A ce stade, la liste Lignes contient exactement s lignes.
#Chacune de ces lignes contient q termes de la liste L
###########################################################################
else: # Donc ici r diff de 0
Lignes=[None] * (s+1)
for t in range(0,s,1):
d=""
for j in range(t*q,(t+1)*q,1):
d=d+phrase_milieu[j] #"\\"'\n'
Lignes[t]=d+"\\"'notag'+doublebackslashlatex
# A ce stade il ne reste à traiter que les derniers termes de la liste (ceux qui seront sur la dernière ligne)
d=""
for j in range(s*q,n,1):
d=d+phrase_milieu[j]
Lignes[s]=d
longL=len(Lignes)
phrase_du_milieu=""
for a in range(0,longL,1):
phrase_du_milieu=phrase_du_milieu+Lignes[a]+" "'\n'
#print(phrase_du_milieu, '\n')
# A ce stade, phrase_du_milieu contient tout le corps
#du align sauf le begin et le end
phrase = phrase_de_debut + phrase_du_milieu + phrase_de_fin
#phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
phrase=phrase.replace("&&", "& &")
print(phrase, '\n')
return 0
##########################################################################################################################################################################################
##
## Début des essais ##
##########################################################################################################################################################################################
# n=10
# #n=3
# La=[None] * n
# for a in range(0,n,1):
# b='E'+"_"+'{'+str(a+1)+'}'
# La[a]=b
# print('La=',La,'\n')
# Lb = range(1,n+1,1)
# print('Lb=',Lb,'\n')
# for b in range(0,n,1):
# print('Lb[b]=',Lb[b],'\n')
# print('EcrituredsAlignLatex(La,Lb,6,toto)= \n')
# EcrituredsAlignLatex(La,Lb,5,'toto')
# print('EcrituredsAlignLatex(La,Lb,5)= \n')
# EcrituredsAlignLatex(La,Lb,5,'toto')
# print('EcrituredsAlignLatex(La,Lb,4)= \n')
# EcrituredsAlignLatex(La,Lb,4,'toto')
# print('EcrituredsAlignLatex(La,Lb,3)= \n')
# EcrituredsAlignLatex(La,Lb,3,'toto')
# print('EcrituredsAlignLatex(La,Lb,2)= \n')
# EcrituredsAlignLatex(La,Lb,2,'toto')
# print('EcrituredsAlignLatex(La,Lb,1)= \n')
# EcrituredsAlignLatex(La,Lb,1,'toto')
##########################################################################################################################################################################################
##
## Fin des essais ##
##########################################################################################################################################################################################
##############################################################################
[docs]
def Essaiprint(var):
"""permet d'écrire des variables dans des equations Latex et tout et tout et tout"""
print(var)
return '' #sinon va provoquer l'affichage de None
############################################################################################## Début des essais ############################################################################################
# a='blabla'
# print('Essaiprint(2)=',a)#, a)
############################################################################################## Fin des essais ############################################################################################
[docs]
def Content(L):
""" Donne le contenu de toute la liste L, en en séparant les élements par des virgules (en particulier plus de crochets) """
phrase=""
print(*L, sep = ',')
return phrase
############################################################################################## Début des essais ############################################################################################
#L=[1,3,8,7]
#print('L=', L,'\n')
#c=Content(L) # imprime tous les élements de la liste en les séparant par des virgules.
#print('Content(L)=')
############################################################################################## Fin des essais ############################################################################################
[docs]
def absprpolynome(var):
if var < 0:
e = -var
else:
e = var
return e
############################################################################################## Début des essais ############################################################################################
############################################################################################## Fin des essais ############################################################################################
[docs]
def absprpolynomebis(var,Z):
""" Fonction qui rendra X-r, r étant un réel, bien écrit en TeX (si on utilise EssaiPrint) et qui gère les cas (X--0), (X--2), (X-+2),...."""
u=str(Z)
strvarplus=str(var)
strvarminus=str(-var)
if var<0:
phrase=u+"+"+strvarminus
else:
if var == 0:
phrase=u
else:
phrase=u+"-"+strvarplus
return phrase
############################################################################################## Début des essais ############################################################################################
[docs]
def polycarlatex(M, nbre):
""" Renvoie, en latex, chi^(nbre)_M """
phrase = ""
U = str(M)
if nbre == 0:
a = '{' + "\\" + 'chi' + '}_{' + U + '}'
elif nbre == 1:
a = '{' + "\\" + 'chi' + '}_{' + '{' + '}' + '_' + '{' + U + '}' + '}' + '^' + '{' + '\'' + '}'
else:
a = '{' + "\\" + 'chi' + '}_{' + '{' + '_' + '{' + U + '}' + '}' + '}^' + '{' + '(' + str(k) + ')' + '}'
return a
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
# A écrire
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
[docs]
def Content_pr_python_latex(L):
""" Renvoie, sous forme de string, le contenu de toute la liste L, en en séparant les éléments par des virgules (en particulier plus de crochets) """
phrase=""
for k in range(0,len(L)-1,1):
phrase = phrase+str(L[k])+','
phrase = phrase+str(L[len(L)-1])
return phrase
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
# Lodeizjo=[1,2,3,4]
# A=Content_pr_python_latex(Lodeizjo)
# print('Content_pr_python_latex([1,2,3,4])=', A,'\n')
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
[docs]
def Content_pr_python_latex_avec_sep(L, sep):
""" Renvoie, sous forme de string, le contenu de toute la liste L, en en séparant les éléments par des virgules (en particulier plus de crochets) """
phrase=""
sepa=str(sep)
for k in range(0,len(L)-1,1):
#phrase = phrase+str(latex(L[k]))+sepa
phrase = phrase+str(L[k])+sepa
phrase = phrase+str(L[len(L)-1])
return phrase
#########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
[docs]
def Content_ss_virg(L):
""" Donne le contenu de toute la liste L, en en séparant les éléments par des virgules (en particulier plus de crochets) """
phrase=""
print(*L, sep = ' ')
return phrase
[docs]
def Content_ss_virg_ss_print(L):
""" renvoie phrase qui est le contenu de toute la liste L, sans l'imprimer', en en séparant les éléments par des virgules (en particulier plus de crochets) """
phrase=""
for i in range(0,len(L),1):
phrase = phrase + str(L[i])
#print(*L, sep = ' ')
return phrase
[docs]
def Content_avec_sep_de_mon_choix(L,sepa):
""" Imprime le contenu de toute la liste L, en en séparant les éléments par des sepa, où sepa est une chaine de caractères """
phrase=""
print(*L, sep = sepa)
return phrase
# A=Content_pr_python_latex_avec_sep(Lodeizjo, '=')
# print('Content_pr_python_latex([1,2,3,4])=', A,'\n')
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
[docs]
def hspacelatexstr(l):
"""Renvoie \hspace{lex}"""
a="\\"'hspace{'+str(l)+'ex}'
return a
#########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
# A écrire !
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
##################################################################################
[docs]
def Latex_Roots_Poly_char(CopySteps, CopyStepsbis, CopyStepster):
"Retourne, au format latex toutes le calcul du polynôme carcatéristique et de toutes les dérivées successives interessantes en les racines données dans l'enoncé"
q = len(CopySteps)
List_of_len = []
for i in range(0,q,1):
List_of_len.append(len(CopyStepster[i][1]))
#print('CopyStepster[',i,'][1]=', CopyStepster[i][1],'\n')
#print('List_of_len=', List_of_len,'\n')
Scenario = 0
cpts = 0
IPVF = 0
if List_of_len[q-1] != 0:
Scenario = 1
IPVF = q
else:
S = sum(List_of_len)
if S == 0:
Scenario = 4
IPVF = 0
else:
Scenario = 3
IPVF = q-1
#print('IPVF =', IPVF,'\n')
counter = 0
#print('List_of_len[IPVF] =', List_of_len[IPVF], 'and counter =', counter, '\n')
while List_of_len[IPVF] == 0 and counter < q:
if List_of_len[IPVF-1] != 0:
toto = 2
else:
IPVF = IPVF-1
#IPVF = IPVF-1
#print('IPVF =', IPVF,'\n')
counter = counter + 1
#print('counter =', counter,'\n')
#print('Le Scénario est =', Scenario,'\n')
#print('IPVF =', IPVF,'\n')
if Scenario == 1:
INFR = len(CopySteps)-1 #Indice de la première liste de gauche liste contenant le nbre final de racines. Après ça plus de modif de la liste de gauche
NFR = len(CopyStepster[len(CopySteps)-1][0]) # Nbre final de racines
Mlist = []
fright = ')'
phrase0 = "\\"'begin{align*}\n'
for k in range(0,len(CopySteps),1):
#print('k=',k, '\n')
if k == 0:
#fleft = '{'+"\\"'chi'+'}'+"_"+'{'+"_"+'{M}'+'}'+'('
fleft = '{'+"\\"'chi'+'}'+"_"+'{'+'{}'+"_"+'{M}'+'}'+'('
elif k == 1:
fleft='{'+"\\"'chi'+'}'+"_"+'{'+'{'+'}'+"_"+'{'+'M'+'}'+'}'+'^'+'{'+"\'"+'}'+'('
else:
fleft='{'+"\\"'chi'+'}'+"_"+'{'+"_"+'{M}'+'}'+'^{'+'('+str(k)+')'+'}'+'('
fright = ')'
##########################################################################################
##########################################################################################
#if k != len(CopySteps)-1:
#print('k=',k,'\n')
# Donc on n'est pas à la dernière étape
#print('Donc on n est pas à la dernière étape')
if len(CopySteps[k][1]) > 1:
# Donc il y a plus d'un seul élément dans len(CopySteps)[k][1]
phrase0 = "\\"'begin{align*}\n'
phrase1 = Content_pr_python_latex_avec_sep(CopySteps[k][0],'=')
phrase1 ='&'+phrase1+'=0'+',&\n'
phrase2 ='&'+" "+"\\"'&'+" "+'&\n'
phrase3 =Content_pr_python_latex_avec_sep(CopyStepsbis[k][1],',')
phrase3 ='&'+"\\"'forall'+"\\"'lambda'+"\\"'in'+"\\"'{'+phrase3+"\\"'}'+','
phrase3 = phrase3+ hspacelatexstr(2) + fleft+"\\"'lambda'+')'+"\\"'neq'+"\\"'hspace{0.25ex}'+ '0'
phrase4 ='&\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4
#
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase)
#print('phrase1 =\n', phrase, '\n')
elif len(CopySteps[k][1]) == 1:
# Donc il y a un seul élément dans len(CopySteps)[k][1]
phrase0 = "\\"'begin{align*}\n'
phrase1 = Content_pr_python_latex_avec_sep(CopySteps[k][0],'=')
phrase1 ='&'+phrase1+'=0'+',&\n'
phrase2 ='&'+" "+"\\"'&'+"\\"'hspace{1ex}'+'&\n'
L=Function_of_a_list(CopyStepsbis[k][1],fleft,fright)
phrase3 =Content_pr_python_latex_avec_sep(L,'')
phrase3 ='&'+phrase3+"\\"'neq 0'+'&'
phrase4 ='&\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase)
#print('phrase2 =\n', phrase, '\n')
else: # donc on a: len(CopySteps[k][1]) == 0:
#autrement dit len(CopySteps[k][1]) == 0 i.e. la liste de droite actuelle est vide
# On est sûr de ne pas avoir atteint la dernière étape car la dernière liste de droite est non vide
phrase1 = Content_pr_python_latex_avec_sep(CopySteps[k][0],'=')
phrase1 = phrase1+'=0'+','
phrase2 =''
phrase3 =''
phrase4 = ''
phrase5 ='\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4+phrase5
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase) #print('On est a l etape', k, 'et donc =\n', phrase, '\n')
###################################################################################################
# Donc maintenant on s'occupe de la toute dernière étape
#print('k=',len(CopySteps), 'Donc on est à la dernière étape', '\n')
fleft='{'+"\\"'chi'+'}'+"_"+'{'+"_"+'{M}'+'}'+'^{'+'('+str(len(CopySteps))+')'+'}'+'('
fright=')'
phrase0 = "\\"'begin{align*}\n'
if len(CopySteps[len(CopySteps)-1][0]) > 1:
# Il y a donc plusieurs racines dans la dernière liste de gauche
phrase1=''
partie = Content_pr_python_latex_avec_sep(CopyStepster[len(CopySteps)-1][0],',')
phrase2 = '&'+"\\"'forall'+"\\"'lambda'+"\\"'in'+"\\"'{'+partie+"\\"'}'+','+ hspacelatexstr(2)
phrase3 = fleft+"\\"'lambda'+')'+"\\"'neq' + hspacelatexstr(2) + '0'+'.'
phrase4 ='&\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
#print('On est a l etape', len(CopySteps), 'et donc =\n', phrase, '\n')
print(phrase) #print('phrase1 =\n', phrase, '\n')
#print('Dico_of_roots_to_be_computed_with_their_mulitplicity_decreasing_decreasing_at_every_step=', Dico_of_roots_to_be_computed_with_their_mulitplicity_decreasing_at_every_step,'\n')
else: # Il n'y a donc qu'une seule racine dans la dernière liste de gauche
phrase1 = ''
partie = Content_pr_python_latex_avec_sep(CopyStepster[len(CopySteps)-1][0],',')
phrase2 = ''
phrase3 = fleft+ str(CopyStepster[len(CopySteps)-1][0][0]) +')'+"\\"'neq'+ hspacelatexstr(0.25)+ '0'+'.'
phrase4 ='&\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
#print('On est a l etape', len(CopySteps), 'et donc =\n', phrase, '\n')
print(phrase) #print('phrase1 =\n', phrase, '\n')
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Fin du scénario 1
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
else: # Donc on n'est pas dans le scénario 1!!!!!
if IPVF == 0:
#Toutes les listes de droite sont donc vides
DP = 0
#PV = 0
PV = q-1
else: #Toutes les listes de droite sont donc vides à partir de l'indice PV
DP = IPVF-1
PV = IPVF
Mlist = []
fright = ')'
phrase0 = "\\"'begin{align*}\n'
# On va appliquer le scénario 1 de l'indice 0 jusqu'à PV-1 i.e. DP). Pour le scénario où toutes
# les listes de droite sont vides, il ne se passera rien à cette étape car PV =0
for k in range(0,PV,1): #print('k=',k, '\n')
if k == 0:
fleft = '{'+"\\"'chi'+'}'+"_"+'{'+'{}'+"_"+'{M}'+'}'+'('
elif k == 1:
fleft='{'+"\\"'chi'+'}'+"_"+'{'+'{'+'}'+"_"+'{'+'M'+'}'+'}'+'^'+'{'+"\'"+'}'+'('
else:
fleft='{'+"\\"'chi'+'}'+"_"+'{'+"_"+'{M}'+'}'+'^{'+'('+str(k)+')'+'}'+'('
fright = ')'
if len(CopySteps[k][1]) > 1:
# Donc il y a plus d'un seul élément dans len(CopySteps)[k][1]
phrase0 = "\\"'begin{align*}\n'
phrase1 = Content_pr_python_latex_avec_sep(CopySteps[k][0],'=')
phrase1 ='&'+phrase1+'=0'+',&\n'
phrase2 ='&'+" "+"\\"'&'+" "+'&\n'
phrase3 =Content_pr_python_latex_avec_sep(CopyStepsbis[k][1],',')
phrase3 ='&'+"\\"'forall'+"\\"'lambda'+"\\"'in'+"\\"'{'+phrase3+"\\"'}'+','
phrase3 = phrase3+ hspacelatexstr(2) + fleft+"\\"'lambda'+')'+"\\"'neq'+"\\"'hspace{0.25ex}'+ '0'
phrase4 ='&\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4
#
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase)
#print('phrase1 =\n', phrase, '\n')
elif len(CopySteps[k][1]) == 1:
# Donc il y a un seul élément dans len(CopySteps)[k][1]
phrase0 = "\\"'begin{align*}\n'
phrase1 = Content_pr_python_latex_avec_sep(CopySteps[k][0],'=')
phrase1 ='&'+phrase1+'=0'+',&\n'
phrase2 ='&'+" "+"\\"'&'+"\\"'hspace{1ex}'+'&\n'
L=Function_of_a_list(CopyStepsbis[k][1],fleft,fright)
phrase3 =Content_pr_python_latex_avec_sep(L,'')
phrase3 ='&'+phrase3+"\\"'neq 0'+'&'
phrase4 ='&\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase)
#print('phrase2 =\n', phrase, '\n')
else: # donc on a: len(CopySteps[k][1]) == 0:
#autrement dit len(CopySteps[k][1]) == 0 i.e. la liste de droite actuelle est vide
# On est sûr de ne pas avoir atteint la dernière étape car la dernière liste de droite est non vide
phrase1 = Content_pr_python_latex_avec_sep(CopySteps[k][0],'=')
phrase1 = phrase1+'=0'+','
phrase2 =''
phrase3 =''
phrase4 = ''
phrase5 ='\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4+phrase5
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase) #print('On est a l etape', k, 'et donc =\n', phrase, '\n')
# A partir de là, onest arrivé à la dernière étape. On va donc, et jusqu'à la fin, on applique le Scénario 4, et plus pcrécisément sa dernière étape
################################
################################
# if q == 0:
if len(CopySteps[PV][0]) == 1: # Il n'y a donc qu'une unique racine
for k in range(PV,len(CopySteps),1):
a = fleft_of('M',k) #print('fleft_of(M,k) = ', a, '\n')
b = CopyStepster[IPVF][0][0]
c=a+str(b)+fright #print('c = ', c, '\n')
Mlist.append(c) #print('Mlist = ', Mlist, '\n')
#
phrase1 = Content_pr_python_latex_avec_sep(Mlist,'=')
phrase1 ='&'+phrase1+'=0'+',&\n'
phrase2 ='&'+" "+"\\"'&'+" "+'&\n'
phrase3 = '&'+'{'+"\\"'chi'+'}'+"_"+'{'+"_"+'{M}'+'}'+'^{'+'('+str(len(CopySteps))+')'+'}'+'('+str(CopyStepster[IPVF][0][0])+')'
phrase4 = "\\"'neq'+"\\"'hspace{0.25ex}'+ '0'+'.'+'&'
phrase5 ='\n'+"\\"'end{align*}\n'
else: # Donc on a: len(CopySteps[IPVF][0]) > 1:
# Il y aura donc plusieurs racines de début à la fin (tjs le même nbre)
for k in range(PV,len(CopySteps),1): # Donc il y a plus d'un seul élément dans len(CopySteps)[k][1]
if k != len(CopySteps)-1:
# Donc k n'est pas la dernière étape
phrase1 = Content_pr_python_latex_avec_sep(CopySteps[k][0],'=')
phrase1 = phrase1+'=0'+','
phrase2 =''
phrase3 =''
phrase4 = ''
phrase5 ='\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4+phrase5
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
#print('Le scenario vaut 4 et donc =\n', phrase, '\n')
else: #Donc k == len(CopySteps)-1: et on est à la dernière étape
# Donc k est la dernière étape
phrase1 = Content_pr_python_latex_avec_sep(CopySteps[k][0],'=')
phrase1 = '&'+ phrase1+'=0'+',&\n'
phrase2 ='&'+" "+"\\"'&'+" "+'&\n'
phrase3 =Content_pr_python_latex_avec_sep(CopyStepster[IPVF][0],',')
phrase3 ='&'+"\\"'forall'+"\\"'lambda'+"\\"'in'+"\\"'{'+phrase3+"\\"'}'+','
phrase4 = hspacelatexstr(2) + fleft_of('M',k+1)+"\\"'lambda'+')'+"\\"'neq'+hspacelatexstr(0.25)+ '0.'+'&'
phrase5 ='\n'+"\\"'end{align*}\n'
phrase= phrase0+phrase1+phrase2+phrase3+phrase4+phrase5
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase)
#print('Le scenario vaut 4 et donc =\n', phrase, '\n')
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Fin du scénario 4
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
return 0
#########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
# EN reprenant les trois listes CopySteps, CopyStepsbis, CopyStepster de mon programme latex d'exo synthèse
# de Linear Algebra
#Latex_Roots_Poly_char(CopySteps, CopyStepsbis, CopyStepster)
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
############################################################################################## Fin des essais ############################################################################################
[docs]
def standard_basis_vector(n,p):
""""Retourne le vecteur e_p de R^n, i.e. (0,0,....,0,1,0,...,0) où le 1 est en p-ième position sous forme de matrix sympy: Attention avec le décalage de python la 1ere ligne est la ligne 0"""
A=zeros(n,1)
#A[p-1]=A[p-1]+1 #si one ne veut pas du décalage de python la 1ere ligne est la ligne 0
A[p]=A[p]+1
return A
############################################################################################## Début des essais ############################################################################################
#print('standard_basis_vector(4,2)=',standard_basis_vector(4,2))
############################################################################################## Fin des essais ############################################################################################
############################################################################################## Début des essais ############################################################################################
#print('standard_basis_vector(4,2)=',standard_basis_vector(4,2))
############################################################################################## Fin des essais ############################################################################################
[docs]
def Eigen_Spaces_ds_align_latex(M,E,etat,nbre_de_paquets,labellatex):
"Retourne dans un align, par paquet de nbre_de_paquets termes, les sous-espaces propres de M,"
"sous la forme E_{lambda_i})=Span{...}"
"Si état=1, on a align et sinon align*"
#Ecriture de tous les espaces propres existants, sous la forme E_{lambda}
EVM=M.eigenvects(simplify=True)
nbvp=len(EVM) #nbre de vp distinctes de M
F=str(E)
lis = []
for i in range(0,nbvp,1):
vp_i=EVM[i][0]
lis.append(vp_i)
La=[None] * nbvp
for i in range(0,nbvp,1):
b=F+"_"+'{'+str(lis[i])+'}'
La[i]=b
phrase_de_debut="\\"'spann\left\{\left('
phrase_de_fin="\\"'right)'+"\\"'right\}'
Lb=[None] * nbvp
vr="\\"'right]'
vl="\\"'left['
wr="\\"'end{smallmatrix},'
wt="\\"'end{smallmatrix}'+"\\"'right) ,'+"\\"'left('
for i in range(0,nbvp,1):
li=len(EVM[i][2]) #nbre de vecteurs propres dans le sous espace propre de la vp lambda_i
b=""
if li == 1:
l='l'+str(i)
#print(l,'=',li,'\n')
b=b+str(latex(EVM[i][2][0]))
b=phrase_de_debut+b+phrase_de_fin
b=b.replace(vl, "")
b=b.replace(vr, "")
b=b.replace('matrix', 'smallmatrix')
Lb[i]=b
#print('Lb[',i,']=',Lb[i],'\n')
else: # donc il y a plus d'un vecteur propre
l='l'+str(i)
#print(l,'=',li,'\n')
for j in range(0,li-1,1):
b=b+str(latex(EVM[i][2][j]))+','
b=b+str(latex(EVM[i][2][li-1]))
b=phrase_de_debut+b+phrase_de_fin
#b=b.replace(wr, wt)
b=b.replace(vl, "")
b=b.replace(vr, "")
b=b.replace('matrix', 'smallmatrix')
b=b.replace(wr, wt)
Lb[i]=b
if etat==0:
return EcrituredsAlignetoileLatex(La, Lb, nbre_de_paquets)
else:
return EcrituredsAlignLatex(La, Lb, nbre_de_paquets,labellatex)
#t = EcrituredsAlignLatex(La, Lb, nbre_de_paquets)
# return EcrituredsAlignLatex(La, Lb, nbre_de_paquets)
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
#Eigen_Spaces_ds_align_latex(M,E,1,3)
#Eigen_Spaces_ds_align_latex(M,'E',1,3,'toto')
#Eigen_Spaces_ds_align_latex(M,'E',0,3,'toto')
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
[docs]
def Dim_Eigen_Spaces_ds_align_latex(M,E,etat,nbre_de_paquets,labellatex):
"Retourne dans un align, par paquet de q termes, la dimension des sous-espaces propres de M,"
"sous la forme din(E_{lambda_i})=r_i"
"Si état=1, on a align et sinon align*"
#Ecriture de tous les espaces propres existants, sous la forme E_{lambda}
EVM=M.eigenvects(simplify=True)
nbvp=len(EVM) #nbre de vp distinctes de M
F=str(E)
lis = []
for i in range(0,nbvp,1):
vp_i=EVM[i][0]
lis.append(vp_i)
La=[None] * nbvp
for i in range(0,nbvp,1):
b="\\"+'dim('+F+"_"+'{'+str(lis[i])+'}'+')'
#b=b.replace("\\", "\")
La[i]=b
Lb=[None] * nbvp
for i in range(0,nbvp,1):
b=str(EVM[i][1])
Lb[i]=b
#print('Lb=', Lb,'\n')
if etat==0:
return EcrituredsAlignetoileLatex(La, Lb, nbre_de_paquets)
else:
return EcrituredsAlignLatex(La, Lb, nbre_de_paquets,labellatex)
#t = EcrituredsAlignLatex(La, Lb, nbre_de_paquets)
# return EcrituredsAlignLatex(La, Lb, nbre_de_paquets)
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
#Eigen_Spaces_ds_align_latex(M,E,1,3)
#Dim_Eigen_Spaces_ds_align_latex(M,'E',1,3,'toto')
#Dim_Eigen_Spaces_ds_align_latex(M,'E',0,3,'toto')
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
############################################################################################## Fin des essais ############################################################################################
[docs]
def Eigen_Vectors_ds_align_latex(M,f,etat,nbre_de_paquets,labellatex):
"Retourne dans un align, par paquet de nbre_de_paquets termes, les vecteurs propres de M,"
"sous la forme f_{_i)=(...)"
"Si état=1, on a align et sinon align*"
#Ecriture de tous les espaces propres existants, sous la forme E_{lambda}
F=str(f)
EVM=M.eigenvects(simplify=True)
nbvp=len(EVM) #nbre de vp distinctes de M
nbvectp=0 #nbre de vecteurs propres
for i in range(0,nbvp,1):
nbvectp=nbvectp+len(EVM[i][2])
#print('nbvectp=',nbvectp,'\n')
# A ce stade, nbvectp est égal le nombre de vecteurs propres de M
La=[]
x=' '
for i in range(0,nbvectp,1):
b='{'+"\\"'bs'+x+F+'}'+"_"+'{'+str(i+1)+'}'
La.append(b)
#print('La=',La,'\n')
# A ce stade lis contient f_1, f_2, ..... jusqu'à f_q
# où q est le nbre de vecteurs propres de M
nbvp=len(EVM) #nbre de vp distinctes de M
phrase_de_debut=""
phrase_de_fin=""
Lb=[None] * nbvectp
cpteur_actuel=0
cpteur_Li=0
for i in range(0,nbvp,1):
li=len(EVM[i][2])
#print('ici',i,'vaut',i,'\n')
for j in range(0,li,1):
#print('ici j vaut',j,'\n')
b=str(latex(EVM[i][2][j]))
#print('b vaut',b,'\n')
b=phrase_de_debut+b+phrase_de_fin
b=b.replace('matrix', 'smallmatrix')
Lb[cpteur_actuel+j]=b
cpteur_actuel = cpteur_actuel+li
if etat==0:
return EcrituredsAlignetoileLatex(La, Lb, nbre_de_paquets)
else:
return EcrituredsAlignLatex(La, Lb, nbre_de_paquets,labellatex)
#t = EcrituredsAlignLatex(La, Lb, nbre_de_paquets)
# return EcrituredsAlignLatex(La, Lb, nbre_de_paquets)
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
#Eigen_Vectors_ds_align_latex(M,'f',1,3,'toto')
#Eigen_Vectors_ds_align_latex(M,'f',0,3,'toto')
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
############################################################################################## Fin des essais ############################################################################################
[docs]
def Liste_de_ts_les_vec_propres(M):
"Retourne dans une liste, tous les vecteurs propres de M, comme ils apparaissent dans EVM"
vr="\\"'right]'
vl="\\"'left['
EVM=M.eigenvects(simplify=True)
nbvp=len(EVM) #nbre de vp distinctes de M
nbvectp=0 #nbre de vecteurs propres
for i in range(0,nbvp,1):
nbvectp=nbvectp+len(EVM[i][2])
#print('nbvectp=',nbvectp,'\n')
# A ce stade, nbvectp est égal le nombre de vecteurs propres de M
Lb=[None] * nbvectp
cpteur_actuel=0
cpteur_Li=0
for i in range(0,nbvp,1):
li=len(EVM[i][2])
for j in range(0,li,1):
b=EVM[i][2][j]
# b=str(latex(EVM[i][2][j]))
# b=b.replace(vl, "")
# b=b.replace(vr, "")
Lb[cpteur_actuel+j]=b
cpteur_actuel = cpteur_actuel+li
return Lb
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
#print(Liste_de_ts_les_vec_propres(M),'\n')
#print('Liste_de_ts_les_vec_propres(M)[0]=',Liste_de_ts_les_vec_propres(M)[0],'\n')
#print(Transpose(Liste_de_ts_les_vec_propres(M)[0]),'\n')
#print(transpose(standard_basis_vector(3,0)),'\n')
#print(transpose(standard_basis_vector(3,1)),'\n')
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
############################################################################################## Fin des essais ############################################################################################
[docs]
def Matrice_Pass_Base_canonique_a_base_de_vect_propres(M):
"Retourne la matrice de passage de la base canonique de K^n, où n=nbre de lignes de l amatrice carrée M, vers la base de vecteurs propres de M, obtenus en utilisant la fonction Liste_de_ts_les_vec_propres(M)"
L=Liste_de_ts_les_vec_propres(M)
p=M.rows
J=zeros(p,1)
#print('J=',J,'\n')
for g in range(0,p,1):
J=J.col_insert(g, L[g])
#print('J_',g,'=',J,'\n')
J.col_del(p)
#print('J=',J,'\n')
return J
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
#print('Matrice_Pass_Base_canonique_a_base_de_vect_propres(M)=',Matrice_Pass_Base_canonique_a_base_de_vect_propres(M))
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
############################################################################################## Fin des essais ############################################################################################
[docs]
def Linear_Map_from_a_Matrix(u, x, M):
"Retourne l'application linéaire u:K^p -> K^q, assosciée à la matrice M"
", dans la base canonique et sous la forme u(x_1,...,x_p)= u_1(x),...,u_q(x)"
q = M.rows
p = M.cols
Lx = [None] * p
Ly = [None] * q
X = zeros(p, 1)
last_sentence = ""
for i in range(0, p, 1):
b = str(x) + "_" + '{' + str(i + 1) + '}'
Lx[i] = b
c = str(x) + "_" + '{' + str(i + 1) + '}'
s = Symbol(c)
X[i] = s
# print('X=', X, '\n')
left_sentence = str(u) + '('
for i in range(0, p - 1, 1):
left_sentence = left_sentence + str(Lx[i]) + ','
left_sentence = left_sentence + str(Lx[p - 1]) + ')'
middle_sentence = '='
T = M * X
for i in range(0, q, 1):
Ly[i] = str(T[i])
qqq = str(latex(T[0]))
right_sentence = '('
for i in range(0, q - 1, 1):
right_sentence = right_sentence + str(latex(T[i])) + ','
right_sentence = right_sentence + str(latex(T[q - 1])) + ')'
last_sentence = left_sentence + middle_sentence + right_sentence
# print(X)
# print(left_sentence)
# return "" # left_sentence
# return X # left_sentence
# return T # left_sentence
# return Ly # left_sentence
# return qqq # left_sentence
# print(right_sentence)
# return rightsentence
return last_sentence
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
#print(X)
#print(leftsentence)
#return ""#leftsentence
#return X #leftsentence
#return T #leftsentence
#return Ly #leftsentence
#return qqq #leftsentence
#print(rightsentence)
#return rightsentence
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
############################################################################################## Fin des essais ############################################################################################
[docs]
def Vec_seul(x,p):
"Retourne le vecteur x:=(x_{1},x_{2},...,x_{p}) verticalement"
p=int(p)
Lx=[None] * p
X=zeros(p,1)
for i in range(0,p,1):
b=str(x)+"_"+'{'+str(i+1)+'}'
Lx[i]=b
c=str(x)+"_"+'{'+str(i+1)+'}'
s=Symbol(c)
X[i]=s
#print('X=',X,'\n')
return X
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
[docs]
def Merge_Lists_Symbol(L_1, L_2, L_3):
"""Renvoi une unique liste, notée L, sur le modèle suivant
L[i] = L_1[i] L_3[i] L_2[i], pour i de 0 à len(L1)-1, ou les trois listes ont la même longueur et ou, si L_3 n'est pas une liste, alors on la créer avec un seul symbole répété len(L1) fois
"""
if len(L_1) != len(L_2):
raise "Les deux listes n'ont pas la même longeur"
else:
toto = 2
if len(L_3) == 1:
T = [None] * len(L_1)
for i in range(0,len(L_1),1):
T[i] = L_3
L_3 = T
else:
toto = 2
Q = [None] * len(L_1)
for i in range(0,len(L_1),1):
Q[i] = str(L_1[i]) + str(L_3[i]) + str(L_2[i])
return Q
############################################################################################## Fin des essais ############################################################################################
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
# A = ['a_1','a_2','a_3','a_4','a_5']
# B = [1, 2, 3, 4, 5]
# C = ['=','=','=','=','=']
# L = Merge_Lists_Symbol(A, B, '=')
# print('L =', L, '\n')
# N = Merge_Lists_Symbol(A, B, C)
# print('N =', N, '\n')
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
[docs]
def Merge_Lists_in_Align_etoile_Latex(L,symb, symbfinal):
"""Retourne en TeX, dans un align*, les éléments de chacune des listes contenues dans la liste L,
en mettant un élement de chaque par ligne. Ainsi, si L_1, L_2 et L_3
sont trois listes et que L=[L_1, L_2, L_3], alors on renverra
#
begin{align*}
&L_1[0],& &L_2[0],& &L_3[0],& \\
&L_1[1],& &L_2[1],& &L_3[1],& \\
...
&L_1[len(L_1)-1],& &L_2[len(L_1)-1],& &L_3[len(L_1)-1],& \\
end{align*}
#
"""
symb = str(symb)
symbfinal = str(symbfinal)
p = len(L)
#print('p=',p,'\n')
if p == 0:
raise "aucune liste à traiter"
else:
n = len(L[0])
#print('n=',n,'\n')
for i in range(0,p,1):
if len(L[i]) != n:
raise "Toutes les listes n'ont pas la même longueur"
else:
toto = 2
phrase_de_debut ="\\"'begin{align*}\n'
phrase_de_fin="\\"'end{align*}\n'
phrase_milieu = []
for i in range(0,n-1,1):
#print('i=',i,'\n')
phrase_i = ''
for j in range(0,p,1):
#print('j=',j,'\n')
phrase_i = phrase_i + '&'+ str(L[j][i]) +symb+'&'
#print(' phrase_i=', phrase_i,'\n')
phrase_i = phrase_i + "\\"+"\\"
phrase_milieu.append(phrase_i)
phrase_fin_boucle = ''
for j in range(0,p-1,1):
#print('j=',j,'\n')
phrase_fin_boucle = phrase_fin_boucle + '&'+ str(L[j][n-1]) +symb+'&'
#print(' phrase_fin_boucle=', phrase_fin_boucle,'\n')
phrase_fin_boucle = phrase_fin_boucle + '&'+ str(L[p-1][n-1]) +symbfinal+'&'
phrase_fin_boucle = phrase_fin_boucle + "\\"+"\\"
phrase_milieu.append(phrase_fin_boucle)
#print(' phrase_milieu=', phrase_milieu,'\n')
phrase_du_milieu=""
for a in range(0,len(phrase_milieu),1):
if a == len(phrase_milieu)-1:
phrase_du_milieu = phrase_du_milieu + phrase_milieu[a]+" "'\n'
else:
phrase_du_milieu = phrase_du_milieu + phrase_milieu[a]+" "'\n'
#print(phrase_du_milieu, '\n')
# A ce stade, phrase_du_milieu contient tout le corps
#du align sauf le begin et le end
phrase = phrase_de_debut + phrase_du_milieu + phrase_de_fin
#phrase=phrase.replace(" ", "")
#phrase=phrase.replace("[", "(")
#phrase=phrase.replace("]", ")")
phrase=phrase.replace("&&", "& &")
print(phrase, '\n')
return 0
##########################################################################################################################################################################################
##
## Début des essais ##
##########################################################################################################################################################################################
# n=5
# La=[None] * n
# for a in range(0,n,1):
# b='E'+"_"+'{'+str(a+1)+'}'
# La[a]=b
# print('La=',La,'\n')
# print('len(La)=',len(La),'\n')
# Lb = range(1,n+1,1)
# print('Lb=',Lb,'\n')
# print('len(Lb)=',len(Lb),'\n')
# L=[]
# L.append(La)
# L.append(Lb)
# print('L=',L,'\n')
# Merge_Lists_in_Align_etoile_Latex(L,',','.')
# Merge_Lists_in_Align_etoile_Latex(L,'','.')
# Merge_Lists_in_Align_etoile_Latex(L,'','')
##########################################################################################################################################################################################
##
## Fin des essais ##
##########################################################################################################################################################################################
##===========================================================================================
##===========================================================================================
#
#
# New fction
#
##===========================================================================================
##=========================================================================================
[docs]
def Ecriture_Poly_en_Latex(P,symbol):
""" Renvoie une liste de deux éléments: chacun de ces élements donne
le polynôme P, écrit en Tex, avec symbol (qui est une chaine de caractères) comme indéterminée
etles monômes sont donnés par ordre:
-croissant dans la première liste
-décroissant décroissant dans la deuxième liste
"""
X = Symbol(symbol)
L = P.all_coeffs()
deg_P = degree(P)
U = L[0]
#U_latex = str(L[0])
if L[0] == 0:
U_latex = ''
else:
U_latex = str(L[0])
V_latex = ""
#print('U_latex =' , U_latex,'\n')
symb = []
for j in range(0,len(L),1):
if j == 0:
symb.append('')
elif j == 1:
symb.append(symbol)
else:
a = symbol+'^{'+ str(deg_P-j) +'}'
symb.append(a)
for j in range(len(L)-1,-1,-1):
#for j in range(0,len(L),1):
#V_latex = V_latex + str(L[j]) + symbol+'^{'+ str(j) +'}'
#print('V_latex1 =' , V_latex,'\n')
if j == len(L)-1:
if L[j] < 0 or L[j] == -1:
if L[j] == -1:
V_latex = V_latex + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
V_latex = V_latex + str(L[j]) + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j, ' =' , V_latex,'\n')
elif L[j] == 1:
V_latex = V_latex + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
elif L[j] == 0:
V_latex = V_latex
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
V_latex = V_latex + '-' + str(L[j]) + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
if L[j] < 0 or L[j] == -1:
if L[j] == -1:
V_latex = V_latex + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
V_latex = V_latex + str(L[j]) + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
elif L[j] == 0:
V_latex = V_latex
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
elif L[j] == 1:
V_latex = V_latex + '+' + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
V_latex = V_latex + '+' + str(L[j]) + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
for i in range(1,len(L),1):
U = U + L[i]*(X**i)
if i == 1:
if L[1] < 0 or L[1] == -1:
if L[1] == -1:
U_latex = U_latex + symbol
#print('U_latex1 =' , U_latex,'\n')
else:
U_latex = U_latex + str(L[1]) + symbol
#print('U_latex2 =' , U_latex,'\n')
elif L[1] == 1:
U_latex = U_latex + '+' + symbol
#print('U_latex 3=' , U_latex,'\n')
elif L[1] == 0:
U_latex = U_latex
#print('U_latex 3=' , U_latex,'\n')
else:
U_latex = U_latex + '+' +str(L[1]) + symbol
#print('U_latex4 =' , U_latex,'\n')
else:
if L[i] < 0 or L[i] == -1:
if L[i] == -1:
U_latex = U_latex + symbol+'^{'+ str(i) +'}'
#print('U_latex5 =' , U_latex,'\n')
else:
U_latex = U_latex + str(L[i]) + symbol+'^{'+ str(i) +'}'
#print('U_latex6 =' , U_latex,'\n')
elif L[i] == 0:
U_latex = U_latex
#print('U_latex 3=' , U_latex,'\n')
elif L[i] == 1:
U_latex = U_latex + '+' + symbol+'^{'+ str(i) +'}'
#print('U_latex7 =' , U_latex,'\n')
else:
U_latex = U_latex + '+' + str(L[i]) + symbol+'^{'+ str(i) +'}'
#print('U_latex8 =' , U_latex,'\n')
X_latex = U_latex
Y_latex = V_latex
Result = [X_latex, Y_latex]
return Result
##===========================================================================================
##===========================================================================================
# Début des essais
##===========================================================================================
##===========================================================================================
##===========================================================================================
##===========================================================================================
# Fin des essais
##===========================================================================================
##===========================================================================================
#===========================================================================================
##===========================================================================================
#
# New fction
#
##===========================================================================================
##=========================================================================================
[docs]
def Ecriture_Poly_en_Latex_dec(P,symbol):
""" Renvoie une liste de deux éléments: chacun de ces élements donne
le polynôme P, écrit en Tex, avec symbol (qui est une chaine de caractères) comme indéterminée
etles monômes sont donnés par ordre:
-décroissant décroissant #dans la deuxième liste
"""
X = Symbol(symbol)
deg_P = degree(P)
L_coef_dec = P.rep.rep
P_all_coeffs = P.all_coeffs()
if L_coef_dec != P_all_coeffs:
raise('Pbm attention les coef du polynôme ne seront pas dans l ordre', '\n')
else:
#print('L_coef_dec = ', L_coef_dec, '\n')
String_ceof_dec_treated = ''
L_ceof_dec_treated = ['']*(1+deg_P)
for i in range(0, deg_P+1, 1):
if i == 0:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
elif i == deg_P-1:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + symbol #'{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + symbol # '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-1) + '}'
elif L_coef_dec[i] == 0:
L_ceof_dec_treated[i] = ''
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+' + str(L_coef_dec[i]) + symbol
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + symbol # #+ '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
elif i == deg_P:
if L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+'+ str(L_coef_dec[i]) #+ symbol #'{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == 0:
L_ceof_dec_treated[i] = ''
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) #+ symbol # #+ '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
else:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == 0:
L_ceof_dec_treated[i] = '' #+ '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+' + str(L_coef_dec[i]) + '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
Poly_dec_monomials_latex = String_ceof_dec_treated
return Poly_dec_monomials_latex#1#Result
##===========================================================================================
##===========================================================================================
# Début des essais
##===========================================================================================
##===========================================================================================
# X= Symbol('X')
# P = Poly(2*X**3 - 2*X**2 + 7*X -4, X)
# L_coef_de_P = P.all_coeffs()
# R = P.rep.rep
# print('P(X) =' , P,'\n')
# print('coeff de P ds l exemple =' , L_coef_de_P,'\n')
# print('P.rep.rep =' , R,'\n')
# S = Poly([-4, 7, 1, 1], X)
# print('S =' , S,'\n')
# L_coef_de_S = S.all_coeffs()
# print('S(X) =' , S,'\n')
# print('S.all_coeffs() =', L_coef_de_S,'\n')
# symbol = 'G'
# E_S = Ecriture_Poly_en_Latex_dec(S,symbol)
# print('E_S =', E_S, ' \n')
# Q = Poly(-2 + 2*X + 3*X**3 + X**4, X)
# print('Q(X) =' , Q,'\n')
# L_coef_de_Q = Q.all_coeffs()
# print('coeff de Q ds l exemple =' , L_coef_de_Q,'\n')
# T = Add(-5*X**3, -X**2, 2*X, +3, evaluate=False)
# PolyT = Poly(T, X)
# print('PolyT =' , PolyT,'\n')
# L_coef_de_PolyT = PolyT.all_coeffs()
# print('PolyT(X) =' , PolyT,'\n')
# print('PolyT.all_coeffs() =', L_coef_de_PolyT,'\n')
# #E_T = Ecriture_Poly_en_Latex_inc(PolyT,symbol)
# print(Ecriture_Poly_en_Latex_dec(S,symbol))
# symbol = 'Y'
# E = Ecriture_Poly_en_Latex_inc(P,symbol)
##===========================================================================================
##===========================================================================================
# Fin des essais
##===========================================================================================
##===========================================================================================
##===========================================================================================
##===========================================================================================
#
#
# New fction
#
##===========================================================================================
##=========================================================================================
[docs]
def Ecriture_Poly_en_Latex_inc(P,symbol):
""" Renvoie une liste de deux éléments: chacun de ces élements donne
le polynôme P, écrit en Tex, avec symbol (qui est une chaine de caractères) comme indéterminée
etles monômes sont donnés par ordre:
-croissant
"""
X = Symbol(symbol)
deg_P = degree(P)
L_coef_dec = P.rep.rep
P_all_coeffs = P.all_coeffs()
if len(L_coef_dec) == 0 or len(P_all_coeffs) == 0:
raise('Pbm attention aucun coefficient non nul', '\n')
else:
toto =2
if L_coef_dec != P_all_coeffs:
raise('Pbm attention les coef du polynôme ne seront pas dans l ordre', '\n')
else:
print('L_coef_dec = ', L_coef_dec, '\n')
L_coef_dec = Reverse_List(L_coef_dec)
print('L_coef_dec = ', L_coef_dec, '\n')
counter_zeros = 0
for i in range(0,len(L_coef_dec),1):
if L_coef_dec[i] == 0:
counter_zeros = counter_zeros +1
else:
toto = 2
alpha = counter_zeros# c'est le nbre de coefs nuls en partant du coef de puissance 0
print('alpha = ', alpha, '\n')
String_ceof_dec_treated = ''
L_ceof_dec_treated = ['']*(1+deg_P)
for i in range(0, deg_P+1, 1):
if i == 0:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '1'
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) #+ symbol #'{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == 0:
L_ceof_dec_treated[i] = ''
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) #+ symbol # #+ '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
#print(' L_ceof_dec_treated[', i, '] = ', L_ceof_dec_treated[i], '\n')
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print('String_ceof_dec_treated = ', String_ceof_dec_treated, '\n')
elif i == counter_zeros and counter_zeros > 1:
#print('ici on est dans le cas ou i vaut =', i, '\n')
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print('L_ceof_dec_treated[i] = ', L_ceof_dec_treated[i], '\n')
elif i == 1:
#print('ici on est dans le cas ou i vaut =', i, '\n')
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + symbol
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + symbol
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + symbol
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + symbol
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print('L_ceof_dec_treated[i] = ', L_ceof_dec_treated[i], '\n')
elif i == deg_P:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
#print(' L_ceof_dec_treated[',i,'] = ', L_ceof_dec_treated[0], '\n')
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
#print(' L_ceof_dec_treated[',i,'] = ', L_ceof_dec_treated[i], '\n')
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+' + str(L_coef_dec[i])+ '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
#print(' L_ceof_dec_treated[',i,'] = ', L_ceof_dec_treated[i], '\n')
#print(' L_ceof_dec_treated[', i, '] = ', L_ceof_dec_treated[i], '\n')
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print('String_ceof_dec_treated = ', String_ceof_dec_treated, '\n')
else:
#print('i = ', i, '\n')
#print('L_coef_dec[', i, '] = ', L_coef_dec[i], '\n')
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
elif L_coef_dec[i] == 0:
L_ceof_dec_treated[i] = '' #+ '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+' + str(L_coef_dec[i]) + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print(' L_ceof_dec_treated[', i, '] = ', L_ceof_dec_treated[i], '\n')
#print('String_ceof_dec_treated = ', String_ceof_dec_treated, '\n')
Poly_inc_monomials_latex = String_ceof_dec_treated
return Poly_inc_monomials_latex#1#Result
##===========================================================================================
##===========================================================================================
# Début des essais
##===========================================================================================
##===========================================================================================
# W = Symbol('W')
# # P = Poly(2*X**3 - 2*X**2 + 7*X -4, X)
# # L_coef_de_P = P.all_coeffs()
# # R = P.rep.rep
# # print('P(X) =' , P,'\n')
# # print('coeff de P ds l exemple =' , L_coef_de_P,'\n')
# # print('P.rep.rep =' , R,'\n')
# Soly = Poly([2, 1, -3, 1], W)
# print('Soly =' , Soly,'\n')
# L_coef_de_Soly = Soly.all_coeffs()
# print('je suis ici Soly(X) =' , Soly,'\n')
# print('Soly.all_coeffs() =', L_coef_de_Soly,'\n')
# E_Soly = Ecriture_Poly_en_Latex_inc(Soly,symbol)
# print('E_Soly =', E_Soly ,'\n')
# Q = Poly(-2 + 2*X + 3*X**3 + X**4, X)
# print('Q(X) =' , Q,'\n')
# L_coef_de_Q = Q.all_coeffs()
# print('coeff de Q ds l exemple =' , L_coef_de_Q,'\n')
# T = Add(-5*X**3, -X**2, 2*X, +3, evaluate=False)
# PolyT = Poly(T, X)
# print('PolyT =' , PolyT,'\n')
# L_coef_de_PolyT = PolyT.all_coeffs()
# print('PolyT(X) =' , PolyT,'\n')
# print('PolyT.all_coeffs() =', L_coef_de_PolyT,'\n')
#E_T = Ecriture_Poly_en_Latex_inc(PolyT,symbol)
#print(Ecriture_Poly_en_Latex_inc(S,symbol))
#print(E_S)
# symbol = 'Y'
# E = Ecriture_Poly_en_Latex_inc(P,symbol)
#Q = Poly(X**3 + 2*X**2 + 3*X -4, X)
#F = Ecriture_Poly_en_Latex_inc(Q,symbol)
# E_0 = E[0]
# print('E_0 =' , E_0,'\n')
# E_1 = E[1]
# print('E_1 =' , E_1,'\n')
# print('E_2 =' , E_2,'\n')
##===========================================================================================
##===========================================================================================
# Fin des essais
##===========================================================================================
##===========================================================================================
##===========================================================================================
##===========================================================================================
#
#
# New fction
#
##===========================================================================================
##=========================================================================================
[docs]
def Ecriture_Poly_en_Latex_v2(P,symbol):
""" Renvoie une liste de deux éléments: chacun de ces élements donne
le polynôme P, écrit en Tex, avec symbol (qui est une chaine de caractères) comme indéterminée
etles monômes sont donnés par ordre:
-décroissant décroissant dans la deuxième liste
-croissant dans la première liste
"""
X = Symbol(symbol)
deg_P = degree(P)
L_coef_dec = P.rep.rep
P_all_coeffs = P.all_coeffs()
if L_coef_dec != P_all_coeffs:
raise('Pbm attention les coef du polynôme ne seront pas dans l ordre', '\n')
else:
Poly_dec_monomials_latex = Ecriture_Poly_en_Latex_dec(P,symbol)
Poly_inc_monomials_latex = Ecriture_Poly_en_Latex_inc(P,symbol)
U = []
U.append(Poly_dec_monomials_latex)
U.append(Poly_inc_monomials_latex)
return U
##===========================================================================================
##===========================================================================================
# Début des essais
##===========================================================================================
##===========================================================================================
# X= Symbol('X')
# # P = Poly(2*X**3 - 2*X**2 + 7*X -4, X)
# # L_coef_de_P = P.all_coeffs()
# # print('P(X) =' , P,'\n')
# # print('coeff de P ds l exemple =' , L_coef_de_P,'\n')
# S = Poly([-4, 7, 1, 1], X)
# print('S =' , S,'\n')
# L_coef_de_S = S.all_coeffs()
# print('S(X) =' , S,'\n')
# print('S.all_coeffs() =', L_coef_de_S,'\n')
# symbol = 'Z'
# E_S = Ecriture_Poly_en_Latex_v2(S,symbol)
# E_S_0 = E_S[0]
# E_S_1 = E_S[1]
# print('Ecriture_Poly_en_Latex_v2[0] =' , E_S[0], '\n')
# print('Ecriture_Poly_en_Latex_v2[0] =' , E_S[1], '\n')
##===========================================================================================
##===========================================================================================
# Fin des essais
##===========================================================================================
##===========================================================================================
##===========================================================================================
##===========================================================================================
#
#
# New fction
#
##===========================================================================================
##=========================================================================================
[docs]
def Ecriture_Poly_of_Matrix_en_Latex(P, Name_Matrix, Size_Matrix):
""" Renvoie une liste de deux éléments: chacun de ces élements donne
le polynôme P(Name_Matrix), écrit en Tex, et dont les monômes sont donnés
par ordre:
-croissant dans la première liste
-décroissant décroissant dans la deuxième liste
"""
Name_Matrix = str(Name_Matrix)
p = Size_Matrix
L = P.all_coeffs()
#U = L[0]
#U_latex = str(L[0])
if L[0] == 0:
U_latex = ''
else:
U_latex = str(L[0]) + 'I_'+ str(p)
V_latex = ""
#print('U_latex =' , U_latex,'\n')
symb = []
for j in range(0,len(L),1):
if j == 0:
a ='I_'+ str(p)
symb.append(a)
elif j == 1:
symb.append(Name_Matrix)
else:
a = Name_Matrix +'^{'+ str(j) +'}'
symb.append(a)
for j in range(len(L)-1,-1,-1):
#V_latex = V_latex + str(L[j]) + symbol+'^{'+ str(j) +'}'
#print('V_latex1 =' , V_latex,'\n')
if j == len(L)-1:
if L[j] < 0 or L[j] == -1:
if L[j] == -1:
V_latex = V_latex + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
V_latex = V_latex + str(L[j]) + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j, ' =' , V_latex,'\n')
elif L[j] == 1:
V_latex = V_latex + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
elif L[j] == 0:
V_latex = V_latex
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
V_latex = V_latex + '-' + str(L[j]) + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
if L[j] < 0 or L[j] == -1:
if L[j] == -1:
V_latex = V_latex + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
V_latex = V_latex + str(L[j]) + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
elif L[j] == 0:
V_latex = V_latex
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
elif L[j] == 1:
V_latex = V_latex + '+' + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
else:
V_latex = V_latex + '+' + str(L[j]) + symb[j]#ol+'^{'+ str(j) +'}'
#print('V_latex', len(L)-1-j,' =' , V_latex,'\n')
for i in range(1,len(L),1):
#U = U + L[i]*(X**i)
if i == 1:
if L[1] < 0 or L[1] == -1:
if L[1] == -1:
U_latex = U_latex + Name_Matrix
#print('U_latex1 =' , U_latex,'\n')
else:
U_latex = U_latex + str(L[1]) + Name_Matrix
#print('U_latex2 =' , U_latex,'\n')
elif L[1] == 1:
U_latex = U_latex + '+' + Name_Matrix
#print('U_latex 3=' , U_latex,'\n')
elif L[1] == 0:
U_latex = U_latex
#print('U_latex 3=' , U_latex,'\n')
else:
U_latex = U_latex + '+' +str(L[1]) + Name_Matrix
#print('U_latex4 =' , U_latex,'\n')
else:
if L[i] < 0 or L[i] == -1:
if L[i] == -1:
U_latex = U_latex + Name_Matrix+'^{'+ str(i) +'}'
#print('U_latex5 =' , U_latex,'\n')
else:
U_latex = U_latex + str(L[i]) + Name_Matrix+'^{'+ str(i) +'}'
#print('U_latex6 =' , U_latex,'\n')
elif L[i] == 0:
U_latex = U_latex
#print('U_latex 3=' , U_latex,'\n')
elif L[i] == 1:
U_latex = U_latex + '+' + Name_Matrix+'^{'+ str(i) +'}'
#print('U_latex7 =' , U_latex,'\n')
else:
U_latex = U_latex + '+' + str(L[i]) + Name_Matrix+'^{'+ str(i) +'}'
#print('U_latex8 =' , U_latex,'\n')
X_latex = U_latex
Y_latex = V_latex
Result = [X_latex, Y_latex]
return Result
##===========================================================================================
##===========================================================================================
# Début des essais
##===========================================================================================
##===========================================================================================
# X= Symbol('X')
# P = Poly(2*X**3 - 2*X**2 + 7*X -4, X)
# print('Ds cet exemple, on a P(X) = ',P, '\n')
# Name_Matrix = 'Q'
# Size_Matrix = 3
# E = Ecriture_Poly_of_Matrix_en_Latex(P, Name_Matrix, Size_Matrix)
# E_0 = E[0]
# print('E_0 =' , E_0,'\n')
# E_1 = E[1]
# print('E_1 =' , E_1,'\n')
# # print('E_2 =' , E_2,'\n')
##===========================================================================================
##===========================================================================================
# Fin des essais
##===========================================================================================
##===========================================================================================
##########################################################################################################################################################################################
##
## New Function
##
##########################################################################################################################################################################################
##########################################################################################################################################################################################
##
## New Function
##
##########################################################################################################################################################################################
[docs]
def Ecriture_Poly_of_Matrix_en_Latex_dec(P, Name_Matrix, Size_Matrix):
""" Renvoie le polynôme P('Name_Matrix'), écrit en Tex, et dont les monômes sont donnés
par ordre décroissant
-P est un polynôme
-Name_Matrix est une chaine de caractères (nom de la matrice carée dont il est question)
-Size_Matrix est la taille de la matrice carrée nommée Name_Matrix
"""
Name_Matrix = str(Name_Matrix)
p = Size_Matrix
#X = Symbol(symbol)
deg_P = degree(P)
Id_p = 'I'+"_"+'{'+str(p)+'}'
L_coef_dec = P.rep.rep
P_all_coeffs = P.all_coeffs()
if L_coef_dec != P_all_coeffs:
raise('Pbm attention les coef du polynôme ne seront pas dans l ordre', '\n')
else:
#print('L_coef_dec = ', L_coef_dec, '\n')
String_ceof_dec_treated = ''
L_ceof_dec_treated = ['']*(1+deg_P)
for i in range(0, deg_P+1, 1):
if i == 0:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '{' + Name_Matrix + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == 0:
toto = 2#
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print(String_ceof_dec_treated, '\n')
elif i == deg_P-1:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + Name_Matrix #'{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + + Name_Matrix # '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-1) + '}'
elif L_coef_dec[i] == 0:
toto = 2#L_ceof_dec_treated[i] = ''
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+' + str(L_coef_dec[i]) + Name_Matrix
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + Name_Matrix # #+ '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print(String_ceof_dec_treated, '\n')
elif i == deg_P:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + Name_Matrix
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + Name_Matrix
elif L_coef_dec[i] == 0:
toto = 2#L_ceof_dec_treated[i] = ''
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+'+ str(L_coef_dec[i]) + Id_p #+ symbol #'{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + Id_p#+ symbol # #+ '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print(String_ceof_dec_treated, '\n')
else:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == 0:
toto = 2#L_ceof_dec_treated[i] = '' #+ '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] > 0 and L_coef_dec[i] != 1:
L_ceof_dec_treated[i] = '+' + str(L_coef_dec[i]) + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print(String_ceof_dec_treated, '\n')
Poly_dec_monomials_latex = String_ceof_dec_treated
return Poly_dec_monomials_latex#1#Result
##===========================================================================================
##===========================================================================================
# Début des essais
##===========================================================================================
##===========================================================================================
# X= Symbol('X')
# P = Poly(2*X**3 + 9*X -4, X)
# print('Ds cet exemple, on a P(X) = ',P, '\n')
# Name_Matrix = 'Q'
# Size_Matrix = 3
# F = Ecriture_Poly_of_Matrix_en_Latex_dec(P, Name_Matrix, Size_Matrix)
# print('F =' , F,'\n')
##===========================================================================================
##===========================================================================================
# Fin des essais
##===========================================================================================
##===========================================================================================
##===========================================================================================
##===========================================================================================
# New Function
##===========================================================================================
##===========================================================================================
[docs]
def Ecriture_Poly_of_Matrix_en_Latex_inc(P, Name_Matrix, Size_Matrix):
""" Renvoie le polynôme P('Name_Matrix'), écrit en Tex, et dont les monômes sont donnés
par ordre croissant
-P est un polynôme
-Name_Matrix est une chaine de caractères (nom de la matrice carée dont il est question)
-Size_Matrix est la taille de la matrice carrée nommée Name_Matrix
"""
#Name_Matrix = str(Name_Matrix)
p = Size_Matrix
deg_P = degree(P)
Id_p = 'I'+"_"+'{'+str(p)+'}'
L_coef_dec = P.rep.rep
P_all_coeffs = P.all_coeffs()
if len(L_coef_dec) == 0 or len(P_all_coeffs) == 0:
raise('Pbm attention aucun coefficient non nul', '\n')
else:
toto =2
if L_coef_dec != P_all_coeffs:
raise('Pbm attention les coef du polynôme ne seront pas dans l ordre', '\n')
else:
#print('L_coef_dec = ', L_coef_dec, '\n')
L_coef_dec = Reverse_List(L_coef_dec)
#print('L_coef_dec = ', L_coef_dec, '\n')
counter_zeros = 0
for i in range(0,len(L_coef_dec),1):
if L_coef_dec[i] == 0:
counter_zeros = counter_zeros +1
else:
toto = 2
alpha = counter_zeros# c'est le nbre de coefs nuls en partant du coef de puissance 0
#print('alpha = ', alpha, '\n')
String_ceof_dec_treated = ''
L_ceof_dec_treated = ['']*(1+deg_P)
for i in range(0, deg_P+1, 1):
if i == 0:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = Id_p
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + Id_p #+ symbol #'{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] == 0:
L_ceof_dec_treated[i] = ''
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + Id_p #+ symbol # #+ '{' + symbol + '}'+ '^'+ '{'+ str(i) + '}'
#print(' L_ceof_dec_treated[', i, '] = ', L_ceof_dec_treated[i], '\n')
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print('String_ceof_dec_treated = ', String_ceof_dec_treated, '\n')
elif i == counter_zeros and counter_zeros > 1:
#print('ici on est dans le cas ou i vaut =', i, '\n')
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print('L_ceof_dec_treated[i] = ', L_ceof_dec_treated[i], '\n')
elif i == 1:
#print('ici on est dans le cas ou i vaut =', i, '\n')
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + Name_Matrix
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + Name_Matrix
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+' + str(L_coef_dec[i]) + Name_Matrix
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + Name_Matrix
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print('L_ceof_dec_treated[i] = ', L_ceof_dec_treated[i], '\n')
elif i == deg_P:
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
#print(' L_ceof_dec_treated[',i,'] = ', L_ceof_dec_treated[0], '\n')
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
#print(' L_ceof_dec_treated[',i,'] = ', L_ceof_dec_treated[i], '\n')
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+' + str(L_coef_dec[i])+ '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
#print(' L_ceof_dec_treated[',i,'] = ', L_ceof_dec_treated[i], '\n')
#print(' L_ceof_dec_treated[', i, '] = ', L_ceof_dec_treated[i], '\n')
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print('String_ceof_dec_treated = ', String_ceof_dec_treated, '\n')
else:
#print('i = ', i, '\n')
#print('L_coef_dec[', i, '] = ', L_coef_dec[i], '\n')
if L_coef_dec[i] == 1:
L_ceof_dec_treated[i] = '+' + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
elif L_coef_dec[i] == -1:
L_ceof_dec_treated[i] = '-' + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
elif L_coef_dec[i] == 0:
L_ceof_dec_treated[i] = '' #+ '{' + symbol + '}'+ '^'+ '{'+ str(deg_P-i) + '}'
elif L_coef_dec[i] > 0:
L_ceof_dec_treated[i] = '+' + str(L_coef_dec[i]) + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
else:
L_ceof_dec_treated[i] = str(L_coef_dec[i]) + '{' + Name_Matrix + '}'+ '^'+ '{'+ str(i) + '}'
String_ceof_dec_treated = String_ceof_dec_treated + str(L_ceof_dec_treated[i])
#print(' L_ceof_dec_treated[', i, '] = ', L_ceof_dec_treated[i], '\n')
#print('String_ceof_dec_treated = ', String_ceof_dec_treated, '\n')
Poly_inc_monomials_latex = String_ceof_dec_treated
return Poly_inc_monomials_latex#1#Result
##===========================================================================================
##===========================================================================================
# Début des essais
##===========================================================================================
##===========================================================================================
# X= Symbol('X')
# P = Poly(2*X**3 - 2*X**2 + 7*X -4, X)
# print('Ds cet exemple, on a P(X) = ',P, '\n')
# Name_Matrix = 'Q'
# Size_Matrix = 3
# E = Ecriture_Poly_of_Matrix_en_Latex_inc(P, Name_Matrix, Size_Matrix)
# print('E =' , E,'\n')
##===========================================================================================
##===========================================================================================
# Fin des essais
##===========================================================================================
##===========================================================================================
############################################################################################## Fin des essais ############################################################################################
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
############################################################################################## Fin des essais ############################################################################################
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
############################################################################################## Fin des essais ############################################################################################
##########################################################################################################################################################################################
##
## Début des essais
##
##########################################################################################################################################################################################
##########################################################################################################################################################################################
##
## Fin des essais
##
##########################################################################################################################################################################################
# def IrreRatioLatex(p,q):
# "Renvoie, sous la forme d'une chaîne de caractère latex, la fraction p/q, sous forme de fraction irréductible"
# s = 0
# if q == 0:
# raise('Pbm, le dénominateur ne peut pas être nul', '\n')
# else:
# d = gcd(p,q)
# p = p//d
# q = q//d
# if p < 0 & q < 0:
# p = -p
# q = -q
# a = '-'
# elif p > 0 & q < 0:
# p = p
# q = -q
# a = '-'
# elif p < 0 & q > 0:
# p = -p
# q = q
# a = '-'
# else:
# p = p
# q = q
# a = ' '
# s = a + str(p) + '/' + str(q)
# t = IrreRatioLatex(2,3)
# r = IrreRatioLatex(-2,3)
# w = IrreRatioLatex(2,-3)
# j = IrreRatioLatex(-2,-3)
# print('t =', t, 'r =', r, 'w =', w, 'j =', j, '\n')