Introduction à Boost-Python

Introduction à
Boost-Python
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Introduction à Boost-Python
V. Louvet
Institut Camille Jordan & CNRS
14 décembre 2006
Introduction à
Boost-Python
V. Louvet
1 Introduction
Introduction
Exemple
simple
2 Exemple simple
Exemple un
(tout petit)
peu plus
compliqué
3 Exemple un (tout petit) peu plus compliqué : petit code de
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Introduction
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Qu’est-ce que Boost.Python ?
• Librairie open source en C++ qui fournit une interface
permettant de relier des classes et fonctions C++ en
Python en utilisant juste un compilateur C++.
Introduction à
Boost-Python
Introduction
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Qu’est-ce que Boost.Python ?
• Librairie open source en C++ qui fournit une interface
permettant de relier des classes et fonctions C++ en
Python en utilisant juste un compilateur C++.
• L’interfaçage est non-intrusif vis à vis du code C++.
Introduction à
Boost-Python
Introduction
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Qu’est-ce que Boost.Python ?
• Librairie open source en C++ qui fournit une interface
permettant de relier des classes et fonctions C++ en
Python en utilisant juste un compilateur C++.
• L’interfaçage est non-intrusif vis à vis du code C++.
• L’utilisation de techniques de métaprogramming permet
de simplifier la syntaxe sous la forme du type des
déclarations d’interfaces du langage IDL.
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Exemple simple
Appel d’une fonction
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Code C++
double f a c t ( i n t n ) {
double f = 1 ;
w h i l e ( n > 1 ) f ∗= n−−;
return f ;
}
double n e p e r ( i n t n ) {
double s = 0 . ;
f o r ( i n t i = 0 ; i < n ; i ++)
s += 1/ f a c t ( i ) ;
return s ;
}
Introduction à
Boost-Python
Exemple simple
Appel d’une fonction
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Interfaçage avec Python
#i n c l u d e <b o o s t / p y t h o n . hpp>
u s i n g namespace b o o s t : : p y t h o n ;
BOOST PYTHON MODULE( n e p e r ) {
def (” neper ” , neper ) ;
}
Introduction à
Boost-Python
Exemple simple
Appel d’une fonction : et en python ?
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Code Python
import n e p e r
print neper . neper (100)
Résultats
2.71828182846
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Interfaçage des classes
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Code C++ : classe maillage 1D homogène
class maillage {
public :
double unstx2 () const { r e t u r n
i n t np ( ) c o n s t { r e t u r n n p ; }
private :
i n t n p ; /∗!< Nombre de P t s ∗/
d o u b l e u n s t x 2 ; /∗!< 1 / ( t x ˆ 2 ) ∗/
Conclusion
};
unstx2 ; }
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Interfaçage des classes
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Interfaçage python
#i n c l u d e <b o o s t / p y t h o n . hpp>
#i n c l u d e ” m a i l l a g e . hpp ”
u s i n g namespace b o o s t : : p y t h o n ;
BOOST PYTHON MODULE( r d ) {
c l a s s <m a i l l a g e >(” m a i l l a g e ” )
. def ( ” u n s t x 2 ” ,& m a i l l a g e : : u n s t x 2 )
. def ( ” np ” ,& m a i l l a g e : : np )
;
}
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Constructeurs
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Code C++ : constructeur de la classe maillage
class maillage {
public :
m a i l l a g e ( i n t np , d o u b l e s z )
:
s i z e ( s z ) , n p ( np ) {
d o u b l e t x = s i z e / ( np −1);
unstx2 = 1./( tx ∗ tx ) ;
p t s . r e s i z e ( np ) ;
f o r ( i n t i = 0 ; i < n p ; i ++)
p t s [ i ] = −( s i z e /2.)+
d o u b l e ( i ) / ( np −1)∗ s i z e ;
}
private :
double
s i z e ; /∗!< T a i l l e du domaine ∗/
};
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Constructeurs
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Interfaçage python
#i n c l u d e <b o o s t / p y t h o n . hpp>
#i n c l u d e ” m a i l l a g e . hpp ”
u s i n g namespace b o o s t : : p y t h o n ;
BOOST PYTHON MODULE( r d ) {
c l a s s <m a i l l a g e >(” m a i l l a g e ” ,
i n i t <i n t , d o u b l e , d o u b l e >())
. def ( ” u n s t x 2 ” ,& m a i l l a g e : : u n s t x 2 )
. def ( ” np ” ,& m a i l l a g e : : np )
;
}
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Constructeurs
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
On peut rajouter d’autres constructeurs : C++
class maillage {
public :
m a i l l a g e ( ) { /∗ l e c t u r e s u r
}
f i c h i e r ∗/
... }
On peut rajouter d’autres constructeurs : interface python
#i n c l u d e <b o o s t / p y t h o n . hpp>
#i n c l u d e ” m a i l l a g e . hpp ”
u s i n g namespace b o o s t : : p y t h o n ;
BOOST PYTHON MODULE( r d ) {
c l a s s <m a i l l a g e >(” m a i l l a g e ” ,
i n i t <i n t , d o u b l e , d o u b l e >())
. d e f ( i n i t <>())
...
;
}
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Attributs privés et properties
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
• Passage d’un attribut public de la classe :
Attribut public en C++
class maillage {
public :
s t r i n g msg ;
};
Interface python
c l a s s <m a i l l a g e > ( . . . )
. d e f r e a d o n l y ( ‘ ‘ msg ’ ’ ,& m a i l l a g e : : msg )
Utilisation directe en python
mail = rd . m a i l l a g e ()
p r i n t m a i l . msg
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Attributs privés et properties
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
• Passage d’un attribut public de la classe :
• Passage d’un attribut privé de la classe par l’intermédiaire
des méthodes classiques set et get
Attribut privé en C++
v o i d m a i l l a g e : : s e t n p ( i n t n ) { n p=n ; }
i n t m a i l l a g e : : getnp ( ) c o n s t { r e t u r n np ; }
Interface python
c l a s s <m a i l l a g e > ( . . . )
. a d d p r o p e r t y ( ‘ ‘ np ’ ’ ,& m a i l l a g e : : g e t n p ,
&m a i l l a g e : : s e t n p )
Utilisation directe en python
m a i l . np = 100
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Surcharge d’opérateurs
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Considérons la classe de variables du problème
Classe C++
c l a s s phi {
public :
p h i ( i n t np , v e c t o r <d o u b l e > v i n i t ) :
n p ( np ) {
p h i . r e s i z e ( np ) ;
f o r ( i n t i = 0 ; i < n p ; i ++)
/∗ I n i t i a l i s a t i o n de p h i a p a r t i r de v i n i t ∗/
}
f r i e n d p h i& o p e r a t o r +( p h i& ph , d o u b l e x ) {
f o r ( i n t i = 0 ; i < ph . n p ; i ++)
ph . p h i [ i ] = ph . p h i [ i ] + x ;
r e t u r n ph ;
}
private :
i n t n p ; /∗!< Nombre de p o i n t s d e s t a b l e a u x ∗/
v e c t o r <d o u b l e > p h i ; /∗!< T a b l e a u s o l u t i o n ∗/
};
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Surcharge d’opérateurs
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Considérons la classe de variables du problème
Interface python
c l a s s <p h i >(” p h i ” , i n i t <i n t , v e c t o r <d o u b l e > > ( ) )
. def ( s e l f + double ())
;
Utilisation directe en python
Conclusion
m a i l=r d . m a i l l a g e ( 1 0 1 , 1 4 0 . )
ph=r d . p h i ( m a i l . np ( ) , m a i l . p t s ( ) )
ph +12.
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Héritage
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Considérons la classe solveur
Classe C++ Solver
class solver {
public :
s o l v e r ( double ttot , i n t nt ) :
t t o t ( t t o t ) , n t ( nt ) {
dt = ttot / nt ;
}
v i r t u a l ˜ s o l v e r ( ) {}
v o i d s o l v e ( v e c t o r <d o u b l e > v e c ) { . . . }
Conclusion
protected :
double
t t o t ; /∗!< Temps t o t a l ∗/
int
n t ; /∗!< Nombre de p a s de temps ∗/
d o u b l e d t ; /∗!< Pas de temps ∗/
};
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Héritage
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Un solveur particulier
Classe C++ RK4
c l a s s rk4 : p u b l i c s o l v e r {
public :
r k 4 ( d o u b l e t t o t , i n t nt , i n t n t a b )
: s o l v e r ( tt o t , nt ) , ntab ( ntab ) { . . . }
private :
i n t ntab ;
};
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Héritage
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
L’interface python correspondante
Classe C++ RK4
c l a s s <s o l v e r >(” s o l v e r ” , i n i t <d o u b l e , i n t >())
. d e f ( ” s o l v e ” ,& s o l v e r : : s o l v e )
;
c l a s s <r k 4 , b a s e s <s o l v e r > >(” r k 4 ” , i n i t <d o u b l e , i n t , i n t >())
;
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Héritage
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
• Les classes dérivées héritent automatiquement de toutes
les méthodes de la classe Python de base.
• Les conversions de la classe dérivée vers la classe de base
sont parfaitement gérées par Boost.Python : les méthodes
C++ (interfacées pour Python) qui attendent un pointeur
ou une référence sur un objet de la classe de base
acceptent un objet de la classe dérivée.
• Il est aussi possible de dériver directement en Python les
classes C++ interfacées par Boost.Python.
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Fonctions virtuelles
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Virtualisation de la méthode solve
Classe C++ Solver et rk4
class solver {
public :
v i r t u a l v o i d s o l v e ( v e c t o r <d o u b l e >) = 0 ;
...
};
c l a s s rk4 : p u b l i c s o l v e r {
public :
v o i d s o l v e ( v e c t o r <d o u b l e > v e c p h i ) { . . . }
};
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Fonctions virtuelles
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Pour interfacer les méthodes virtuelles proprement, il faut écrire
une classe “enveloppe” dérivant de la classe de base, de façon
à respecter le principe de non-intrusion du code C++.
Classe wrapper
#i n c l u d e <b o o s t / p y t h o n / w r a p p e r . hpp>
#i n c l u d e <b o o s t / p y t h o n / c a l l . hpp>
c l a s s solverWrap : p u b l i c s o l v e r {
public :
solverWrap ( PyObject ∗ s e l f , double t t o t , i n t nt )
: s o l v e r ( t t o t , n t ) , s e l f ( s e l f ) {}
solverWrap ( PyObject ∗ s e l f , c o n s t s o l v e r& s )
: s o l v e r ( s ) , s e l f ( s e l f ) {}
v i r t u a l ˜ s o l v e r W r a p ( ) {}
v i r t u a l v o i d s o l v e ( v e c t o r <d o u b l e > v e c ) {
c a l l m e t h o d <v o i d >( s e l f , ” s o l v e ” , v e c ) ;
}
private :
PyObject ∗ s e l f ;
};
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Fonctions virtuelles
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
L’élément clé qui permet la surcharge en Python est l’appel de
la méthode call method. Tous les constructeurs de la classe
wrapper doivent être redéfinis avec un argument initial de type
PyObject*. Cet argument doit être stocké de façon à pouvoir
être utilisé lors de l’appel de call method. Si la fonction n’est
pas virtuelle pure, il faut prévoir une fonction par défaut
solve default afin de pouvoir appeler la fonction solve de la
classe de base.
Interface Python
c l a s s <s o l v e r , s o l v e r W r a p >(” s o l v e r ” , i n i t <d o u b l e , i n t >())
. d e f ( ” s o l v e ” ,& s o l v e r : : s o l v e )
;
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Passage de containers C++
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Revenons à notre classe maillage. On voudrait pouvoir accèder
au tableau des points de ce maillage. Il nous faut donc une
méthode get sur cet attribut.
Méthode get sur pts
class maillage {
...
v e c t o r <d o u b l e > p t s ( ) c o n s t {
return
pts ;
}
};
Introduction à
Boost-Python
Interfaçage d’un petit code de résolution d’ODE
Passage de containers C++
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
Il nous faut donc une enveloppe pour la classe std : :vector. On
utilise pour cela l’indexation de Boost.Python qui permet
l’exportation simple de conteneur C++ en Python. Les
conteneurs indexables sont ceux qui autorisent un accès
aléatoire via l’opérateur [] (typiquement std : :vector).
Interface pour la classe vector et la méthode pts
c l a s s <m a i l l a g e >(” m a i l l a g e ” , i n i t <i n t , d o u b l e >())
. d e f ( ” p t s ” ,& m a i l l a g e : : p t s )
;
c l a s s <s t d : : v e c t o r <d o u b l e > >(” s t d v e c t o r d o u b l e ” )
. d e f ( v e c t o r i n d e x i n g s u i t e <s t d : : v e c t o r <d o u b l e > >())
;
Introduction à
Boost-Python
Sommaire
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
1 Introduction
2 Exemple simple
3 Exemple un (tout petit) peu plus compliqué : petit code de
résolution d’ODE
Interfaçage des classes
Constructeurs
Attributs privés et properties
Surcharge d’opérateurs
Héritage
Fonctions virtuelles
Passage de containers
4 Conclusion
Introduction à
Boost-Python
Conclusion
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
• Un outil puissant.
Introduction à
Boost-Python
Conclusion
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
• Un outil puissant.
• Une documentation pas toujours très explicite.
Introduction à
Boost-Python
Conclusion
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
• Un outil puissant.
• Une documentation pas toujours très explicite.
• Très utilisé dans les jeux vidéos (par exemple Civilization
IV).
Introduction à
Boost-Python
Conclusion
V. Louvet
Introduction
Exemple
simple
Exemple un
(tout petit)
peu plus
compliqué
Interfaçage des
classes
Constructeurs
Attributs privés
et properties
Surcharge
d’opérateurs
Héritage
Fonctions
virtuelles
Passage de
containers
Conclusion
• Un outil puissant.
• Une documentation pas toujours très explicite.
• Très utilisé dans les jeux vidéos (par exemple Civilization
IV).
• Je n’ai pas parlé de beaucoup de choses ...