##!/usr/bin/env python3
# # -*- coding: utf-8 -*-
# """
# Created on Thu Mar 17 19:11:52 2022
# @author: jlebovits
# """
from __future__ import division
import random
import sys
from copy import deepcopy
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 *
import src.scripts.Mes_fctions.Mes_fctions_probabilistes
from src.scripts.Mes_fctions.Mes_fctions_probabilistes import *
import src.scripts.Mes_fctions.Mes_fctions_d_ecriture_Latex
from src.scripts.Mes_fctions.Mes_fctions_d_ecriture_Latex import *
import src.scripts.Mes_fctions.Mes_fctions_d_alg_generale
from src.scripts.Mes_fctions.Mes_fctions_d_alg_generale import *
import sympy
from random import uniform, Random, randrange, randint
from random import *
from functools import reduce
import numpy.random as npr
import numpy.linalg as alg
import numpy as np
from sympy import *
from sympy.stats import *
from random import uniform, Random, randrange, randint
from sympy.stats import P, E, variance, Die, Normal
from sympy import Eq, simplify
import random
import sympy
from sympy import *
from sympy.stats import *
from random import uniform, Random, randrange, randint
from sympy.stats import P, E, variance, Die, Normal
from sympy import Eq, simplify
from random import uniform, Random, randrange, randint
from random import *
from functools import reduce
import numpy.random as npr
import numpy.linalg as alg
import numpy as np
import math
from random import uniform, Random, randrange, randint
#import numpy as np
#import numpy.random as npr
from sympy import *
from random import *
from sympy.stats import *
# from sympy import Eq, simplify, S, Symbol, Rational, binomial, expand_func
from sympy.stats import P, E, variance, Die, Normal, DiscreteUniform, Bernoulli, sample, Binomial, density, Normal, sample_iter, given
from sympy import Piecewise, log, piecewise_fold
from sympy import S, Symbol
from random import uniform, Random, randrange, randint
from sympy import Eq, simplify, S, Symbol
from sympy import MatrixSymbol, Transpose, transpose
from sympy.abc import x, y
import numpy as np
import numpy.random as npr
inf=float("inf")
import random
#print('toto')
[docs]
def prenom():
print("dfRonandd")
[docs]
def alg_lineaire() :
chaine = "alg lineaire Ok"
return chaine
# X = Symbol('X')
# Eerevfdvdf = Poly_with_random_coef_v2('X',2,0)
# E_1 = E[0]
# E_2 = E[1]
# E_3 = E[2]
# #
# D = Poly_with_random_coef_v2('X',1,1)
# D_1 = D[0]
# D_2 = D[1]
# D_3 = D[2]
# S_X = E_1*D_1
# print('S_X =', S_X, '\n')
###############################################
[docs]
def diag_tst(res_eigenvects):
""" En: Checks if for each eigenvalue the multiplicity equals the dimension of the associated eigenspace.
Fr: Vérifie si pour chaque valeur propre la multiplicité égale à la dimension du sous espace propre associé """
for vp in res_eigenvects:
if vp[1] != len(vp[2]):
return False
return True
[docs]
class nondiago(Exception):
pass
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def diag_sympy(M):
"""
En: Tests if a matrix is diagionalizable by checking if for each eigenvalue the multiplicity
equals the dimension of the associated eigenspace. If M is s-diagonalizable returns (D,P), which is as a list.; i.e.
D = diag_sympy(M)[0] and P = diag_sympy(M)[1].
Fr: Teste si M est diagonalisable. Si c'est le cas, renvoie la matrice diagonale D ainsi que la matrice de passage P
présentée sous la forme d'une liste de D = diag_sympy(M)[0] et P = diag_sympy(M)[1].
"""
VP = M.eigenvects()
if diag_tst(VP) == False:
#raise "la matrice n'est pas diagonalisable"
raise nondiago("la matrice n'est pas diagonalisable")
d=M.shape
u=d[1] #prend le nombre de lignes vu que la matrice M est carrée c'est bon!
D = Matrix(zeros(u))
#D = zeros(M.shape)
P = Matrix(zeros(u))
k=0
for i in range(len(VP)):
#si multiplicité >1
for j in range(VP[i][1]):
D[k,k]= VP[i][0]
#vecteur propre dans la matrice de passage
P[:,k:k+1] = VP[i][2][j]
k=k+1
return (D, P)
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# M = Matrix([[1, 0, 0], [0, 5, 1], [0, 0, 3]])
# C = diag_sympy(M)
# print('C =', C, '\n')
# print('C[0] =', C[0], '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def puissance_exact(M,p):
"""
En: Reurns the p^th power of Matrix M. \\i.e. M^p.
Fr: .
"""
# 1. Il faut que la matrice soit carrée pour calculer sa puissance n
if M.shape[0] != M.shape[1]:
#raise "la matrice n'est pas diagonalisable"
raise "La matrice n'est pas diagonalisable"
taille_mat = M.shape[0]
#Diagonalisation formelle
(D,P) = diag_sympy(M)
for i in range(taille_mat):
D[i,i] = D[i,i]**p
return P*D*P.inv()
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def mat_element(p,q,i,j):
""" En: Renvoie la matrice élémentaire de p lignes et q colonnes avec un 1 à la place i,j.
Returns the elementary matrix with p rows and q columns with a 1 at position (i, j).
Fr: Renvoie la matrice élémentaire de p lignes et q colonnes avec un 1 à la place i,j."""
if i > p or j>q:
raise "l'indice de ligne ou de colonne est trop grand"
else:
M = Matrix(zeros(p, q))
M[i-1,j-1]=1
return M
[docs]
def Cptrzeros(M):
"""En: Counts the number of zero entries in the given matrix M.
cpte le nombre de coefficients nuls dans une matrice donnée"""
cptr = 0
p = M.cols
q = M.rows
for i in range(p):
for j in range(q):
if M[i,j] == 0:
cptr = cptr + 1
return cptr
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randmatrixrect(p,q,a,b):
"""Returns a rectangular matrix with p rows and q columns such that every coefficient is a realization of
of a discrete random variable on range(a, b)
:returns: LaTeX bmatrix as a string
"""
M= eye(p,q)
for i in range(p):
for j in range(q):
#print('(i,j) =', i,j,'\n')
#M[i,j] = next(sample(DiscreteUniform('h', range(a, b))))
M[i,j] = sample(DiscreteUniform('h', range(a, b)))
# M[i,j] = next(sample(DiscreteUniform('h', range(a, b)))) for i in range(p) for j in range(p)]
return M
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randmatrix(p,a,b):
"""Returns a square matrix of size p such that every coefficient is a realization of
of a uniform discrete random variable within the range(a,b)
"""
M = randmatrixrect(p,p,a,b)
return M
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randmatrixdiagonale(p,a,b):
"""
Returns a square diagonal matrix of size p such that every coefficient is a
realization of a uniform discrete random variable, the range of which is range(a, b)
"""
D= eye(p)
for i in range(p):
for j in range(p):
if j==i:
D[i,j] = sample(DiscreteUniform('h', range(a, b)))
else:
D[i,j] = 0
return D
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randmatrixdiagonalesorted(p,a,b):
"""Returns a square diagonal matrix, denoted D, of size p, such that every coefficient is a realization of
a uniform discrete random variable in range(a, b).
Moreover, the eigen values of D are sorted in the increasing order
"""
U = DiscreteUniform('U', list(range(a,b,1))) # distribution over the range -9 to 10
L = [] # Liste qui va contenir toutes les valeurs propres de la matrice diagonale
cpteur_de_zero_dans_L = 0
for i in range(0,p,1):
g = sample(U)
L.append(g)
if g ==0:
cpteur_de_zero_dans_L = 1 + cpteur_de_zero_dans_L
else:
c=2
# a ce stade L contient la liste de toutes les valeurs propres répétées
# autant de fois qu'elles apparaissent
Lordo = sorted(L)
D =Matrix(zeros(p,p))
for i in range(0,p,1):
D = D + (Lordo[i])*mat_element(p,p,i+1,i+1)
return D
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# D = randmatrixdiagonalesorted(2,-5,6)
# print('Ddez =', D, '\n')
# #print('fin')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
########################################################################
[docs]
def randmatrixdiagonaleinversible(p,a,b):
"""Returns a square invertible diagonal matrix of size p such that every
coefficient is a realization of a uniform discrete random variable in the range (a, b).
"""
D= eye(p)
for i in range(p):
for j in range(p):
if j==i:
t=sample(DiscreteUniform('h', range(a, b)))
while t == 0:
t = sample(DiscreteUniform('h', range(a, b)))
D[i,j] = t
else:
D[i,j] = 0
return D
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randmatrixInvnew(p,a,b,r):
"""En: Returns an invertible square matrix of size p, with r percent of non-zero entries
(thus [r.p]+1 non-zero elements), and all entries are between a and b-1.
Retourne une matrice carrée de taille p, inversible et dont le nbre de coefficients non nuls est de r
pourcent (donc en fait [r.p]+1 éléments non nuls) et dont tous les coefficients sont compris
entre a et b-1"""
alphaprimeo = r*p*p/100
alphaprime = int(r*p*p/100)
alphaprimeseconde = alphaprimeo -alphaprime
H = eye(p)
S = eye(p)
if alphaprimeseconde < 1/2:
alpha = alphaprime
#print('alpha = ', alpha)
else :
alpha= alphaprime +1
#print('alpha = ', alpha)
# if alphaprime == p**2:
# alpha= p**2 #Nbre de coefficients qui devront être non nuls dans P
# else :
# alpha= int(r*p*p/100)+1 #Nbre de coefficients qui devront être non nuls dans P
beta=p**2 - alpha #Nbre de coefficients qui devront être nuls dans P
#print('beta = ', beta)
if alpha < p:
print('r is too small! Choose a greater value for r.')
else :
P = randmatrix(p,a,b)
q= P.det()
#print('(P,det(P)) = ', P, P.det())
#q= P.det()-q
#print('q = ', q)
rho = 0
while q == 0:
P = randmatrix(p,a,b)
q = P.det()
#print('q = ', q)
rho = rho+1
# A ce stade la matrice P est inversible
# On veut que P ait exactement alpha coef non nuls et p^2-alpha nulles.
#print('rho = ', rho) #Donc si rho = 0 c'est qu'on n'est pas rentré dans la boucle et que la matrice est inversible depuis le début
#print('P = ', P, ' et det(P) = ', P.det())
cptrzeros = Cptrzeros(P)
#print('cptrzeros = ', Cptrzeros(P))
#print(' cptrzeros =', cptrzeros)
# A ce stade cpt rzeros est égal au nombre de coefs nuls contenus dans P
# return P#cptrzeros
if cptrzeros == beta:
H = P
#print(' cptrzeros =', cptrzeros)
else :
if cptrzeros < beta: #Donc ici la matrice P a trop peu de zéros, il faut en rajouter.
while cptrzeros < beta:
for i in range(p):
if cptrzeros == beta:
break
else :
for j in range(p):
if cptrzeros == beta:
break
else :
if P[i,j] != 0:
S=P-P[i,j]*mat_element(p,p,i+1,j+1)
if S.det() != 0:
P=S
cptrzeros = Cptrzeros(P)
#print('P = ', P)
#cptrzeros = cptrzeros +1
#print('cptrzeros = ', cptrzeros)
H = P
else : #Donc ici la matrice P a trop de zéros, il faut en retirer.
while cptrzeros > beta:
for i in range(p):
if cptrzeros == beta:
break
else :
for j in range(p):
if cptrzeros == beta:
break
else :
if P[i,j] == 0:
S=P+mat_element(p,p,i+1,j+1)
if S.det() != 0:
P=S
cptrzeros = cptrzeros -1
H = P
#print(' cptrzeros =', cptrzeros)
#return P
return H
#q=randmatrixInvnew(3,-9,10,100)
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randmatrixInvnewparpaquet(n,p,a,b,r):
"""Returns a list of n invertible square matrices of size p, with r percent of non-zero entries (rounded up if the decimal is >= 0.5 and down otherwise).
Additionally, all entries are between a and b-1, and the positions of zero entries are chosen randomly among all possible positions.
Retourne une liste de n matrices carrées de taille p, inversible,
et dont le nbre de coefficients non nuls est de r pourcent (arrondi à la décimale supérieure si elle >=0.5 et infériure sinon.
De plus tous les coefficients sont compris entre a et b-1. Enfin l'emplacement de chaque coef nul est choisi
aléatoirement parmi tous les emplacements de coefficients."""
liste=[]
for i in range(n):
c=randmatrixInvnew(p,a,b,r)
liste.append(c)
#M[i,j] = next(sample(DiscreteUniform('h', range(a, b))))
#print('liste[',i,']=',liste[i])
return liste
##l=randmatrixInvnewparpaquet(2,3,-9,10,100)
##print('Nous avons: l= ', l)
##print('Nous avons: l[0]= ', l[0])
##print('Nous avons: l[1]= ', l[1])
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def selectRandom(names):
"""
Sélectionne au hasard un élément dans une liste
"""
return choice(names)
# return random.choice(names)
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randmatrixInvnewzerosaleatoire(p,a,b,r):
"""Returns an invertible square matrix of size p, with r/100 non-zero entries (rounded up if the decimal is >= 0.5 and down otherwise).
Additionally, all entries are between a and b-1, and the positions of zero entries are chosen randomly among all possible positions.
Retourne une matrice carrée de taille p, inversible,
et dont le nbre de coefficients non nuls est de r/100 (arrondi à la décimale supérieure si elle >=0.5 et inférieure sinon.
De plus tous les coefficients sont compris entre a et b-1. Enfin l'emplacement de chaque coef nul est choisi
aléatoirement parmi tous les emplacements de coefficients."""
alphaprimeo = r*p*p/100
alphaprime = int(r*p*p/100)
alphaprimeseconde = alphaprimeo -alphaprime
H = eye(p)
S = eye(p)
l1=list(range(1,10))
#print('l1 = ', l1)
l2=list(range(-9,0))
l2.reverse()
l3=[]
#l1[9:9]=l2 # A ce stade, on a: l1=[1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -2, -3, -4, -5, -6, -7, -8, -9]
for i in range(0,9):
m=l1[i]
n=l2[i]
l3.append(m)
l3.append(n)
#print('l3 = ', l3) # A ce stade l3 = [1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, -6, 7, -7, 8, -8, 9, -9]
if alphaprimeseconde < 1/2:
alpha = alphaprime
#print('alpha = ', alpha)
else :
alpha= alphaprime +1
#print('alpha = ', alpha)
# if alphaprime == p**2:
# alpha= p**2 #Nbre de coefficients qui devront être non nuls dans P
# else :
# alpha= int(r*p*p/100)+1 #Nbre de coefficients qui devront être non nuls dans P
beta=p**2 - alpha #Nbre de coefficients qui devront être nuls dans P
#print('beta = ', beta)
if alpha < p:
print('r is too small! Choose a greater value for r.')
else :
P = randmatrix(p,a,b)
#print('La matrice de départ est: ', P)
q= P.det()
#print('(P,det(P)) = ', P, P.det())
#q= P.det()-q
#print('q = ', q)
#rho = 0
while q == 0:
P = randmatrix(p,a,b)
q = P.det()
#print('q = ', q)
# A ce stade la matrice P est inversible
# On veut que P ait exactement alpha coef non nuls et p^2-alpha nulles.
#print('rho = ', rho) #Donc si rho = 0 c'est qu'on n'est pas rentré dans la boucle et que la matrice est inversible depuis le début
#print('P = ', P, ' et det(P) = ', P.det())
cptrzeros = Cptrzeros(P)
#print('cptrzeros = ', Cptrzeros(P)) #A ce stade cptr zeros est égal au nombre de coefs nuls contenus dans P
L=[]
for i in range(p):
for j in range(p):
L.append([i,j])
#print('L =', L)
#A ce stade on a L= [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]
if cptrzeros == beta:
H = P
#print(' cptrzeros =', cptrzeros)
else :
if cptrzeros < beta: #Donc ici la matrice P a trop peu de zéros, il faut en rajouter.
while cptrzeros < beta:
if cptrzeros == beta or len(L) == 0:
break
else:
h=choice(L)
s=h[0]
t=h[1]
if P[s,t] != 0:
for i in l3 :
S=P-P[s,t]*mat_element(p,p,s+1,t+1)
if S.det() != 0:
P=S
cptrzeros = Cptrzeros(P)
L.remove([s,t])
#u = 3*s+t#print(' P[',s,',',t,'] =', P[s,t])
#del L[u]
break
H = P
else : #Donc ici la matrice P a trop de zéros, il faut en retirer.'
while cptrzeros > beta:
if cptrzeros == beta or len(L) == 0 :
break
else :
h=choice(L)
s = h[0]
t = h[1]
if P[s,t] == 0:
for i in l3 :
S = P+i*mat_element(p,p,s+1,t+1)
if S.det() != 0:
P=S
cptrzeros = Cptrzeros(P)
L.remove([s,t])
#u = 3*s+t#print(' P[',s,',',t,'] =', P[s,t])
#del L[u]
break
H = P
# P = randmatrix(p,a,b)
# H = P
#print(' cptrzeros =', cptrzeros)
#return P
return H
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randdiagomatrixeigvaluesorted(p, a, b, aprime, bprime, pourcent):
""" Returns a square diagonalizable matrix of size p, the coefficients of which are randomly chosen.
More precisely, we start from a diagonal matrix D (with increasing eigen values, all between a and b). Then we define
M = P^-1 D P, where P is an invertible matrix (obtained by using
P = randmatrixInvnewzerosaleatoire(p,aprime,bprime, pourcent, exprimé en 45 si c'est 45% d'entrées non nulles dans P) )
returns M
"""
D = randmatrixdiagonalesorted(p,a,b)
#print('D =', D, '\n')
P = randmatrixInvnewzerosaleatoire(p,aprime,bprime,pourcent)
while P == eye(p, p):
P = randmatrixInvnewzerosaleatoire(p,aprime,bprime,pourcent)
#print('P=',P,'\n')
M = P*D*P.inv()
return M
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# M = randdiagomatrixeigvaluesorted(2, -5, 6, -9, 10, 68)
# print('M =', M, '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
# def IndicatricefunctionRV(Q,s): #C'est i1_(-\infty,s)(Q) avec Q r.v.
# def indifunction(s,t):
# b=Piecewise((1, x <= s), (0, x > s))
# c=b.subs(x,t) #i.e. c=i1_(-\infty,s)(t)
# return c;
# b = indifunction(s,Q)
# return b;
##################################################################### x\mpasto i1_{[alpha,beta]]}(x)
# def indifunctionintervalle(alpha,beta,t):
# #b=Piecewise((1, ( (x <= beta) and (x >= alpha) )), (0, ((x > beta) or (x < alpha))) )
# b=Piecewise( (1, x <= beta ), (0, x > beta) )
# bprime =Piecewise( (1, x >= alpha ), (0, x < alpha) )
# d=b*bprime
# c=d.subs(x,t)
# return c
#########################
# def AbsRV(Q): #C'est |Q| avec Q r.v.
# def abs(t):
# b=Piecewise((1, x >= 0), (0, x < 0))
# c=b.subs(x,t) #i.e. c=i1_[0,\infty)(t)
# return c;
# b=Q*abs(Q)-Q*abs(-Q)
# return b
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randmatrixInvnewzerosaleatoireparpaquet(n,p,a,b,r):
"""Returns a list of n invertible square matrices of size p, with r/100 non-zero entries (rounded up if the decimal is >= 0.5 and down otherwise).
Additionally, all entries are between a and b-1, and the positions of zero entries are chosen randomly among all possible positions.
Retourne une liste de n matrices carrées de taille p, inversible,
et dont le nbre de coefficients non nuls est de r/100 (arrondi à la décimale supérieure si elle >=0.5 et infériure sinon.
De plus tous les coefficients sont compris entre a et b-1. Enfin l'emplacement de chaque coef nul est choisi
aléatoirement parmi tous les emplacements de coefficients."""
liste=[]
for i in range(n):
c=randmatrixInvnewzerosaleatoire(p,a,b,r)
liste.append(c)
#print('liste[',i,']=',liste[i])
return liste
##l=randmatrixInvnewzerosaleatoireparpaquet(2,3,-9,10,100)
##print('Nous avons: l= ', l)
##print('Nous avons: l[0]= ', l[0])
##print('Nous avons: l[1]= ', l[1])
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def EcritureLatexdesmatricesinversiblesainversergroupeespar3(n,p,a,b,r):
"""Returns the matrices to be inverted, created by calling randmatrixInvnewparpaquet(3,4,-9,10,100), grouped m by m, and written in TeX format.
randmatrixInvnewparpaquet(n,p,a,b,r):
Retourne les matrices à invreser, créées par appel de randmatrixInvnewparpaquet(3,4,-9,10,100),
groupées m par m, et écrites en Tex
randmatrixInvnewparpaquet(n,p,a,b,r):"""
#Q=randmatrixInvnewparpaquet(3,4,-9,10,100)
Q = randmatrixInvnewparpaquet(n,p,a,b,r)
s=int(n/3)
t=n-3*s
if t == 0:
for f in range(0,s,1):
i=3*f
j=3*f+1
k=3*f+2
#print('$A_',k,'=', latex(Q[i]),',','A_',j,'=',latex(Q[k]),',','A_',rho,'=',latex(Q[j]), '$\n')
print('$A_',i,'=', latex(Q[i]),',','A_',j,'=',latex(Q[j]),',','A_',k,'=',latex(Q[k]), '$\n')
#print('$A_',i,'=', latex(Q[i]),',','A_',j,'=',latex(Q[j]), '$\n')
#print('$A_',k,':=', latex(Q[k]), '$\n')
elif t == 1:
m=3*s
for f in range(0,s,1):
i=3*f
j=3*f+1
k=3*f+2
#print('$A_',k,'=', latex(Q[i]),',','A_',j,'=',latex(Q[k]),',','A_',rho,'=',latex(Q[j]), '$\n')
print('$A_',i,'=', latex(Q[i]),',','A_',j,'=',latex(Q[j]),',','A_',k,'=',latex(Q[k]), '$\n')
print('$A_',m,'=', latex(Q[m]),'$\n')
else:
u=3*s
m=3*s+1
for f in range(0,s,1):
i=3*f
j=3*f+1
k=3*f+2
#print('$A_',k,'=', latex(Q[i]),',','A_',j,'=',latex(Q[k]),',','A_',rho,'=',latex(Q[j]), '$\n')
print('$A_',i,'=', latex(Q[i]),',','A_',j,'=',latex(Q[j]),',','A_',k,'=',latex(Q[k]), '$\n')
print('$A_',u,'=', latex(Q[u]),',','A_',m,'=',latex(Q[m]),'$\n')
return 0 #print('q & det(q) =', q,',', q.det())
#t = EcritureLatexdesmatricesinversiblesainversergroupeespar3(6,3,-9,10,100)
#print('toto')
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def Ecriture(A,n,p,a,b,r):
"""Returns the matrices to be inverted, created by calling randmatrixInvnewparpaquet(3,4,-9,10,100), grouped m by m, and written in TeX format. randmatrixInvnewparpaquet(n,p,a,b,r):
Retourne les matrices à inverser, créées par appel de randmatrixInvnewparpaquet(3,4,-9,10,100),
groupées m par m, et écrites en Tex
randmatrixInvnewparpaquet(n,p,a,b,r):"""
#Q=randmatrixInvnewparpaquet(3,4,-9,10,100)
U=str(A)
Q=randmatrixInvnewparpaquet(n,p,a,b,r)
s=int(n/3)
t=n-3*s
if t == 0:
for f in range(0,s-1,1):
i=3*f
j=3*f+1
k=3*f+2
w=3*f+3
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(j)+'='+str(latex(Q[i]))
phrase2 =',&'+'&'+U+'_'+str(k)+'='+str(latex(Q[j]))
phrase3 =',&'+'&'+U+'_'+str(w)+'='+str(latex(Q[k]))
phrase4=','+'&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
#print("\\"'begin{align*}\n','&A_',j,'=', latex(Q[i]),',','&','&A_',k,'=',latex(Q[j]),',','&','&A_',w,'=',latex(Q[k]),',','&\n', "\\"'end{align*}\n')
#print("\\"'begin{align*}\n','&',U,'_',j,'=', latex(Q[i]),',','&','&A_',k,'=',latex(Q[j]),',','&','&A_',w,'=',latex(Q[k]),',','&\n', "\\"'end{align*}\n')
i=3*(s-1)
j=3*(s-1)+1
k=3*(s-1)+2
w=3*(s-1)+3
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(j)+'='+str(latex(Q[i]))
phrase2 =',&'+'&'+U+'_'+str(k)+'='+str(latex(Q[j]))
phrase3 =',&'+'&'+U+'_'+str(w)+'='+str(latex(Q[k]))
phrase4='.'+'&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
elif t == 1:
m=3*s
mprime=m+1
for f in range(0,s,1):
i=3*f
j=3*f+1
k=3*f+2
w=3*f+3
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(j)+'='+str(latex(Q[i]))
phrase2 =','&+'&'+U+'_'+str(k)+'='+str(latex(Q[j]))
phrase3 =',&'+'&'+U+'_'+str(w)+'='+str(latex(Q[k]))
phrase4=','+'&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
#print("\\"'begin{align*}\n','&A_',j,'=', latex(Q[i]),',','&','&A_',k,'=',latex(Q[j]),',','&','&A_',w,'=',latex(Q[k]),',','&\n', "\\"'end{align*}\n')
phrase1 ="\\"'begin{equation*}\n'+U+'_'+str(mprime)+'='+str(latex(Q[m]))
phrase2=','+'\n'+"\\"'end{equation*}.\n'
phrase= phrase1+phrase2
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
#print("\\"'begin{equation*}\n','A_',mprime,'=', latex(Q[m]),'.\n',"\\"'end{equation*}\n')
else:
u=3*s
m=3*s+1
mprime=m+1
for f in range(0,s,1):
i=3*f
j=3*f+1
k=3*f+2
w=3*f+3
#print('$A_',k,'=', latex(Q[i]),',','A_',j,'=',latex(Q[k]),',','A_',rho,'=',latex(Q[j]), '$\n')
#print("\\"'begin{align*}\n','&A_',j,'=', latex(Q[i]),',','&','&A_',k,'=',latex(Q[j]),',','&','&A_',l,'=',latex(Q[k]),',','&\n', "\\"'end{align*}\n')
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(j)+'='+str(latex(Q[i]))
phrase2 =',&'+'&'+U+'_'+str(k)+'='+str(latex(Q[j]))
phrase3 =',&'+'&'+U+'_'+str(w)+'='+str(latex(Q[k]))
phrase4=',&'+'&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
#print("\\"'begin{align*}\n','&A_',m,'=', latex(Q[u]),',','&','&A_',mprime,'=',latex(Q[m]),'.','&\n',"\\"'end{align*}\n')
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(m)+'='+str(latex(Q[u]))
phrase2 =',&'+'&'+U+'_'+str(mprime)+'='+str(latex(Q[m]))
phrase3='.&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3#+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
return 0
#En python, on appelle la fction en écrivant:
#t=Ecriture(Z,6,3,-9,10,100)
#t=Ecriture(Z,4,3,-9,10,100)
#t=Ecriture(Z,5,3,-9,10,100)
#En pythonTeX, on appelle la fction en écrivant, à l'intérieur d'un begin #sympycode:
#a='Z'
#t=Ecriture(a,6,3,-9,10,100)
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def Ecritureavecinverse(A,n,p,a,b,r):
"""Returns the matrices to be inverted, created by calling randmatrixInvnewparpaquet(3,4,-9,10,100),
grouped m by m, and written in TeX format. randmatrixInvnewparpaquet(n,p,a,b,r):
Retourne les matrices à invreser, créées par appel de randmatrixInvnewparpaquet(3,4,-9,10,100),
groupées m par m, et écrites en Tex
randmatrixInvnewparpaquet(n,p,a,b,r):"""
p0="\\"'subsubsection{'
p1 ="\\"'iffrancais\n'
p2='1'+'-Matrices à inverser'
p3 ="\\"'else\n'
p4 ='1'+'-Matrices to inverse'
p5 ="\\"'fi\n'
p6='}'
p0=p0.replace(" ", "")
p1=p1.replace(" ", "")
p3=p3.replace(" ", "")
p5=p5.replace(" ", "")
sentencedebut= p0+p1+p2+p3+p4+p5+p6
#fhrase=fhrase.replace(" ", "")
print(sentencedebut, '\n')
#Q=randmatrixInvnewparpaquet(3,4,-9,10,100)
U=str(A)
V = '{'+U+'}'+'^{-1}'
V=V.replace(" ", "")
mm='$'+V+'$'
Q=randmatrixInvnewparpaquet(n,p,a,b,r)
s=int(n/3)
t=n-3*s
if t == 0:
for f in range(0,s-1,1):
i=3*f
j=3*f+1
k=3*f+2
w=3*f+3
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(j)+'='+str(latex(Q[i]))
phrase2 =',&'+'&'+U+'_'+str(k)+'='+str(latex(Q[j]))
phrase3 =',&'+'&'+U+'_'+str(w)+'='+str(latex(Q[k]))
phrase4=','+'&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
#print("\\"'begin{align*}\n','&A_',j,'=', latex(Q[i]),',','&','&A_',k,'=',latex(Q[j]),',','&','&A_',w,'=',latex(Q[k]),',','&\n', "\\"'end{align*}\n')
#print("\\"'begin{align*}\n','&',U,'_',j,'=', latex(Q[i]),',','&','&A_',k,'=',latex(Q[j]),',','&','&A_',w,'=',latex(Q[k]),',','&\n', "\\"'end{align*}\n')
i=3*(s-1)
j=3*(s-1)+1
k=3*(s-1)+2
w=3*(s-1)+3
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(j)+'='+str(latex(Q[i]))
phrase2 =',&'+'&'+U+'_'+str(k)+'='+str(latex(Q[j]))
phrase3 =',&'+'&'+U+'_'+str(w)+'='+str(latex(Q[k]))
phrase4='.'+'&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
q00 ="\\"'textcolor{blue}{'
q0="\\"'subsubsection{'
q1 ="\\"'iffrancais\n'
q2='2'+'-Matrices inversées'
q3 ="\\"'else\n'
q4 ='2'+'-Inverted Matrices'
q5 ="\\"'fi\n'
q6='}}'
q0=q0.replace(" ", "")
q1=q1.replace(" ", "")
q3=q3.replace(" ", "")
q5=q5.replace(" ", "")
sentencefin= q00+q0+q1+q2+q3+q4+q5+q6
#fhrase=fhrase.replace(" ", "")
print(sentencefin, '\n')
for f in range(0,s-1,1):
i=3*f
j=3*f+1
k=3*f+2
w=3*f+3
phrase0bis ="\\"'textcolor{blue}{'
phrase1bis ="\\"'begin{align*}\n'+'&'+V+'_'+str(j)+'='+str(latex(Q[i].inv()))
phrase2bis =',&'+'&'+V+'_'+str(k)+'='+str(latex(Q[j].inv()))
phrase3bis =',&'+'&'+V+'_'+str(w)+'='+str(latex(Q[k].inv()))
phrase4bis=','+'&\n'+"\\"'end{align*}\n'
phrase5bis ='}'
phrasebis= phrase0bis+phrase1bis+phrase2bis+phrase3bis+phrase4bis+phrase5bis
phrasebis=phrasebis.replace(" ", "")
phrasebis=phrasebis.replace("[", "(")
phrasebis=phrasebis.replace("]", ")")
print(phrasebis, '\n')
#print("\\"'begin{align*}\n','&A_',j,'=', latex(Q[i]),',','&','&A_',k,'=',latex(Q[j]),',','&','&A_',w,'=',latex(Q[k]),',','&\n', "\\"'end{align*}\n')
#print("\\"'begin{align*}\n','&',U,'_',j,'=', latex(Q[i]),',','&','&A_',k,'=',latex(Q[j]),',','&','&A_',w,'=',latex(Q[k]),',','&\n', "\\"'end{align*}\n')
i=3*(s-1)
j=3*(s-1)+1
k=3*(s-1)+2
w=3*(s-1)+3
phrase0bis ="\\"'textcolor{blue}{'
phrase1bis ="\\"'begin{align*}\n'+'&'+V+'_'+str(j)+'='+str(latex(Q[i].inv()))
phrase2bis =',&'+'&'+V+'_'+str(k)+'='+str(latex(Q[j].inv()))
phrase3bis =',&'+'&'+V+'_'+str(w)+'='+str(latex(Q[k].inv()))
phrase4bis='.'+'&\n'+"\\"'end{align*}\n'
phrase5bis ='}'
phrasebis=phrase0bis+phrase1bis+phrase2bis+phrase3bis+phrase4bis+phrase5bis
phrasebis=phrasebis.replace(" ", "")
phrasebis=phrasebis.replace("[", "(")
phrasebis=phrasebis.replace("]", ")")
print(phrasebis, '\n')
elif t == 1:
m=3*s
mprime=m+1
for f in range(0,s,1):
i=3*f
j=3*f+1
k=3*f+2
w=3*f+3
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(j)+'='+str(latex(Q[i]))
phrase2 =',&'+'&'+U+'_'+str(k)+'='+str(latex(Q[j]))
phrase3 =',&'+'&'+U+'_'+str(w)+'='+str(latex(Q[k]))
phrase4=','+'&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
#print("\\"'begin{align*}\n','&A_',j,'=', latex(Q[i]),',','&','&A_',k,'=',latex(Q[j]),',','&','&A_',w,'=',latex(Q[k]),',','&\n', "\\"'end{align*}\n')
phrase1 ="\\"'begin{equation*}\n'+U+'_'+str(mprime)+'='+str(latex(Q[m]))
phrase2=','+'\n'+"\\"'end{equation*}.\n'
phrase= phrase1+phrase2
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
#print("\\"'begin{equation*}\n','A_',mprime,'=', latex(Q[m]),'.\n',"\\"'end{equation*}\n')
# Ici démarre la seconde partie!
q00 ="\\"'textcolor{blue}{'
q0="\\"'subsubsection{'
q1 ="\\"'iffrancais\n'
q2='2'+'-Matrices inversées'
q3 ="\\"'else\n'
q4 ='2'+'-Inverted Matrices'
q5 ="\\"'fi\n'
q6='}}'
q0=q0.replace(" ", "")
q1=q1.replace(" ", "")
q3=q3.replace(" ", "")
q5=q5.replace(" ", "")
sentencefin= q00+q0+q1+q2+q3+q4+q5+q6
#fhrase=fhrase.replace(" ", "")
print(sentencefin, '\n')
for f in range(0,s,1):
i=3*f
j=3*f+1
k=3*f+2
w=3*f+3
phrase0bis ="\\"'textcolor{blue}{'
phrase1bis ="\\"'begin{align*}\n'+'&'+V+'_'+str(j)+'='+str(latex(Q[i].inv()))
phrase2bis =',&'+'&'+V+'_'+str(k)+'='+str(latex(Q[j].inv()))
phrase3bis =',&'+'&'+V+'_'+str(w)+'='+str(latex(Q[k].inv()))
phrase4bis=','+'&\n'+"\\"'end{align*}\n'
phrase5bis ='}'
phrasebis= phrase0bis+phrase1bis+phrase2bis+phrase3bis+phrase4bis+phrase5bis
phrasebis=phrasebis.replace(" ", "")
phrasebis=phrasebis.replace("[", "(")
phrasebis=phrasebis.replace("]", ")")
print(phrasebis, '\n')
phrase0bis ="\\"'textcolor{blue}{'
phrase1bis ="\\"'begin{equation*}\n'+V+'_'+str(mprime)+'='+str(latex(Q[m].inv()))
phrase2bis=','+'\n'+"\\"'end{equation*}.\n'
phrase3bis='}'
phrasebis= phrase0bis+phrase1bis+phrase2bis+phrase3bis
phrasebis=phrasebis.replace(" ", "")
phrasebis=phrasebis.replace("[", "(")
phrasebis=phrasebis.replace("]", ")")
print(phrasebis, '\n')
else:
u=3*s
m=3*s+1
mprime=m+1
for f in range(0,s,1):
i=3*f
j=3*f+1
k=3*f+2
w=3*f+3
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(j)+'='+str(latex(Q[i]))
phrase2 =',&'+'&'+U+'_'+str(k)+'='+str(latex(Q[j]))
phrase3 =',&'+'&'+U+'_'+str(w)+'='+str(latex(Q[k]))
phrase4=','+'&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
phrase1 ="\\"'begin{align*}\n'+'&'+U+'_'+str(m)+'='+str(latex(Q[u]))
phrase2 =',&'+'&'+U+'_'+str(mprime)+'='+str(latex(Q[m]))
phrase3='.&\n'+"\\"'end{align*}\n'
phrase= phrase1+phrase2+phrase3#+phrase4
phrase=phrase.replace(" ", "")
phrase=phrase.replace("[", "(")
phrase=phrase.replace("]", ")")
print(phrase, '\n')
q00 ="\\"'textcolor{blue}{'
q0="\\"'subsubsection{'
q1 ="\\"'iffrancais\n'
q2='2'+'-Matrices inversées'
q3 ="\\"'else\n'
q4 ='2'+'-Inverted Matrices'
q5 ="\\"'fi\n'
q6='}}'
q0=q0.replace(" ", "")
q1=q1.replace(" ", "")
q3=q3.replace(" ", "")
q5=q5.replace(" ", "")
sentencefin= q00+q0+q1+q2+q3+q4+q5+q6
#fhrase=fhrase.replace(" ", "")
print(sentencefin, '\n')
# Dernière partie
for f in range(0,s,1):
i=3*f
j=3*f+1
k=3*f+2
w=3*f+3
phrase0bis ="\\"'textcolor{blue}{'
phrase1bis ="\\"'begin{align*}\n'+'&'+V+'_'+str(j)+'='+str(latex(Q[i].inv()))
phrase2bis =',&'+'&'+V+'_'+str(k)+'='+str(latex(Q[j].inv()))
phrase3bis =',&'+'&'+V+'_'+str(w)+'='+str(latex(Q[k].inv()))
phrase4bis=','+'&\n'+"\\"'end{align*}\n'
phrase5bis ='}'
phrasebis= phrase0bis+phrase1bis+phrase2bis+phrase3bis+phrase4bis+phrase5bis
phrasebis=phrasebis.replace(" ", "")
phrasebis=phrasebis.replace("[", "(")
phrasebis=phrasebis.replace("]", ")")
print(phrasebis, '\n')
phrase0bis ="\\"'textcolor{blue}{'
phrase1bis ="\\"'begin{align*}\n'+'&'+V+'_'+str(m)+'='+str(latex(Q[u].inv()))
phrase2bis =',&'+'&'+V+'_'+str(mprime)+'='+str(latex(Q[m].inv()))
phrase3bis='.&\n'+"\\"'end{align*}\n'
phrase4bis ='}'
phrasebis= phrase0bis+phrase1bis+phrase2bis+phrase3bis+phrase4bis#+phrase4
phrasebis=phrasebis.replace(" ", "")
phrasebis=phrasebis.replace("[", "(")
phrasebis=phrasebis.replace("]", ")")
print(phrasebis, '\n')
return 0
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def trafiquematrice(M) :
"""En: For any matrix A, returns the matrix A with exactly one element modified.
The modified element, which is a non-zero element is arbitrarily chosen and mulitplied
a random number between -5 and 5, 0 being exluded. In other word, a_i,j becomes k a_ij, for an non zero element a_i,j
Fr: """
n,m = M.shape
facteur = choice([-4,-3,-2,-1,2,3,4])
trafiquee = False
while not trafiquee :
i = randint(0,n-1)
j = randint(0,m-1)
if M[i,j] != 0 :
M[i,j] = facteur*M[i,j]
trafiquee = True
return M
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
# def trafiquematrice(A):
# """En: For any invertible matrix A, returns the matrix A with exactly one element modified.
# The modified element, which is non-zero and located at position (i,j), is replaced by 2*a_{i,j}.
# Fr: Pour toute matrice inversible A, retourne la matrice A, à un élément près.
# Le seul élément de A qui a été modifié est non nul!!!!!, placé en position i,j est devenu 2*a_i,j """
# if A.det() == 0:
# print('Error: your matrix is not invertible')
# #raise "l'indice de ligne ou de colonne est trop grand
# else:
# #M=A
# U = DiscreteUniform('U', list(range(0,A.cols,1)) ) # distribution over a range
# uprime= sample(U)
# j=sample(U) #next(uprime)
# s=int(1)
# # print('j= ', j)
# # print('s= ', s)
# for i in range(0,3,1):
# if s == 1 and A[i,j] != 0:
# #print('A[i,j]= ', A[i,j])
# M=A+A[i,j]*mat_element(A.rows,A.cols,i+1,j+1)
# #print('M= ', M)
# s=s-1
# #print('s= ', s)
# return M
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def trafiquematricerestantinversible(M):
"""Pour toute matrice inversible A, retourne la matrice A, à un élément près, de telle sorte que la matrice trafiquée reste inversible."""
# Convert to SymPy matrix with exact arithmetic
M_sympy = Matrix(M)
n, m = M_sympy.shape
# Initial invertibility check
try:
det_value = M_sympy.det()
if det_value == S.Zero:
print('La matrice n\'est pas inversible')
return M_sympy
except Exception as e:
print(f"Erreur lors de la vérification initiale: {str(e)}")
return M_sympy
# Track modifications
success = False
attempts = 0
max_attempts = n * m * 5
while not success and attempts < max_attempts:
i = randint(0, n-1)
j = randint(0, m-1)
if M_sympy[i, j] != 0:
# Save original value
original = M_sympy[i, j]
# Try a modification
factor = choice([-4, -3, -2, -1, 2, 3, 4])
# Create a test matrix instead of modifying the original
test_matrix = M_sympy.copy()
test_matrix[i, j] = factor * original
# Check determinant without triggering exceptions
try:
if test_matrix.det() != S.Zero:
# Apply change to original only if valid
M_sympy[i, j] = factor * original
success = True
except:
# Skip this attempt if error occurs
pass
attempts += 1
# if not success:
# print("Aucune modification valide trouvée après plusieurs tentatives.")
return M_sympy
##### Pause du 2/08/24 avec Gaspard
[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 pième position: 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 ########
#############################################################################################################
#############################################################################################################
#### Nouvelle Fction ########
#############################################################################################################
[docs]
def Polynomial_of_Matrix(P,A):
"""Renvoie la matrice P(A), où P est un polynôme"""
n = shape(A)[0] # nbre de lignes de A
if shape(A)[0] != shape(A)[1]:
raise Exception("Sorry, A must be a square matrix")
# else:
# toto = 2
deg_P = degree(P)
Z = zeros(n, n)
Y = MatrixSymbol('Y', n, n)
L = P.all_coeffs()
l = len(L)
for j in range(0,l-1,1):
Z = Z+L[j]*Y**(deg_P-j)
if L[l-1] != 0:
Z = Z + L[l-1]*eye(n)
else:
toto = 2
Z_bis = Z.subs(Y, A)
Z_bis_expand = expand(Z_bis)
Z_bis_expand_explicit = Z_bis_expand.as_explicit()
return Z_bis_expand_explicit
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# Essai #1
# M = Matrix([[1, 2], [3, 4]])
# X = Symbol('X')
# y = 2*X**3 - 3*X**2 + 4*X - 5
# poly = Poly(y, X)
# U = Polynomial_of_Matrix(poly, M)
# print('Polynomial_of_Matrix(poly, M)=', U, '\n')
# #X=Symbol('X')
# QQ = M.charpoly(X)
# Q=factor(QQ.as_expr())
# T=expand(Q)
# QQQ=T.as_expr()
# print('M.charpoly(X)=',QQ,'\n')
# print('factor(QQ.as_expr())=',Q,'\n')
# print('expand(factor(QQ.as_expr()))=',T,'\n')
# print('T.as_expr()=',QQQ,'\n')
# V = Polynomial_of_Matrix(QQ, M)
# print('Polynomial_of_Matrix(M.charpoly, M)=',V,'\n')
# Essai #2
# N = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# print('N=',N, '\n')
# QQN = N.charpoly(X)
# QN=factor(QQN.as_expr())
# TN=expand(QN)
# QQQN=TN.as_expr()
# VN = Polynomial_of_Matrix(QQN, N)
# print('Polynomial_of_Matrix(M.charpoly, N)=',VN, '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Fction ########
#############################################################################################################
# #def Polynomial_of_Matrix_extended(P, A, X):
# def Polynomial_of_Matrix_extended(P,A):
# """Renvoie la matrice P(A), où P est un polynôme avec les 3 étapes de calculs"""
# n = shape(A)[0] # nbre de lignes de A
# if shape(A)[0] != shape(A)[1]:
# raise Exception("Sorry, A must be a square matrix")
# # else:
# # toto = 2
# deg_P = degree(P)
# Z = zeros(n, n)
# V = Symbol('X')
# Y = MatrixSymbol('Y', n, n)
# L = P.all_coeffs()
# l = len(L)
# W = 0
# for j in range(0,l-1,1):
# Z = Z + L[j]*Y**(deg_P-j)
# W = W + L[j]*V**(deg_P-j)
# final = ''
# if L[l-1] != 0:
# Z = Z + L[l-1]*eye(n)
# if L[l-1] > 0:
# final = str(L[l-1])+'I_{'+str(n)+'}'#W = W + L[l-1]
# else:
# final = str(L[l-1])+'I_{'+str(n)+'}'#W = W + L[l-1]
# else:
# toto = 2
# L_bis = []
# Z_bis_pr_LaTex = str(W.subs(V,'A')) +final
# Z_bis = Z.subs(Y, A)
# Z_bis_expand = expand(Z_bis)
# Z_bis_expand_explicit = Z_bis_expand.as_explicit()
# L_bis.append(Z_bis_pr_LaTex)
# L_bis.append(Z_bis)
# #print('L_bis = ', L_bis)
# L_bis.append(Z_bis_expand)
# L_bis.append(Z_bis_expand_explicit)
# return L_bis
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# Essai #1
# M = Matrix([[1, 2], [3, 4]])
# X = Symbol('X')
# y = 2*X**3 - 3*X**2 + 4*X - 5
# poly = Poly(y, X)
# U = Polynomial_of_Matrix_extended(poly, M)
# U_0 = Polynomial_of_Matrix_extended(poly, M)[0]
# U_1 = Polynomial_of_Matrix_extended(poly, M)[1]
# U_2 = Polynomial_of_Matrix_extended(poly, M)[2]
# U_3 = Polynomial_of_Matrix_extended(poly, M)[3]
# #print('Polynomial_of_Matrix_extended(poly, M)=', U, '\n')
# print('Polynomial_of_Matrix_extended(poly, M)=', U_0, '\n')
# print('Polynomial_of_Matrix_extended(poly, M)=', U_1, '\n')
# print('Polynomial_of_Matrix_extended(poly, M)=', U_2, '\n')
# print('Polynomial_of_Matrix_extended(poly, M)=', U_3, '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#===================================================================================================================
#
# Nouvelle Fction ########
#
#====================================================================================================================
[docs]
def Polynomial_of_Matrix_extended_v_5(P, name_polynomial, A, name_matrix):
"""Renvoie la matrice P(A), où P est un polynôme avec les 4 étapes de calculs dans une liste.
Chaque étape étant un élément de la liste de résulat. Le dernier élement de la liste de résultat
n'est autre que le TeX dans un alignetoile de toute la séquence"""
n = shape(A)[0] # nbre de lignes de A
if shape(A)[0] != shape(A)[1]:
raise Exception("Sorry, A must be a square matrix")
name_matrix = str(name_matrix)
deg_P = degree(P)
Z = zeros(n, n)
X = Symbol('X')
F = Symbol('F')
Y = MatrixSymbol('Y', n, n)
I = MatrixSymbol('I', n, n)
L_coeffs_of_P = P.all_coeffs()
l = len(L_coeffs_of_P)
Id_n = 'I' + "_" + str(n)
#S = P-L_coeffs_of_P[l-1]+(L_coeffs_of_P[l-1])*F
T = [None]*l
K = [None]*l
K_sub = [None]*l
K_sub_latex = [None]*l
L = [None]*l
L_sub = [None]*l
L_sub_latex = [None]*l
N = [None]*l
# création de la liste contenant le premier développement de P(A) sous format latex
for i in range(0,l-2,1):
mk = str(L_coeffs_of_P[i])
if i == 0 or L_coeffs_of_P[i] <0:
if L_coeffs_of_P[i] == -1:
mk = '-'
elif L_coeffs_of_P[i] == 1:
mk = ''
else:
toto =2
elif L_coeffs_of_P[i] == 1:
mk = '+'
else:
mk = '+'+ mk
N[i] = mk + name_matrix+'^{'+str(deg_P-i)+'}'
#print('N[',i,'] =', N[i], '\n')
mk = str(L_coeffs_of_P[l-2])
if L_coeffs_of_P[l-2] <0:
if L_coeffs_of_P[l-2] == -1:
mk = '-'
else:
toto = 2
elif L_coeffs_of_P[l-2] == 1:
mk = '+'
else:
mk = '+'+mk
N[l-2] = mk + name_matrix
#print('N[',l-2,'] =', N[l-2], '\n')
mk = str(L_coeffs_of_P[l-1])
if L_coeffs_of_P[l-1] <0:
if L_coeffs_of_P[l-1] == -1:
mk = '-'
else:
toto = 2
elif L_coeffs_of_P[l-1] == 1:
mk = '+'
else:
mk = '+'+mk
N[l-1] = mk + Id_n
#print('N[',l-1,'] =', N[l-1], '\n')
ch= ''
for i in range(0,l,1):
ch = ch + N[i]
#print('ch =', ch, '\n')
# création des étapes 2 et 3 du calcul du développement de P(A) sous format latex
for i in range(0,l-1,1):
T[i] = MatPow(Y, deg_P-i, evaluate=False)
K[i] = Mul(T[i], L_coeffs_of_P[i] , evaluate=False)
K_sub[i] = K[i].subs(Y, A)
L_sub[i] = expand(K_sub[i])
from sympy.printing.latex import LatexPrinter
K_sub_latex[i] = LatexPrinter(dict(order='none'))._print(K_sub[i])
L_sub_latex[i] = LatexPrinter(dict(order='none'))._print(L_sub[i])
T[l-1] = MatPow(I, deg_P-(l-1), evaluate=False)
K[l-1] = Mul(T[l-1], L_coeffs_of_P[l-1] , evaluate=False)
K_sub[l-1] = K[l-1].subs(I, eye(n),)
L_sub[l-1] = expand(K_sub[l-1])
Total = MatAdd(*K_sub, evaluate= True)
#print('Total =', Total, '\n')
from sympy.printing.latex import LatexPrinter
K_sub_latex[l-1] = LatexPrinter(dict(order='none'))._print(K_sub[l-1])
L_sub_latex[l-1] = LatexPrinter(dict(order='none'))._print(L_sub[l-1])
#print('K_sub_latex[',l-1,'] = ', K_sub_latex[l-1], '\n')
Kprime = []
Lprime = []
lp, rp, lb, = "\\"+'left(', "\\"+'right)', "\\"+'left['
lbnew, rb, rbnew = "\\"+'left(', "\\"+'right]', "\\"+'right)'
alpha = ['^{0}', '^{1}', lp, rp, lb, rb]
beta = ["", "", "", "", lbnew, rbnew]
K_sub_latex = prog_remplacement_mots_dans_une_liste(K_sub_latex, alpha, beta)
L_sub_latex = prog_remplacement_mots_dans_une_liste(L_sub_latex, alpha, beta)
for s in range(0,l,1):
if s == 0 or L_coeffs_of_P[s] < 0:
toto = 2
else:
K_sub_latex[s] = '+'+ K_sub_latex[s]
if s == 0 :
toto = 2
else:
L_sub_latex[s] = '+'+ L_sub_latex[s]
Kprime.append(K_sub_latex[s])
Lprime.append(L_sub_latex[s])
#print('Lprime = ', Lprime, '\n')
Intermediary_Result = [ch, Kprime, Lprime, Total]
I_R = Intermediary_Result
u = str(name_polynomial)+'('+name_matrix+')'
L_nom = [u, "", "", ""]
G_1 = Content_ss_virg_ss_print(Intermediary_Result[1])
G_2 = Content_ss_virg_ss_print(Intermediary_Result[2])
G_3 = str(latex(I_R[3]))
L_but = [I_R[0], G_1 , G_2, G_3]
#L_but = [I_R[0], Content_ss_virg(I_R[1]), Content_ss_virg(I_R[2]), I_R[3]]
U = EcrituredsAlignetoileLatex_one_per_line(L_nom, L_but)
Resultat_du_calcul = Polynomial_of_Matrix(P,A)
Result = [ch, Kprime, Lprime, Resultat_du_calcul, U, Total]
return Result
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# X = Symbol('X')
# A = Matrix([[1, 2], [3, 4]])
# z = Add(X**3, X**2, -X, +1, evaluate=False)
# poly_bis = Poly(z, X)
# n = shape(A)[0] # nbre de lignes de A
# Y = MatrixSymbol('Y', n, n)
# print('Ici commence le résultat de la fonction', '\n')
# Tout = Polynomial_of_Matrix_extended_v_5(poly_bis,'P',A,'R')
# print('Tout = ', Tout, '\n')
# ch = Polynomial_of_Matrix_extended_v_5(poly_bis,'P',A,'R')[0]
# print('Polynomial_of_Matrix_extended_v_5(poly_bis,"P",A,'R')[0] =', ch, '\n')
# Kprime = Polynomial_of_Matrix_extended_v_5(poly_bis,'P',A,'R')[1]
# print('Polynomial_of_Matrix_extended_v_5(poly_bis,"P",A,'R')[1]=', Kprime, '\n')
# Lprime = Polynomial_of_Matrix_extended_v_5(poly_bis,'P',A,'R')[2]
# print('Polynomial_of_Matrix_extended_v_5(poly_bis,"P",A,'R')[2]=', Lprime, '\n')
# Resultat = Polynomial_of_Matrix_extended_v_5(poly_bis,'P',A,'R')[3]
# print('Polynomial_of_Matrix_extended_v_5(poly_bis,"P",A,'R')[3]=', Resultat, '\n')
# U = Polynomial_of_Matrix_extended_v_5(poly_bis,'P',A,'R')[4]
# print('Polynomial_of_Matrix_extended_v_5(poly_bis,"P",A,'R')[4]=', U, '\n')
# Total = Polynomial_of_Matrix_extended_v_5(poly_bis,'P',A,'R')[5]
# print('Total =', Total, '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#===================================================================================================================
#
# Nouvelle Fction ########
#
#====================================================================================================================
from sympy import *
[docs]
def Polynomial_of_Matrix_extended_v7(P,A,name_matrix):
"""Renvoie la matrice P(A), où P est un polynôme avec les 4 étapes de calculs dans une liste"""
n = shape(A)[0] # nbre de lignes de A
if shape(A)[0] != shape(A)[1]:
raise Exception("Sorry, A must be a square matrix")
#name_matrix = str(name_matrix)
deg_P = degree(P)
Z = zeros(n, n)
X = Symbol('X')
F = Symbol('F')
Y = MatrixSymbol('Y', n, n)
I = MatrixSymbol('I', n, n)
L_coeffs_of_P = P.all_coeffs()
l = len(L_coeffs_of_P)
# Id_n = 'I' + "_" + str(n)
# ARG = []
# for i in range(0,deg_P,1):
# t = (L_coeffs_of_P[i]*X**(deg_P-i)).subs({X:name_matrix}).as_expr()
# ARG.append(t)
# s = (L_coeffs_of_P[i]*F**(deg_P-i)).subs({F:Id_n}).as_expr()
# ARG.append(s)
# #print('ARG =', ARG, '\n')
# exprs = ARG[0]
# for i in range(1,len(ARG),1):
# exprs = Add(exprs, ARG[i], evaluate=False)
# from sympy.printing.str import StrPrinter # or LatexPrinter from .latex)
# Hprimes = StrPrinter(dict(order='none'))._print_Add(exprs)
# #print('Hprimes j =', Hprimes, '\n')
T = [None]*l
K = [None]*l
K_sub = [None]*l
K_sub_latex = [None]*l
L = [None]*l
L_sub = [None]*l
L_sub_latex = [None]*l
for i in range(0,l-1,1):
T[i] = MatPow(Y, deg_P-i, evaluate=False)
K[i] = Mul(T[i], L_coeffs_of_P[l-1-i] , evaluate=False)
K_sub[i] = K[i].subs(Y, A)
L_sub[i] = expand(K_sub[i])
from sympy.printing.latex import LatexPrinter
K_sub_latex[i] = LatexPrinter(dict(order='none'))._print(K_sub[i])
L_sub_latex[i] = LatexPrinter(dict(order='none'))._print(L_sub[i])
print('K_sub_latex[',i,'] = ', K_sub_latex[i], '\n')
T[l-1] = MatPow(I, deg_P-(l-1), evaluate=False)
K[l-1] = Mul(T[l-1], L_coeffs_of_P[l-1] , evaluate=False)
K_sub[l-1] = K[l-1].subs(I, eye(n),)
L_sub[l-1] = expand(K_sub[l-1])
Total = MatAdd(*K_sub, evaluate= True)
#print('Total =', Total, '\n')
from sympy.printing.latex import LatexPrinter
K_sub_latex[l-1] = LatexPrinter(dict(order='none'))._print(K_sub[l-1])
L_sub_latex[l-1] = LatexPrinter(dict(order='none'))._print(L_sub[l-1])
#print('K_sub_latex[',l-1,'] = ', K_sub_latex[l-1], '\n')
Kprime = []
Lprime = []
lp, rp, lb, = "\\"+'left(', "\\"+'right)', "\\"+'left['
lbnew, rb, rbnew = "\\"+'left(', "\\"+'right]', "\\"+'right)'
alpha = ['^{0}', '^{1}', lp, rp, lb, rb]
beta = ["", "", "", "", lbnew, rbnew]
K_sub_latex = prog_remplacement_mots_dans_une_liste(K_sub_latex, alpha, beta)
L_sub_latex = prog_remplacement_mots_dans_une_liste(L_sub_latex, alpha, beta)
for s in range(0,l,1):
if s == 0 or L_coeffs_of_P[s] < 0:
toto = 2
else:
K_sub_latex[s] = '+'+ K_sub_latex[s]
if s == 0 :
toto = 2
else:
L_sub_latex[s] = '+'+ L_sub_latex[s]
Kprime.append(K_sub_latex[s])
Lprime.append(L_sub_latex[s])
#print('Kprime = ', Kprime, '\n')
#print('Lprime = ', Lprime, '\n')
Poly_en_latex_monomes_croissants = Ecriture_Poly_of_Matrix_en_Latex_inc(P,name_matrix, n)
Poly_en_latex_monomes_decroissants = Ecriture_Poly_of_Matrix_en_Latex_dec(P,name_matrix, n)
#Result = [Hprime_as_expr_latex, Kprime, Lprime, Total]
Result = [Poly_en_latex_monomes_decroissants, Kprime, Lprime, Total]
return Result#1#L_bis
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# X = Symbol('X')
# A = Matrix([[1, 2], [3, 4]])
# z = Add(4*X**4, 2*X**3, -3*X**2, 4*X, -5, evaluate=False)
# poly_bis = Poly(z, X)
# # n = shape(A)[0] # nbre de lignes de A
# # Y = MatrixSymbol('Y', n, n)
# print('Ici commence le résultat de la fonction Polynomial_of_Matrix_extended_v7', '\n')
# print("On a d'abord le polynôme de l'exemple = ", poly_bis, '\n')
# Ess = Polynomial_of_Matrix_extended_v7(poly_bis,A,'A')
# print('Essai = ', Ess, '\n')
# =============================================================================
# # H = Polynomial_of_Matrix_extended_v7(poly_bis,A,'A')[0]
# # print('Poly_en_latex_monomes_croissants =', H, '\n')
#
# # I = Polynomial_of_Matrix_extended_v7(poly_bis,A,'A')[1]
# # print('Poly_en_latex_monomes_decroissants =', I, '\n')
#
#
#
#
#
# # Kprime = Polynomial_of_Matrix_extended_v7(poly_bis,A,'A')[2]
# # print('Kprime =', Kprime, '\n')
#
# # Lprime = Polynomial_of_Matrix_extended_v7(poly_bis,A,'A')[3]
# # print('Lprime =', Lprime, '\n')
#
# # W = Polynomial_of_Matrix_extended_v7(poly_bis,A,'A')[4]
# # print('Résultat final =', W, '\n')
#
# =============================================================================
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#===================================================================================================================
# Nouvelle Fction ########
#====================================================================================================================
[docs]
def Polynomial_of_Matrix_extended_dec(P,name_poly, A,name_matrix):
"""Renvoie la matrice P(A), où P est un polynôme avec
les 4 étapes de calculs dans une liste"""
n = shape(A)[0] # nbre de lignes de A
if shape(A)[0] != shape(A)[1]:
raise Exception("Sorry, A must be a square matrix")
#name_matrix = str(name_matrix)
deg_P = degree(P)
name_poly = str(name_poly)
name_matrix = str(name_matrix)
Z = zeros(n, n)
X = Symbol('X')
F = Symbol('F')
Y = MatrixSymbol('Y', n, n)
I = MatrixSymbol('I', n, n)
L_coef_dec = P.rep.rep
L_coeffs_of_P = P.all_coeffs()
P_all_coeffs = P.all_coeffs()
# print('P(X) ds la fction =', P, '\n')
# print(' P_all_coeffs ds la fction =', P_all_coeffs, '\n')
l = len(L_coeffs_of_P)
Poly_en_latex_monomes_dec = Ecriture_Poly_of_Matrix_en_Latex_dec(P, name_matrix, n)
#print('Poly_en_latex_monomes_decroissants =', Poly_en_latex_monomes_dec, '\n')
T = [None]*l
K = [None]*l
K_sub = [None]*l
K_sub_latex = [None]*l
L = [None]*l
L_sub = [None]*l
L_sub_latex = [None]*l
R = [None]*l
R_sub = [None]*l
R_sub_latex = [None]*l
if L_coef_dec != P_all_coeffs:
raise('Pbm attention les coef du polynôme ne seront pas dans l ordre', '\n')
else:
for i in range(0,l-1,1):
if L_coeffs_of_P[i] == 0:
K[i] = 0
#
K_sub[i] = 0
R_sub[i] = 0
L_sub[i] = 0
#
K_sub_latex[i] = ''
R_sub_latex[i] = ''
L_sub_latex[i] = ''
#print('K_sub_latex[',i,'] = ', K_sub_latex[i], '\n')
else:
T[i] = MatPow(Y, deg_P-i, evaluate=False)
K[i] = Mul(T[i], L_coeffs_of_P[i] , evaluate=False)
K_sub[i] = K[i].subs(Y, A)
B = A**(deg_P-i)#, evaluate = True)
#print(' B = ', B, '\n')
R[i] = Mul(L_coeffs_of_P[i], Y, evaluate=False)
#print('Etape que je veux R[',i,'] = ', R[i], '\n')
#R[i] = R[i].subs(Y, B)
#print('Etape finale que je veux R[',i,'] = ', R[i], '\n')
R_sub[i] = R[i].subs(Y, B)#Mul(L_coeffs_of_P[i], R[i], evaluate=False)
#print('R_sub[',i,'] = ', R_sub[i], '\n')
#L_sub[i] = expand(K_sub[i])
# L_sub[i] = Mul(L_coeffs_of_P[i], Y, evaluate = True)
# L_sub[i] =L_sub[i].subs(Y, B)
L_sub[i] = L_coeffs_of_P[i]*B
from sympy.printing.latex import LatexPrinter
K_sub_latex[i] = LatexPrinter(dict(order='none'))._print(K_sub[i])
R_sub_latex[i] = LatexPrinter(dict(order='none'))._print(R_sub[i])
#print('R_sub_latex[',i,'] = ', R_sub_latex[i], '\n')
L_sub_latex[i] = LatexPrinter(dict(order='none'))._print(L_sub[i])
#print('K_sub_latex[',i,'] = ', K_sub_latex[i], '\n')
if L_coeffs_of_P[l-1] == 0:
K[l-1] = 0
K_sub[l-1] = 0
R[l-1] = 0
R_sub[l-1] = 0
L_sub[l-1] = 0
K_sub_latex[l-1] = ''
L_sub_latex[l-1] = ''
R_sub_latex[l-1] = ''
else:
T[l-1] = MatPow(I, deg_P-(l-1), evaluate=False)
K[l-1] = Mul(T[l-1], L_coeffs_of_P[l-1] , evaluate=False)
K_sub[l-1] = K[l-1].subs(I, eye(n))
R[l-1] = Mul(L_coeffs_of_P[l-1], I, evaluate=False)
R_sub[l-1] = R[l-1].subs(I, eye(n))
L_sub[l-1] = expand(K_sub[l-1])
# Total = MatAdd(*K_sub, evaluate= True)
# print('Total =', Total, '\n')
from sympy.printing.latex import LatexPrinter
K_sub_latex[l-1] = LatexPrinter(dict(order='none'))._print(K_sub[l-1])
R_sub_latex[l-1] = LatexPrinter(dict(order='none'))._print(R_sub[l-1])
#print('R_sub_latex[',l-1,'] = ', R_sub_latex[l-1], '\n')
L_sub_latex[l-1] = LatexPrinter(dict(order='none'))._print(L_sub[l-1])
#print('K_sub_latex[',l-1,'] = ', K_sub_latex[l-1], '\n')
Total = MatAdd(*K_sub, evaluate= True)
K_sub_minus_last = K_sub[0:l-1]
Total_bis = MatAdd(*K_sub_minus_last, evaluate= True)
Total_bis = Total_bis + L_coeffs_of_P[l-1]* eye(n)
#print('Total =', Total, '\n')
Kprime = []
Rprime = []
Lprime = []
lp, rp, lb, = "\\"+'left(', "\\"+'right)', "\\"+'left['
lbnew, rb, rbnew = "\\"+'left(', "\\"+'right]', "\\"+'right)'
alpha = ['^{0}', '^{1}', lp, rp, lb, rb]
beta = ["", "", "", "", lbnew, rbnew]
K_sub_latex = prog_remplacement_mots_dans_une_liste(K_sub_latex, alpha, beta)
R_sub_latex = prog_remplacement_mots_dans_une_liste(R_sub_latex, alpha, beta)
L_sub_latex = prog_remplacement_mots_dans_une_liste(L_sub_latex, alpha, beta)
for s in range(0,l,1):
if s == 0 or L_coeffs_of_P[s] < 0:
toto = 2
else:
if L_coeffs_of_P[s] == 0:
K_sub_latex[s] = ''
R_sub_latex[s] = ''
# elif L_coeffs_of_P[s] == 1:
# K_sub_latex[s] = K_sub_latex[s]
else:
K_sub_latex[s] = '+'+ K_sub_latex[s]
R_sub_latex[s] = '+'+ R_sub_latex[s]
if s == 0 :
toto = 2
else:
if L_coeffs_of_P[s] == 0:
L_sub_latex[s] = ''
# elif L_coeffs_of_P[s] == 1:
# L_sub_latex[s] = L_sub_latex[s]
else:
L_sub_latex[s] = '+'+ L_sub_latex[s]
Kprime.append(K_sub_latex[s])
Rprime.append(R_sub_latex[s])
#print('Rprime = ', Rprime, '\n')
Lprime.append(L_sub_latex[s])
#print('Kprime = ', Kprime, '\n')
#print('Rprime = ', Rprime, '\n')
#print('Lprime = ', Lprime, '\n')
L_nom = []
L_eq = []
a = name_poly + '(' + name_matrix + ')'
L_nom.append(a)
L_eq.append(Poly_en_latex_monomes_dec)
L_nom.append(' ')
b = Content_ss_virg_ss_print(Kprime)
L_eq.append(b)
L_nom.append(' ')
d = Content_ss_virg_ss_print(Rprime)
L_eq.append(d)
L_nom.append(' ')
c = Content_ss_virg_ss_print(Lprime)
L_eq.append(c)
L_nom.append(' ')
L_eq.append(latex(Total_bis))
Le_tout = EcrituredsAlignetoileLatex_one_per_line(L_nom, L_eq)
Result = [Poly_en_latex_monomes_dec, Kprime, Lprime, Total_bis, Le_tout]
return Result
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# X = Symbol('X')
# A = Matrix([[1, 2, 3, 4], [3, 4, 5, 6], [6, 7, 8, 9], [10, 11, 12, -2]])
# z = Add(4*X**4, X**3, -X**2, -2*X, -1, evaluate=False)
# poly_bis = Poly(z, X)
# print('Ici commence le résultat de la fonction Polynomial_of_Matrix_extended_dec', '\n')
# print("On a d'abord le polynôme de l'exemple = ", poly_bis, '\n')
# poly_bis_all_coeffs = poly_bis.all_coeffs()
# print("On a aussi P_all_coeffs = ", poly_bis_all_coeffs, '\n')
# Ess_dec = Polynomial_of_Matrix_extended_dec(poly_bis,'Q',A,'A')
# print('Ess_dec = ', Ess_dec, '\n')
# Ess_dec_0 = Ess_dec[0]
# print('Ess_dec_0 = ', Ess_dec_0, '\n')
# Ess_dec_1 = Ess_dec[1]
# print('Ess_dec_1 = ', Ess_dec_1, '\n')
# Ess_dec_2 = Ess_dec[2]
# print('Ess_dec_2 = ', Ess_dec_2, '\n')
# Ess_dec_3 = Ess_dec[3]
# print('Ess_dec_3 = ', Ess_dec_3, '\n')
# Ess_dec_4 = Ess_dec[4]
# print('Ess_dec_4 = ', Ess_dec_4, '\n')
# print('Fin du test de Polynomial_of_Matrix_extended_dec \n')
# =============================================================================
# # H = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[0]
# # print('Poly_en_latex_monomes_croissants =', H, '\n')
#
# # I = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[1]
# # print('Poly_en_latex_monomes_decroissants =', I, '\n')
#
#
#
#
#
# # Kprime = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[2]
# # print('Kprime =', Kprime, '\n')
#
# # Lprime = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[3]
# # print('Lprime =', Lprime, '\n')
#
# # W = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[4]
# # print('Résultat final =', W, '\n')
#
# =============================================================================
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#===================================================================================================================
# Nouvelle Fction ########
#====================================================================================================================
[docs]
def Polynomial_of_Matrix_extended_inc(P,A,name_matrix):
"""Renvoie la matrice P(A), où P est un polynôme avec les 4 étapes de calculs dans une liste"""
n = shape(A)[0] # nbre de lignes de A
if shape(A)[0] != shape(A)[1]:
raise Exception("Sorry, A must be a square matrix")
#name_matrix = str(name_matrix)
deg_P = degree(P)
Z = zeros(n, n)
X = Symbol('X')
F = Symbol('F')
Y = MatrixSymbol('Y', n, n)
I = MatrixSymbol('I', n, n)
L_coeffs_of_P = P.all_coeffs()
l = len(L_coeffs_of_P)
T = [None]*l
K = [None]*l
K_sub = [None]*l
K_sub_latex = [None]*l
L = [None]*l
L_sub = [None]*l
L_sub_latex = [None]*l
for i in range(0,l-1,1):
T[i] = MatPow(Y, deg_P-i, evaluate=False)
K[i] = Mul(T[i], L_coeffs_of_P[l-1-i] , evaluate=False)
K_sub[i] = K[i].subs(Y, A)
L_sub[i] = expand(K_sub[i])
from sympy.printing.latex import LatexPrinter
K_sub_latex[i] = LatexPrinter(dict(order='none'))._print(K_sub[i])
L_sub_latex[i] = LatexPrinter(dict(order='none'))._print(L_sub[i])
#print('K_sub_latex[',i,'] = ', K_sub_latex[i], '\n')
T[l-1] = MatPow(I, deg_P-(l-1), evaluate=False)
K[l-1] = Mul(T[l-1], L_coeffs_of_P[l-1] , evaluate=False)
K_sub[l-1] = K[l-1].subs(I, eye(n),)
L_sub[l-1] = expand(K_sub[l-1])
Total = MatAdd(*K_sub, evaluate= True)
#print('Total =', Total, '\n')
from sympy.printing.latex import LatexPrinter
K_sub_latex[l-1] = LatexPrinter(dict(order='none'))._print(K_sub[l-1])
L_sub_latex[l-1] = LatexPrinter(dict(order='none'))._print(L_sub[l-1])
#print('K_sub_latex[',l-1,'] = ', K_sub_latex[l-1], '\n')
Kprime = []
Lprime = []
lp, rp, lb, matrix = "\\"+'left(', "\\"+'right)', "\\"+'left[', 'matrix'
lbnew, rb, rbnew, pmatrix= "\\"+'left(', "\\"+'right]', "\\"+'right)', 'pmatrix'
alpha = ['^{0}', '^{1}', lp, rp, lb, rb, matrix]
beta = ["", "", "", "", lbnew, rbnew, pmatrix]
K_sub_latex = prog_remplacement_mots_dans_une_liste(K_sub_latex, alpha, beta)
L_sub_latex = prog_remplacement_mots_dans_une_liste(L_sub_latex, alpha, beta)
for s in range(0,l,1):
if s == 0 or L_coeffs_of_P[s] < 0:
toto = 2
else:
K_sub_latex[s] = '+'+ K_sub_latex[s]
if s == 0 :
toto = 2
else:
L_sub_latex[s] = '+'+ L_sub_latex[s]
Kprime.append(K_sub_latex[s])
Lprime.append(L_sub_latex[s])
#print('Kprime = ', Kprime, '\n')
#print('Lprime = ', Lprime, '\n')
Poly_en_latex_monomes_croissants = Ecriture_Poly_of_Matrix_en_Latex_inc(P,name_matrix, n)
#Poly_en_latex_monomes_decroissants = Ecriture_Poly_of_Matrix_en_Latex_dec(P,name_matrix, n)
#Result = [Hprime_as_expr_latex, Kprime, Lprime, Total]
Result = [Poly_en_latex_monomes_croissants, Kprime, Lprime, Total]
return Result#1#L_bis
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# X = Symbol('X')
# A = Matrix([[1, 2], [3, 4]])
# z = Add(4*X**4, 2*X**3, -3*X**2, 4*X, -5, evaluate=False)
# poly_bis = Poly(z, X)
# print('Ici commence le résultat de la fonction Polynomial_of_Matrix_extended_inc', '\n')
# print("On a d'abord le polynôme de l'exemple = ", poly_bis, '\n')
# Ess = Polynomial_of_Matrix_extended_inc(poly_bis,A,'A')
# print('Essai = ', Ess, '\n')
# Ess_0 = Ess[0]
# print('Ess_0 = ', Ess_0, '\n')
# Ess_1 = Ess[1]
# print('Ess_1 = ', Ess_1, '\n')
# Ess_2 = Ess[2]
# print('Ess_2 = ', Ess_2, '\n')
# Ess_3 = Ess[3]
# print('Ess_3 = ', Ess_3, '\n')
# =============================================================================
# # H = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[0]
# # print('Poly_en_latex_monomes_croissants =', H, '\n')
#
# # I = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[1]
# # print('Poly_en_latex_monomes_decroissants =', I, '\n')
#
#
#
#
#
# # Kprime = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[2]
# # print('Kprime =', Kprime, '\n')
#
# # Lprime = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[3]
# # print('Lprime =', Lprime, '\n')
#
# # W = Polynomial_of_Matrix_extended_v_7(poly_bis,A,'A')[4]
# # print('Résultat final =', W, '\n')
#
# =============================================================================
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
# M = Matrix([[1,2,3],[4,5,6],[7,8,9]])
# print('M =', M, '\n')
# Q = M.charpoly()
# print('Q =', Q, '\n')
# X = Symbol('X')
# R = Q.as_expr(X)
# print('R =', R, '\n')
# R = Poly(R, X)
# print('R =', R, '\n')
#######==================================================================================================##################
####### Nouvelle Fction ########
#######=================================================================================================###################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#######==================================================================================================##################
####### Nouvelle Fction ########
#######=================================================================================================###################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#######==================================================================================================##################
####### Nouvelle Fction ########
#######=================================================================================================###################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#######==================================================================================================##################
####### Nouvelle Fction ########
#######=================================================================================================###################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#######==================================================================================================##################
####### Nouvelle Fction ########
#######=================================================================================================###################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#######==================================================================================================##################
####### Nouvelle Fction ########
#######=================================================================================================###################