Interpréter un string comme un calcul à effectuer

Le
Laurent Claessens
Bonjour à toutes et à tous

Je sais que

a = "3"
print float(3)+5

donne le résultat attendu 8.

Ce que je voudrais faire est plus fort. Je voudrais faire

a = "3+5"
print ????(a)

qui donnerait 8.

Ma motivation est de créer un script en python qui produit du code
pstricks (pour LaTeX). Je dois donc d'une part pouvoir produire la
ligne

ewcommand{Fn}[1]{(-3)/(x)+5} càd -3/x + 5

(c'est pour cela que je voudrais avoir " (-3/x) +5" comme string en
python)

et d'autre part, pouvoir calculer la valeur de cette fonction en des x
arbitraires. Ce que je compte faire, c'est

a = "(-3/x) +5"
b = a.replace("x",23)

et puis "évaluer" b. À ce moment, j'ai que b vaut le string
"(-3/25)+5".
Je suis sûr que python peut me trouver la valeur 4.88 à partir de ce
string, n'est-ce pas ?


Pour la petite histoire, en LaTeX pur, faire exactement ce que je
décris, ça passe.

Si je fais
ewcommand{Fn}[1]{(-3)/(#1)+5} equivalent de a = "(-3/x) +5"
ewcommand{psFn}{Fn{x}} equivalent
de b = a.replace("x",23)

alors
psplot{0.5}{9}{psFn}
trace bien la courbe -3/x +5 entre 0.5 et 9

et
FPeval{resultat}{Fn(3)}
donne bien la valeur de la fonction en 3 dans esultat.


Ce dont j'ai besoin est donc en python une fonction aussi forte que
FPeval en LaTeX.

Merci pour vos lumières,
bonne nuit
Laurent
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
yves
Le #2691911
Le Wed, 09 Apr 2008 17:18:47 -0700, Laurent Claessens a écrit:

Bonjour,

Je sais que
a = "3"
print float(3)+5

donne le résultat attendu 8.

Ce que je voudrais faire est plus fort. Je voudrais faire

a = "3+5"
print ????(a)

qui donnerait 8.



|>>> a = "3 + 5"
|>>> eval(a)
8
|>>> a = "(-3/x) +5"
|>>> b = a.replace("x","25")
|>>> b
'(-3/25) +5'
|>>> eval(b)
4
|>>> from __future__ import division
|>>> eval(b)
4.8799999999999999


--
Yves

Laurent Claessens
Le #2717311

|>>> a = "3 + 5"
|>>> eval(a)
8
|>>> a = "(-3/x) +5"
|>>> b = a.replace("x","25")
|>>> b
'(-3/25) +5'
|>>> eval(b)
4
|>>> from __future__ import division
|>>> eval(b)
4.8799999999999999



Merci beaucoup. eval a l'air d'être exactement ce que je cherchais.

Bonne soirée
Laurent

Francois
Le #2757201
Bonjour,

J'utilise LaTeX assez régulièrement et je fais souvent des dessins avec
PSTricks. Je me demandais ce que tu cherchais à faire comme dessin
exactement et en quoi Python intervient là dedans.

Serait-il possible d'avoir des petits précisions ? PSTricks à lui seul
ne suffit pas ? Pourquoi fais-tu intervenir Python ? Ça m'intéresse.


--
François
kib
Le #2779821
Bonjour,

J'utilise LaTeX assez régulièrement et je fais souvent des dessins avec
PSTricks. Je me demandais ce que tu cherchais à faire comme dessin
exactement et en quoi Python intervient là dedans.

Serait-il possible d'avoir des petits précisions ? PSTricks à lui seul
ne suffit pas ? Pourquoi fais-tu intervenir Python ? Ça m'intéresse.


Salut,


Je serai aussi très intéressé. Je suppose que c'est la syntaxe de
PSTricks qui te rebute (c'est la même chose avec Tikz-Pgf et Asymptote).
J'avais commencé une sorte de backend pour pgf, ça marche bien, mais
j'aurai aimé faire ça a plusieurs...des volontaires ?

Tu peux toujours utiliser PyX sinon, voire un ancien module de Vincent
Zoonekynd : http://zoonek.free.fr/LaTeX/Triangle/index.shtml

Kib.

Laurent Claessens
Le #6807281
Bonjour,

J'utilise LaTeX assez r�guli�rement et je fais souvent des dessins avec
PSTricks. Je me demandais ce que tu cherchais � faire comme dessin
exactement et en quoi Python intervient l� dedans.

Serait-il possible d'avoir des petits pr�cisions ? PSTricks ï¿ ½ lui seul
ne suffit pas ? Pourquoi fais-tu intervenir Python ? �a m'intï ¿½resse.



Désolé pour la réponse tardive.

Je suis en train de taper un cours de math et de physique pour nos
têtes blondes.
http://www.enseignons.be/secondaire/preparations-34-mecanique-optique-relati vite-4262.html
Les sources LaTeX sont ici http://student.ulb.ac.be/~lclaesse/echa.tar.gz

J'ai déjà tapé beaucoup en pstricks, et j'avoue que la syntax e ne me
plaît pas; la géométrie est réellement plus maniable en orienté
objet : un segment est une classe qui a une méthode "milieu" qui est
de la classe "Point", etc.


Je suis en train de taper un chapitre sur les dérivées, et ce que je
veux faire, c'est ceci.




On prend une courbe F, et on y met un point P fixe. Ensuite, un point
Q se rapproche de P et on trace la ligne PQ. Lorsque Q se rapproche de
P, la ligne devient la tangente. Et chaque ligne a une couleur
différente. Le tout aussi automatisé que possible.

Je suis parvenu à faire ça en pstricks avec des multido, mais à §a a été
la folie !
Attention au code :

++++++++++++++++ Exemple de code pstricks +++++++++++++++++
documentclass[a4paper,12pt]{book}

usepackage{latexsym}
usepackage{amsfonts}
usepackage{amsmath}
usepackage{amsthm}
usepackage{amssymb}
usepackage{bbm}
usepackage{cases}


usepackage{eso-pic}
usepackage{pstricks}
usepackage{pst-node}
usepackage{pst-eucl}
usepackage{pst-plot}
usepackage{pst-math}
usepackage{pstricks-add}


usepackage{multido}
usepackage{fp}
usepackage{ifthen}
usepackage{subfigure}
usepackage{graphicx}


% La macro ValeurFonction
% #1 est le nom de la fonction à calculer. Cette dernière doit à ªtre
une macro à un argument du genre 3*#1+5/#1
% #2 est la valeur de la variable en laquelle on veut calculer la
fonction
% #3 est le nom de la variable FP dans laquelle le résultat sera
écrit.
newcommand{ValeurFonction}[3]{FPeval{#3}{#1{#2}}}


% La macro pstPointSurCourbe
% #1 est le nom de la fonction
% #2 est le x où l'on veut le point
% #3 est le nom du point pstricks qui sera en x sur la courbe.
newcommand{pstPointSurCourbe}[3]{%
ValeurFonction{#1}{#2}{inter}
pstGeonode(#2,inter){#3}
}


% La macro pstMarquePoint prend les arguments suivants :
% - 1 est optionnel : il donne le style de point qui va arriver
% - 2 est le point (au sens pstrick) qui doit être marqué
% - 3 est la position où va se trouver la marque par rapport au point
pstrick. Typiquement c'est (0.3;90) en coordonnées polaires
% - 4 est ce qu'on va y noter
newcommand{pstMarquePoint}[4][PointSymbol=none]{%
rput(#2){rput(#3){#4}} % Mettre le symbole du point là où il doit
être
pstGeonode[#1](#2){mpinter} % Cette ligne fait apparaître un point
à l'endroit que l'on marque.
% étant donné le psset{PointSymbol=none} dans lequel t outes
les figures se trouvent,
% ceci ne fait pas grand chose si on ne donne pas à
pstMarquePoint l'argument optionnel
% du type PointSymbol=* par exemple.
}

% La macro pstLigneLongueur
% #1 Optionnel : ce sont les parametres de tracé
% #2 Premier point de la ligne
% #3 Second point de la ligne
% #4 Longueur de la ligne souhaitée
%
% Cela trace une droite de longueur spécifiée qui passe par les deux
points donnés.
newcommand{pstLigneLongueur}[4][]{%
pstMiddleAB{#2}{#3}{interC} % Trouver le milieu du segment
donné
pstInterLC[Diameter=pstDistVal{#4}]{#2}{#3}{interC}{}{interP}
{interQ} % Points d'intersection entre la droite et le cercle de
diamètre #4
pstLineAB[#1]{interP}{interQ}
}

begin{document}

%
% L'environement ParamsTanApproxDerr contient les paramètres des
figures à tracer pour mon approx de dérivation
% L'environement FigTanApproxDerr est l'environement de figure elle-
même. Elle est censée se trouver à l'intérieur de Params TanApproxDerr.
%


% Fn est la fonction au sens où Fn{a} donne l'expression de la
fonction avec a. Pour calculer la valeur de la fonction en 4, il faut
donner Fn{4} à FPeval. C'est ce que fait la macro ValeurFonction.
% psFn est la fonction à donner à psplot. psFn est l'expression de
Fn donnée avec x.
newenvironment{ParamsTanApproxDerr}[1]{%
newcommand{Fn}[1]{(-3)/(##1)+5} %-3/x + 5
newcommand{psFn}{Fn{x}}
FPeval{Px}{1}
FPeval{Qx}{8}

% Les deux macros suivantes donnent les coordonnées où doivent être
placés les labels des points Q0, Q1, ... Y'a rien à faire : ils
doivent être mis à la main.
newcommand{CoorR}[1]{
ifnum ##1=0 0.3fi
ifnum ##1=1 0.3fi
ifnum ##1=2 0.3fi
ifnum ##1=3 0.5fi
ifnum ##1=4 0.5fi
ifnum ##1=5 0.5fi
ifnum ##1=6 0.5fi
ifnum ##1=7 0.5fi
}
newcommand{CoorA}[1]{%
ifnum ##1=0 -90fi
ifnum ##1=1 -90fi
ifnum ##1=2 -90fi
ifnum ##1=3 -90fi
ifnum ##1=4 -90fi
ifnum ##1=5 -90fi
ifnum ##1=6 -45fi
ifnum ##1=7 -45fi
}
% La macro qui suit donne la couleur du tracé de l'approximation de
tangente.
% Ici c'est important de ne pas mettre d'espace entre la couleur et
le fi, sinon cet espace est prit comme faisant partie du nom de la
couleur
% et alors xcolor se plaint de ne pas la connaître.
% typiquement on a ceci : ! Package xcolor Error: Undefined color
`red '.
newcommand{CoulTan}[1]{%
ifnum ##1=0 bluefi
ifnum ##1=1 bluefi
ifnum ##1=2 bluefi
ifnum ##1=3 bluefi
ifnum ##1=4 bluefi
ifnum ##1=5 bluefi
ifnum ##1=6 bluefi
ifnum ##1=7 bluefi
}

% J'ai besoin de la bounding box en vrai et en échelle parce que les
axes sont tracés après avoir imposé l'échelle, ce qui fa it que, eux,
doivent être donnés par les nombres non mis à l'échelle.
% La bounding box est (-0.9,-1,1)(11,5)
FPeval{BBbgx}{(-0.9)}
FPeval{BBbgy}{(-1.1)}
FPeval{BBhdx}{10}
FPeval{BBhdy}{5}

% Je la recalcule en fonction de l'échelle donnée
FPeval{eBBbgx}{0+BBbgx*#1}
FPeval{eBBbgy}{0+BBbgy*#1}
FPeval{eBBhdx}{0+BBhdx*#1}
FPeval{eBBhdy}{0+BBhdy*#1}

newenvironment{FigTanApproxDerr}{
begin{pspicture}(eBBbgx,eBBbgy)(eBBhdx,eBBhdy)
psset{algebraic=true, PointSymbol=none, PointName=none,
xunit=#1cm, yunit=#1cm}

% Mettre les points sur la courbe
pstPointSurCourbe{Fn}{Px}{P}
pstPointSurCourbe{Fn}{Qx}{Q}

% Définir les vecteurs de base de mon système de coordonné es
pstGeonode(0,0){O}(1,0){X}(0,1){Y}

% Construire le point I qui est à l'angle du rectangle donné pa r P
et Q.
pstTranslation{O}{X}{P}[PX]
pstTranslation{O}{Y}{Q}[QY]
pstInterLL{P}{PX}{Q}{QY}{I}

% Placer les points où les Delta x et Delta y vont être mit
pstMiddleAB{P}{I}{Del}
pstMiddleAB{Q}{I}{ff}

% Dessiner les axes et tracer la courbe.
psaxes[dotsep=1pt]{->}(0,0)(BBbgx,BBbgy)(BBhdx,BBhdy)
psplot{0.5}{9}{psFn}
} % Fin de l'ouverture de l'environnement FigTanApproxDerr
{end{pspicture}} % Fin de la fermeture de l'environnement
FigTanApproxDerr
} % Fin de l'ouverture de l'environement ParamsTanApproxDerr
{} % Fin de la fermenture de l'environement ParamsTanApproxDerr


begin{center}
begin{ParamsTanApproxDerr}{0.5}
begin{FigTanApproxDerr}
pstMarquePoint[PointSymbol=*]{P}{0.3;0}{$P$}
end{FigTanApproxDerr}
end{ParamsTanApproxDerr}
end{center}

begin{figure}[ht]
centering
begin{ParamsTanApproxDerr}{0.5}
FPeval{NumPoints}{8} % Note qu'avec n points, ils sont numérotà ©s
de 0 à n-1, comme le veux une vieille tradition en informatique.
FPeval{Intervalle}{(Qx-Px)/NumPoints}
multido{n=0+1}{NumPoints}{%
subfigure{
begin{FigTanApproxDerr}
FPeval{Qix}{Qx-(n*Intervalle)}
pstMarquePoint[PointSymbol=*]{P}{0.3;145}{$P$}
pstPointSurCourbe{Fn}{Qix}{Qin}
pstMarquePoint[PointSymbol=*]{Qin}{CoorR{n};CoorA{n}}
{$Q_{n}$}
FPeval{Qix}{Qix+1}
pstLigneLongueur[linecolor=CoulTan{n}]{P}{Qin}{7}
end{FigTanApproxDerr}
} % Fin de la sous-figure.
} % Fin du multido
end{ParamsTanApproxDerr}
caption{Plus le second point d'intersection avec la courbe s'approche
de $P$, plus la droite ressemble à la tangente.}
label{FigTanApproxSuite}
end{figure}


end{document}
+++++Fin Exemple d'utilisation pstricks ++++++++++++++++++


Après avoir fait ça, j'avoue que j'en ai eut marre et j'ai commenc é à
programmer en python des classes qui permettent de produire les code
pstricks.

Avantages :
* Calcul automatique de la bounding box
* orienté objet
* La programmation est plus simple (boucles for, calculs, utilisations
de variables, ...). Parce que programmer en LaTeX ... heu ...

Inconvénients :
* Deux "compilations" (lancer le scipt, puis compiler avec LaTeX)
* Obligation d'avoir python sur son ordi (je crois que ça vient de
base avec tous les OS sauf Gentoo, non ? --- wooo putain, le
troll !!! )
* Utilisation de maxima pour calculer des intersections (pas installé
d'office avec tous les os)
* ... ??? Je verrai à l'usage si il y a d'autres inconvénients



Voici le script qui me fournit le code pstricks d'à peu près les m êmes
figures.

+++++++++++ Code python +++++++++++++++


#! /usr/bin/python
# -*- coding: utf8 -*-

from __future__ import division
import commands, os, copy # La classe copy est pour faire des
copies d'objets
# Ce script demande aussi la présence de Maxima sur le système,
# pour calculer des extremas de fonctions, entre autres.

REP = commands.getoutput("pwd")

class Fichier(object):
def __init__ (self, filename):
self.NomComplet = filename
self.chemin = self.NomComplet

def OpenFile(self,opt):
self.file = open(self.NomComplet,opt) # Pour fermer le fichier,
c'est self.file.close()


class ListeNomsPoints(object):
def __init__(self):
self.donne = [97,97,96]
def suivant(self):
self.donne[2] = self.donne[2]+1
if self.donne[2] == 123:
self.donne[2] = 97
self.donne[1] = self.donne[1] + 1
if self.donne[1] == 123:
self.donne[1] = 97
self.donne[0] = self.donne[0] + 1
return chr(self.donne[0])+chr(self.donne[1])+chr(self.donne[2])

NomPointLibre = ListeNomsPoints()

class maxima(object):
def calcul(self,ligne):
sortie = commands.getoutput( "maxima --batch-string=
"display2d:false;n float("+ligne+");""+"|grep o2" )
return sortie
def solve(self,eq,vars):
return self.calcul( " solve(["+eq+"],["+vars+"]) " )
def extrema(self,f):
sortie = self.solve("diff("+f.fx
+",x)=0","x").replace(",","").replace("]","")
a = sortie.split("x =")
del a[0]
return a


class BoundingBox(object):
def __init__(self,dbg,dhd):
self.bg = dbg
self.hd = dhd
def AddPoint(self,P):
self.bg = Point( min(self.bg.x,P.x), min(self.bg.y,P.y) )
self.hd = Point( max(self.hd.x,P.x), max(self.hd.y,P.y) )

class Point(object):
def __init__(self,x,y):
self.x = x
self.y = y
self.psNom = NomPointLibre.suivant()

def Coord(self):
return "("+str(self.x)+","+str(self.y)+")"
def CoordBr(self):
return "{"+str(self.x)+","+str(self.y)+"}"

class Segment(object):
def __init__(self,A,B):
self.I = A
self.F = B
self.vertical = 0
if A.x == B.x :
self.vertical = 1
if self.vertical == 0:
self.equation = [(A.y-B.y)/(A.x-B.x),(A.y*B.x-A.x*B.y)/(A.x-B.x)]
def Milieu(self):
return Point( (self.I.x+self.F.x)/2, (self.I.y+self.F.y)/2 )

class Rectangle(object):
def __init__(self,A,B):
self.bg = A
self.hd = B
self.bd = Point( self.hd.x,self.bg.y )
self.hg = Point( self.bg.x,self.hd.y )

class Fonction(object):
def __init__(self,fun):
self.fx = fun
def eval(self,x):
return eval(self.fx.replace("x",str(x)))
def PointDessus(self,x):
return Point(float(x),self.eval(x))
def extremas(self):
l = []
for x in maxima().extrema(self):
l.append(Point(x),self.eval(x))
return l

class Cercle(object):
def __init__(self,C,r):
self.Centre = C
self.Rayon = r

# Une figure est le but ultime de ce script. Une figure est une suite
de subfigures, lesquelles sont destinées à être essentielleme nt des
pspictures.
class figure(object):
def __init__(self,caption,label,fich):
self.caption = caption
self.label = label
self.xunit = 1
self.yunit = 1
self.code = []
self.SSfigures = []
self.fichier = Fichier (fich)
self.AjouteLigne("\begin{figure}[ht]")
self.AjouteLigne("centering")

def Conclure(self):
self.AjouteLigne("psset{xunit="+str(self.xunit)
+",yunit="+str(self.yunit)+"}n")
for f in self.SSfigures :
self.AjouteLigne("subfigure["+f.caption+"]{%")
self.AjouteCode(f.code)
self.AjouteLigne("} % Fermeture de la sous-figure
"+str(self.SSfigures.index(f)+1))
self.AjouteLigne("%")

self.AjouteLigne("caption{"+self.caption+"}label{"+self.label+"}")
self.AjouteLigne("end{figure}")
self.contenu = "".join(self.code)

def Dilate(self,fact):
self.xunit = self.xunit * fact
self.yunit = self.yunit * fact

def AjouteSSfigure(self,ssFig):
self.SSfigures.append(ssFig)
def AjoutePspicture(self,fig):
self.AjouteLigne(fig.contenu())

def AjouteLigne(self,ligne):
self.code.append(ligne+"n")
def AjouteCode(self,liste_code):
self.code.extend(liste_code)

def EcrireFichier(self):
self.fichier.OpenFile("w")
self.fichier.file.write(self.contenu)
self.fichier.file.close()

# Le subfigure[caption]{ ne se met pas dans le code de la classe
subfigure parce que dans la classe figure, je numérote les sous-
figures.
# Typiquement, une sousfigure sera juste créée en ajoutant une
pspicture d'un coup, et puis c'est tout.
class subfigure(object):
def __init__(self,caption,label):
self.caption = caption
self.label = label
self.code = []

def AjouteLigne(self,ligne):
self.code.append(ligne)
def AjouteCode(self,cod):
print "Mon code est"
print self.code
print "Et j'ajoute"
print cod
self.code.extend(cod)

def AjoutePspicture(self,psp):
self.AjouteLigne(psp.contenu())

class pspicture(object):
def __init__(self):
self.code = []
self.listePoint = []

self.AjouteLigne("psset{PointSymbol=none,PointName=none,algebraic=tru e}
n")
self.BB = BoundingBox(Point(1000,1000),Point(-1000,-1000))

def Dilate(self,fact):
self.xunit = self.xunit * fact
self.yunit = self.yunit * fact

def AjouteLigne(self,ligne):
self.code.append(ligne+"n")
def AddFonction(self,fun,params,deb,fin):
self.BB.AddPoint( Point(deb,fun.eval(deb) ) )
self.BB.AddPoint( Point(fin,fun.eval(fin) ) )
for p in fun.extremas() :
self.BB.AddPoint(p)
self.AjouteLigne( "psplot["+params+"]{"+str(deb)+"}{"+str(fin)+"}
{"+fun.fx+"}" )
def AddPoint(self,P,params):
self.AjouteLigne("pstGeonode["+params+"]"+P.Coord()+"{"+P.psNom
+"}")
self.listePoint.append(P.psNom)
def MarquePoint(self,P,params,dist,angle,marque):
if P.psNom not in self.listePoint :
self.AddPoint(P,"PointSymbol=none,PointName=none")
self.BB.AddPoint(P)
self.AjouteLigne("pstMarquePoint["+params+"]{"+P.psNom+"}
{"+str(dist)+";"+str(angle)+"}{"+marque+"}")
def AddSegment(self,seg,params):
self.BB.AddPoint(seg.I)
self.BB.AddPoint(seg.F)
self.AddPoint(seg.I,"")
self.AddPoint(seg.F,"")
self.AjouteLigne("pstLineAB["+params+"]{"+seg.I.psNom+"}
{"+seg.F.psNom+"}")
def AddRectangle(self,rec,params):
self.BB.AddPoint(rec.bg)
self.BB.AddPoint(rec.hd)
self.AddSegment( Segment(rec.hg,rec.hd),params )
self.AddSegment( Segment(rec.hd,rec.bd),params )
self.AddSegment( Segment(rec.bd,rec.bg),params )
self.AddSegment( Segment(rec.bg,rec.hg),params )

def contenu(self):
a = ["\begin{pspicture}"+self.BB.bg.Coord()+self.BB.hd.Coord()
+"n"]
a.extend(self.code)
a.append("end{pspicture}n")
return "".join(a)


# Création de la pspicture générale.
##########################################################################
pspict_gene = pspicture()
f = Fonction("(-3/x)+5")
P = f.PointDessus(1)
Q = f.PointDessus(8)
angle = Point(Q.x , P.y)
pspict_gene.AddFonction(f,"",0.5,9)
pspict_gene.AddRectangle( Rectangle(pspict_gene.BB.bg,pspict_gene.BB.hd),"li necolor=cyan" )


# Création de la grande figure.
##########################################################################
pspict_gd = copy.deepcopy(pspict_gene)
pspict_gd.MarquePoint(P,"PointSymbol=*",0.3,180,"$P$")
pspict_gd.MarquePoint(Q,"PointSymbol=*",0.3,90,"$Q$")
pspict_gd.AddSegment(Segment(P,angle),"linestyleÚshed")
pspict_gd.AddSegment(Segment(Q,angle),"linestyleÚshed")

fig_gd = figure("Ma figure","leLabel",REP+"/figure1.tex")
fig_gd.AjoutePspicture(pspict_gd)
fig_gd.Conclure()
fig_gd.EcrireFichier()

# Création des sous figures
##########################################################################

n_ssfig = 6
ssfigs = []
for i in range(0,n_ssfig):
ssfig = subfigure("La suivante","UnLabel")
pspict = copy.deepcopy(pspict_gene)
Pi = f.PointDessus( Q.x-i*(Q.x-P.x)/(n_ssfig) )
pspict.AddSegment(Segment(P,Pi),"linecolor=blue")
ssfig.AjoutePspicture(pspict)
ssfigs.append(ssfig)

# Création de la figure principale
##########################################################################

fig_pr = figure("Ma figure principale","FigPrinc",REP+"/figure2.tex")
for ssf in ssfigs :
fig_pr.AjouteSSfigure(ssf)
fig_pr.Dilate(0.5)
fig_pr.Conclure()

fig_pr.EcrireFichier()

+++++++++++++++++++++++++++ Fin du code python +++++++++++++++++

C'est pas encore très portable, ni tout à fait terminé, mais je trouve
que c'est plus agréable à utiliser.

Tout commentaire sur le code ou sur l'idée de faire des classes en
python pour programmer du code LaTeX est le bienvenu (je peux même
commenter le code si il faut ;) )

Bonne soirée
Laurent

Jonathan Barnoud
Le #6990771

* Obligation d'avoir python sur son ordi (je crois que ça vient de
base avec tous les OS sauf Gentoo, non ? --- wooo putain, le
troll !!! )


Gentoo sans python ? Ho que je me gausse. Sauf si Gentoo a
définitivement abandonner portage, le gestionnaire de paquets est en
python et sans lui, pas moyen d'installer quoi que ce soit (enfin si
mais c'est plus une gentoo).

Jonathan

Publicité
Poster une réponse
Anonyme