/* ctypes_test1.c L'objectif est d'avoir une soubroutine en C qui peut être accédé depuis le langage Python. Pour compiler depuis un Terminal : gcc -shared -Wl,-soname,ctypes_test1 -o ctypes_test1.so -fPIC ctypes_test1.c gcc -shared -o ctypes_test1.so -fPIC ctypes_test1.c Pour les options, c.f. https://gcc.gnu.org/onlinedocs/gcc/Option-Summary.html L'option "-Wl,-soname,pyco1" me semble inutile. ********************************************************/ #include <stdio.h> #include <string.h> // c.f. https://www.tutorialspoint.com/c_standard_library/string_h.htm int hellotest() { //=============== printf("Hello Wolrd\n"); // ne sera écrit nulle part ! return 7; } // hellotest long multiplier(long a, long b) { //=============================== //Attend deux entiers et les multiple return a * b; } // multiplier // Ne fonctionne pas, le type float et le type double ne sont pas // reconnus. double multiplierfxf(double a, double b) { //======================================== //Attend deux nombres à virgule et les multiplie return a * b; } // multiplierfxf char *dit_papa(char *p) { //======================= // Retourne le string envoyé en argument, suivit de " papa". return strcat(p, " papa"); } char *dit_bonjour(char *p) { //========================== // Retourne "Bonjour " suivit du string envoyé en argument // c.f. https://www.tutorialspoint.com/cprogramming/c_arrays.htm char temp[100]; strcpy(temp, "Bonjour "); return strcat(temp, p); }
# ctypes_test1.py # L'objectif est d'accéder à des routines écrites en langage C # depuis un programme Python. # c.f. https://docs.python.org/3/library/ctypes.html import ctypes montest = ctypes.CDLL("/home/bg/Bg2/Python/ctests/testsimple.so") # Il faut donner le chemin complet du fichier .so à inclure. # Sous Linux, un fichier .so correspond à une .dll sous Windows. print(montest.hellotest()) # Par défaut, les type sont int ou long, # donc, il n'y a pas de conversion à faire. a = 12 #a = ctypes.c_int(12) # a le même effet que : a = 12 b = 11 c = montest.multiplier(a, b) # Ceci fonctionne bien ! print("a*b=", a, "*", b, "=", c) print("Le type de c est :", type(c)) print() #================================================ va = 1.1 vb = 1.2 # Converti en type "double" du langage C cva = ctypes.c_double(va) cvb = ctypes.c_double(vb) #print(cva) # pour information #print(cva.value) # pour information # Indique que le type de retour de la fonction est "double" montest.multiplierfxf.restype = ctypes.c_double # Appelle de la fonction écrite en langage C cvres = montest.multiplierfxf(cva, cvb) print("va*vb =", cva.value, "*", vb, "=", cvres) print("Le type de cvres est :", type(cvres)) print() #================================================ mypystring = "le kiwi" astr = ctypes.c_char_p(mypystring.encode('utf8')) print(astr.value) # Indique le type de la variable retournée par la fonction C montest.dit_papa.restype = ctypes.c_char_p cstrrep = montest.dit_papa(astr) print(cstrrep) print(astr.value) # L'appelle à la fonction a modifié la valeur de astr.value ! print("Le type de cstrrep est :", type(cstrrep)) print() #================================================ # Indique le type de la variable retournée par la fonction C montest.dit_bonjour.restype = ctypes.c_char_p cret = montest.dit_bonjour(ctypes.c_char_p("Monsieur".encode('utf8'))) print(cret) print("Le type de cret est :", type(cret)) # c.f. # Indique le type de la variable retournée par la fonction C # 16.16.1.4 Fundamental data types : # Ce paragraphe indique les correspondances entre les type en langage C # et ce qui est utilisable en Python. # Il faut changer les type des arguments que l'on transmet au C # Avec .restype = ... il faut indiquer le type de la variable retournée.
/* ctypes_test2.c L'objectif est d'avoir une soubroutine en C qui peut être accédé depuis le langage Python. gcc -shared -o ctypes_test2.so -fPIC ctypes_test2.c gcc -I /usr/include/python3.5 -shared -Wl,-soname,pyco2 -o pyc02.so -fPIC pyc02.c "-I /usr/include/python3.5" indique où trouver la librairie`gcc -print-prog-name=cc1` -v Pour afficher la liste des répertoires utilisés par gcc c.f. http://www.network-theory.co.uk/docs/gccintro/gccintro_21.html ------------------------------------------------------------------- Pour l'emplacement des librairies utilisées par gcc. Par défaut, gcc cherche les headers dans : /usr/local/include/ /usr/include/ Par défaut, gcc cherche les librairies dans : /usr/local/lib/ /usr/lib/ On peut ajouter des répertoires de "include" (.h) ainsi : C_INCLUDE_PATH="/usr/include/python3.5" export C_INCLUDE_PATH gcc -shared -o pyc02.so -fPIC pyc02.c Sera suffisant pour compiler le programme c, qui utilise une librairie de Python Pour du C++, il faut : CPLUS_INCLUDE_PATH=/opt/gdbm-1.8.3/include export CPLUS_INCLUDE_PATH Pour des librairies : LIBRARY_PATH=/opt/gdbm-1.8.3/lib export LIBRARY_PATH This directory will be searched after any directories specified on the command line with the option -L, and before the standard default directories (such as ‘/usr/local/lib’ and ‘/usr/lib’). c.f. : http://www.network-theory.co.uk/docs/gccintro/gccintro_23.html ******************************************************************************/ int fact(int n) { //=============== // Fonction factorielle récursive en C if (n < 2) return(1); return (n)*fact(n-1); } // fact int pgcd(int a, int b) { //====================== // fonction 'pgcd' en C int r; while (b!=0) { r = a%b; a = b; b = r; } return a; } // pgcd
# ctypes_test2.py # L'objectif est d'accéder à des routines écrites en langage C # depuis un programme Python. # c.f. https://docs.python.org/3/library/ctypes.html import ctypes montest = ctypes.CDLL("/home/bg/Bg2/Python/ctests/ctypes_test2.so") # Il faut donner le chemin complet du fichier .so à inclure. # Sous Linux, un fichier .so correspond à une .dll sous Windows. print(montest.fact(7)) print(montest.pgcd(5040, 3003)) # Fonctionne très bien. a=5040 b=3003 c=montest.pgcd(a, b) print("Le pgcd(", a, ",", b, ") =",c) n=10 n_fact = montest.fact(n) print(n, "! =", n_fact) # Ces tests fonctionnent très bien et sont très simples, # car on utilise que des nombres entiers !
/* test0.c L'objectif est d'avoir une soubroutine en C qui peut être accédé depuis le langage Python. Pour compiler depuis un Terminal : gcc -shared -o test0.so -fPIC test0.c Depuis Python, si on veut taper dans la console : import os os.getcwd() # indique le répertoire par défaut os.chdir("/home/bg/Bg2/Python/ctests") # pour changer le répertoire par défaut import test0 test0.compte("abcdefgh") # retournera la longueur du string. Ici = 8 Mieux : exécuter le script test0.py qui est donné dans un autre fichier. Pour les types que Python reconnait et peut convertir en C : https://www.tutorialspoint.com/python/python_further_extensions.htm Curiosité : import sys sys.getrefcount(test0) *****************************************************/ #include "Python.h" #include <string.h> // c.f. https://www.tutorialspoint.com/c_standard_library/string_h.htm static PyObject* test0_compte(PyObject *self, PyObject *args) { //============================================================= // Définit la fonction en C qui sera appelée depuis Python const char* command; int sts; if (!PyArg_ParseTuple(args, "s", &command)) return NULL; // c.f. https://docs.python.org/3.3/c-api/arg.html#PyArg_ParseTuple sts = strlen(command); // retourne la longueur de la chaine de caractères // Plus exactement, le nombre d'octets qui code cette chaîne de caractères return PyLong_FromLong(sts); } // test0_compte static PyMethodDef test0Methods[] = { //=================================== {"compte", test0_compte, METH_VARARGS, "Compte le nombre de caractères d'une chaîne,\ les caractères accentués comptent double.\n\ Il faut donner une chaine de caractères en paramètre."}, // Est un texte d'aide. Obtenu avec : print(test0.compte.__doc__) {NULL, NULL, 0, NULL} // Sentinel }; static struct PyModuleDef test0module = { //======================================= // Est une structure nécessaire pour Python ??? PyModuleDef_HEAD_INIT, "test0", /* name of module */ NULL, //test0_doc, /* module documentation, may be NULL */ -1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */ test0Methods }; PyMODINIT_FUNC PyInit_test0(void) { //================================= // Fonction de création du module return PyModule_Create(&test0module); } // PyInit_test0 int main(int argc, char *argv[]) { //================================ // Fonction principale, qui sera exécutée au chargement du module wchar_t *program = Py_DecodeLocale(argv[0], NULL); if (program == NULL) { fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); exit(1); } /* Add a built-in module, before Py_Initialize */ PyImport_AppendInittab("test0", PyInit_test0); /* Pass argv[0] to the Python interpreter */ Py_SetProgramName(program); /* Initialize the Python interpreter. Required. */ Py_Initialize(); /* Optionally import the module; alternatively, import can be deferred until the embedded script imports it. */ PyImport_ImportModule("test0"); PyMem_RawFree(program); return 0; } // main // Il y a beaucoup de points que je ne comprends pas, mais cela fonctionne !
""" test0.py Ceci est un exemple d'appel à une routine écrite en langage C. Test la librairie de démo "test0.c" """ import test0 print(test0.compte("abcdefgh")) # affiche 8, qui est le nombre de caractères. print(test0.compte("abc def")) # affiche 7, qui est le nombre de caractères. print(test0.compte("aéb")) # affiche 4, car en utf-8, "é" prend 2 octets str="Ceci est dans une variable" print(test0.compte(str)) print(test0.compte.__doc__) # pour afficher de l'aide sur la fonction test0.compte
/* test1.c L'objectif est d'avoir une soubroutine en C qui peut être accédé depuis le langage Python. Pour compiler depuis un Terminal : gcc -shared -o test1.so -fPIC test1.c Depuis Python, si on veut taper dans la console : import os os.getcwd() # indique le répertoire par défaut os.chdir("/home/bg/Bg2/Python/ctests") # pour changer le répertoire par défaut import test1 test1.mult(11,7) # retournera le produit 11 * 7 Les arguments doivent être deux nombres entiers. Mieux : exécuter le script test1.py qui est donné dans un autre fichier. Pour les types que Python reconnait et peut convertir en C : https://www.tutorialspoint.com/python/python_further_extensions.htm Curiosité : import sys sys.getrefcount(test1) ***********************************************************/ #include "Python.h" static PyObject *test1_mult(PyObject *self, PyObject *args) { //============================================================= // Définit la fonction en C qui sera appelée depuis Python const long lNb1; const long lNb2; long lRep; if (!PyArg_ParseTuple(args, "ll", &lNb1, &lNb2)) return NULL; // c.f. https://docs.python.org/3.3/c-api/arg.html#PyArg_ParseTuple lRep = lNb1 * lNb2; return PyLong_FromLong(lRep); // c.f. https://docs.python.org/3.3/c-api/long.html } // test1_mult static PyMethodDef test1Methods[] = { //=================================== {"mult", test1_mult, METH_VARARGS, "mult prend deux nombres entiers en entrée et retourne leur produit."}, // Est un texte d'aide. Obtenu avec : print(test1.mult.__doc__) {NULL, NULL, 0, NULL} // Sentinel }; static struct PyModuleDef test1module = { //======================================= // Est une structure nécessaire pour Python ??? PyModuleDef_HEAD_INIT, "test1", /* name of module */ NULL, //test1_doc, /* module documentation, may be NULL */ -1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */ test1Methods }; PyMODINIT_FUNC PyInit_test1(void) { //================================= // Fonction de création du module return PyModule_Create(&test1module); } // PyInit_test1 int main(int argc, char *argv[]) { //================================ // Fonction principale, qui sera exécutée au chargement du module wchar_t *program = Py_DecodeLocale(argv[0], NULL); if (program == NULL) { fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); exit(1); } /* Add a built-in module, before Py_Initialize */ PyImport_AppendInittab("test1", PyInit_test1); /* Pass argv[0] to the Python interpreter */ Py_SetProgramName(program); /* Initialize the Python interpreter. Required. */ Py_Initialize(); /* Optionally import the module; alternatively, import can be deferred until the embedded script imports it. */ PyImport_ImportModule("test1"); PyMem_RawFree(program); return 0; } // main // Il y a beaucoup de points que je ne comprends pas, mais cela fonctionne !
""" test1.py Ceci est un exemple d'appel à une routine écrite en langage C. Test la librairie de démo "test1.c" """ import test1 print(test1.mult(7, 8)) print(test1.mult(123456789, 123)) print(test1.mult(111111111, 111111111)) a=11 b=12 print(test1.mult(a, b)) print(test1.mult.__doc__) # pour afficher de l'aide sur la fonction.
/* test2.c L'objectif est d'avoir une soubroutine en C qui peut être accédé depuis le langage Python. Pour compiler depuis un Terminal : gcc -shared -o test2.so -fPIC test2.c Depuis Python, si on veut taper dans la console : import os os.getcwd() # indique le répertoire par défaut os.chdir("/home/bg/Bg2/Python/ctests") # pour changer le répertoire par défaut import test2 test2.mult(3.1415, 7.0) # retournera le produit 3.1415 * 7 Les arguments doivent être deux nombres à virgule. Mieux : exécuter le script test2.py qui est donné dans un autre fichier. Pour les types que Python reconnait et peut convertir en C : https://www.tutorialspoint.com/python/python_further_extensions.htm Curiosité : import sys sys.getrefcount(test2) **************************************************************/ #include "Python.h" static PyObject *test2_mult(PyObject *self, PyObject *args) { //============================================================= // Définit la fonction en C qui sera appelée depuis Python const double vNb1; const double vNb2; double vRep; if (!PyArg_ParseTuple(args, "dd", &vNb1, &vNb2)) return NULL; vRep = vNb1 * vNb2; return PyFloat_FromDouble(vRep); // https://docs.python.org/3.3/c-api/float.html } // test2_mult // Définit l'aide associée à la fonction. #define AIDE "mult prend deux nombres à virgule en \ entrée et retourne leur produit." static PyMethodDef test2Methods[] = { //=================================== {"mult", test2_mult, METH_VARARGS, AIDE}, // Est un texte d'aide. Obtenu avec : print(test2.mult.__doc__) {NULL, NULL, 0, NULL} // Sentinel }; static struct PyModuleDef test2module = { //======================================= // Est une structure nécessaire pour Python ??? PyModuleDef_HEAD_INIT, "test2", /* name of module */ NULL, //test2_doc, /* module documentation, may be NULL */ -1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */ test2Methods }; PyMODINIT_FUNC PyInit_test2(void) { //================================= // Fonction de création du module return PyModule_Create(&test2module); } // PyInit_test2 int main(int argc, char *argv[]) { //================================ // Fonction principale, qui sera exécutée au chargement du module wchar_t *program = Py_DecodeLocale(argv[0], NULL); if (program == NULL) { fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); exit(1); } /* Add a built-in module, before Py_Initialize */ PyImport_AppendInittab("test2", PyInit_test2); /* Pass argv[0] to the Python interpreter */ Py_SetProgramName(program); /* Initialize the Python interpreter. Required. */ Py_Initialize(); /* Optionally import the module; alternatively, import can be deferred until the embedded script imports it. */ PyImport_ImportModule("test2"); PyMem_RawFree(program); return 0; } // main // Il y a beaucoup de points que je ne comprends pas, mais cela fonctionne !
""" test2.py Ceci est un exemple d'appel à une routine écrite en langage C. Test la librairie de démo "test2.c" """ import test2 print(test2.mult(3.1415, 7.0)) print(test2.mult(3.141593, 113.0)) print(test2.mult(1.111e8, 1.111e9)) a = 9.999 b = 1.111 print(test2.mult(a, b)) print(test2.mult.__doc__) # pour afficher de l'aide sur la fonction.
/* test3.c L'objectif est d'avoir une soubroutine en C qui peut être accédé depuis le langage Python. Pour compiler depuis un Terminal : gcc -shared -o test3.so -fPIC test3.c Depuis Python, si on veut taper dans la console : import os os.getcwd() # indique le répertoire par défaut os.chdir("/home/bg/Bg2/Python/ctests") # pour changer le répertoire par défaut import test3 test3.sommeInv(700) # retournera la somme des inverses des entiers de 1 à 700 L'argument doit être un nombre entier. Retourne un nombre à virgule Mieux : exécuter le script test3.py qui est donné dans un autre fichier. Pour les types que Python reconnait et peut convertir en C : https://www.tutorialspoint.com/python/python_further_extensions.htm ***********************************************************************/ #include "Python.h" static PyObject *test3_sommeInv(PyObject *self, PyObject *args) { //=============================================================== // Définit la fonction en C qui sera appelée depuis Python // PyObject *x_obj; // autre possibilité. // Somme des inverses des nombres entiers de lNbMin à lNbMax-1 // lNbMin et lNbMax sont les deux arguments. long lNbMax; long lNbMin; long lNbr; double vRep; if (!PyArg_ParseTuple(args, "ll", &lNbMin, &lNbMax)) return NULL; // c.f. https://docs.python.org/3.3/c-api/arg.html#PyArg_ParseTuple //if (!PyArg_ParseTuple(args, "O", &x_obj)) return NULL; //lNbMax = PyLong_AsLong(x_obj); // c.f. https://docs.python.org/3.3/c-api/long.html vRep = 0.0; for (lNbr=lNbMax-1; lNbr>=lNbMin; lNbr--) vRep = vRep + 1.0 / lNbr; return PyFloat_FromDouble(vRep); // https://docs.python.org/3.3/c-api/float.html } // test3_sommeInv // Définit l'aide associée à la fonction. #define AIDE "sommeInv prend deux nombres entiers Nmin et Nmax en entrée\n\ et retourne la somme des inverses des entiers de 1/Nmin à 1/(Nmax-1)." static PyMethodDef test3Methods[] = { //=================================== {"sommeInv", test3_sommeInv, METH_VARARGS, AIDE}, // Est un texte d'aide. Obtenu avec : print(test3.sommeInv.__doc__) {NULL, NULL, 0, NULL} // Sentinel }; static struct PyModuleDef test3module = { //======================================= // Est une structure nécessaire pour Python ??? PyModuleDef_HEAD_INIT, "test3", /* name of module */ NULL, //test3_doc, /* module documentation, may be NULL */ -1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */ test3Methods }; PyMODINIT_FUNC PyInit_test3(void) { //================================= // Fonction de création du module return PyModule_Create(&test3module); } // PyInit_test3 int main(int argc, char *argv[]) { //================================ // Fonction principale, qui sera exécutée au chargement du module wchar_t *program = Py_DecodeLocale(argv[0], NULL); if (program == NULL) { fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); exit(1); } /* Add a built-in module, before Py_Initialize */ PyImport_AppendInittab("test3", PyInit_test3); /* Pass argv[0] to the Python interpreter */ Py_SetProgramName(program); /* Initialize the Python interpreter. Required. */ Py_Initialize(); /* Optionally import the module; alternatively, import can be deferred until the embedded script imports it. */ PyImport_ImportModule("test3"); PyMem_RawFree(program); return 0; } // main
""" test3.py Ceci est un exemple d'appel à une routine écrite en langage C. Test la librairie de démo "test3.c" """ import test3 print(test3.sommeInv.__doc__) # pour afficher de l'aide sur la fonction. print() print(test3.sommeInv(10, 100)) # 1/10 + 1/11 + 1/12 + 1/13 + 1/14 + ... + 1/(N-1) print(test3.sommeInv(100, 1000)) # 1/100 + 1/101 + 1/102 + 1/103 + ... + 1/(N-1) print(test3.sommeInv(1000, 10000)) # 1/1000 + 1/1001 + 1/1002 + ... + 1/(N-1) print(test3.sommeInv(10000, 100000)) # 1/10000 + 1/10001 + 1/10002 + ... + 1/(N-1) print() nn=10 while (nn < 100000000): print(test3.sommeInv(nn, 10*nn)) nn=10*nn # On remarque que ces sommes donnent presque le même résultat. # Ceci suggère très fortement que la série harmonique diverge # et montre également qu'elle diverge comme Ln(N). # La constante d'Euler-Mascheroni est définie par # gamme = lim(N -> infini) (somme 1/k - Ln(N)) = 0,577 215 664 901 532 860 6… # c.f. https://fr.wikipedia.org/wiki/Constante_d%27Euler-Mascheroni print() import math nn=100000000 print("gama = ", test3.sommeInv(1, nn) - math.log(nn))
/* test4.c L'objectif est d'avoir une soubroutine en C qui peut être accédé depuis le langage Python. Pour compiler depuis un Terminal : gcc -shared -o test4.so -fPIC test4.c Depuis Python, exécuter le script test4.py qui est donné dans un autre fichier. Pour les types que Python reconnait et peut convertir en C : https://www.tutorialspoint.com/python/python_further_extensions.htm ***********************************************************************/ #include "Python.h" static PyObject *test4_sommeInv9(PyObject *self, PyObject *args) { //=============================================================== // Définit la fonction en C qui sera appelée depuis Python // PyObject *x_obj; // autre possibilité. // Somme des inverses des nombres entiers de lNbMin à lNbMax-1 // lNbMin et lNbMax sont les deux arguments. // test4_sommeInv9(1,10) = 2.8178571428571426; // La somme de 1 à 8 // test4_sommeInv9(10,100) = 2.063991622224917; // La somme de 10 à 88 // test4_sommeInv9(100,1000) = 1.818871425200977; // La somme de 1 à 8888 // test4_sommeInv9(1000,10000) = 1.633464212583175; // La somme de 1 à 88888 long lNbMax; long lNbMin; long lNbr; long lDixPow; double vRep; if (!PyArg_ParseTuple(args, "ll", &lNbMin, &lNbMax)) return NULL; //if (!PyArg_ParseTuple(args, "O", &x_obj)) return NULL; //lNbMax = PyLong_AsLong(x_obj); // c.f. https://docs.python.org/3.3/c-api/long.html vRep = 0.0; lNbr=lNbMin; while (lNbr<lNbMax) { if (lNbr % 10 == 9) { lNbr ++; if (lNbr/10 % 10 == 9) { lNbr += 10; if (lNbr/100 % 10 == 9) { lNbr += 100; // J'ai laissé quelques "if" pour comprendre la structures des tests. lDixPow = 1000; while (lNbr/lDixPow % 10 == 9) { lNbr += lDixPow; lDixPow *=10; } } } } vRep = vRep + 1.0 / lNbr; lNbr++; } // while return PyFloat_FromDouble(vRep); // https://docs.python.org/3.3/c-api/float.html } // test4_sommeInv9 // Définit l'aide associée à la fonction. #define AIDE "sommeInv9 prend deux nombres entiers Nmin et Nmax en entrée\n\ et retourne la somme des inverses des entiers de 1/Nmin à 1/(Nmax-1)\n\ dans laquelle tous les nombres contenant le chiffre 9\n\ ont été éliminés. Voici des nombres éliminés :\n\ 9 ; 19 ; 29 ; 9xxx ; 19xxx ; 29xxx ; 999999.\n\ Nmin ne doit pas contenir de chiffre 9." static PyMethodDef test4Methods[] = { //=================================== {"sommeInv9", test4_sommeInv9, METH_VARARGS, AIDE}, // Est un texte d'aide. Obtenu avec : print(test4.sommeInv9.__doc__) {NULL, NULL, 0, NULL} // Sentinel }; static struct PyModuleDef test4module = { //======================================= // Est une structure nécessaire pour Python ??? PyModuleDef_HEAD_INIT, "test4", /* name of module */ NULL, //test4_doc, /* module documentation, may be NULL */ -1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */ test4Methods }; PyMODINIT_FUNC PyInit_test4(void) { //================================= // Fonction de création du module return PyModule_Create(&test4module); } // PyInit_test4 int main(int argc, char *argv[]) { //================================ // Fonction principale, qui sera exécutée au chargement du module wchar_t *program = Py_DecodeLocale(argv[0], NULL); if (program == NULL) { fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); exit(1); } /* Add a built-in module, before Py_Initialize */ PyImport_AppendInittab("test4", PyInit_test4); /* Pass argv[0] to the Python interpreter */ Py_SetProgramName(program); /* Initialize the Python interpreter. Required. */ Py_Initialize(); /* Optionally import the module; alternatively, import can be deferred until the embedded script imports it. */ PyImport_ImportModule("test4"); PyMem_RawFree(program); return 0; } // main
""" test4.py Ceci est un exemple d'appel à une routine écrite en langage C. Test la librairie de démo "test4.c" """ import test4 print(test4.sommeInv9.__doc__) # pour afficher de l'aide sur la fonction. print() print(test4.sommeInv9(1, 10)) # 1/1 + 1/2 + 1/3 + 1/4 + ... + 1/8 (1/9 est éliminé) print(test4.sommeInv9(10, 100)) # 1/10 + 1/11 + 1/12 + 1/13 + 1/14 + ... + 1/88 # Eliminé : 1/19, 1/29, ..., 1/79, 1/89 à 1/99 print(test4.sommeInv9(100, 1000)) # 1/100 + 1/101 + 1/102 + 1/103 + ... + 1/888 print(test4.sommeInv9(1000, 10000)) # 1/1000 + 1/1001 + 1/1002 + ... + 1/8888 print(test4.sommeInv9(10000, 100000)) # 1/10000 + 1/10001 + 1/10002 + ... + 1/88888 print() nn=10 s2 = test4.sommeInv9(nn, 10*nn) while (nn < 100000000): s1 = s2 nn=10*nn s2 = test4.sommeInv9(nn, 10*nn) print("Rapport =", s2/s1) # On remarque que le rapport de ces sommes tend vers 0,9 # Ceci suggère très fortement que cette série converge # comme 0.9^Log10(N) # Donc la convergence est très lente. nn = 10000000 s1 = test4.sommeInv9(1, nn) s2 = test4.sommeInv9(nn, 10*nn) # La valeur limite est environ : # s1 + s2*(1 + 0.9 + 0.9^2 + 0.9^3 + 0.9^4 + ...) = s1 + 10*s2 print("Valeur limite =", s1 + 10*s2) # On montre par d'autres méthodes que la valeur limite vaut bien : # 22,92067 66192 64150 34816 ...
Plan du Site :
Home
Python
python_code_c.html
( = http://www.juggling.ch/gisin/python/python_code_c.html )
Page mise à jour le 15 mars 2018 par Bernard Gisin
( Envoyer un e-mail )
Hébergement par : www.infomaniak.ch