Appel de fonctions C++ en scilab

Bonjour,

Tout d'abord, je m'excuse si ce message n'est pas dans le bon topic, mais je n'avais pas trouvé de forum Scilab.

En gros mon problème viens d'une fonction que j'ai codée en Scilab est qui est trop lente, je voudrais donc la re-coder en C++, je voudrais savoir comment je dois définir ma fonction C++ pour qu'elle réponde au prototype d'appel suivant :

Code:

function [u,vu] = solvePDE(f,g,bound,dx,dy,DEBUG)

et ce que je devais faire coté Scilab pour pouvoir appeler ma fonction.

Merci d'avance.

Salut,

Autant le dire tout de suite, je ne connais pas scilab (il faudra vraiment que je m'y intéresse un jour) :aie:

Mais bon, je présume que ce qui t'intéresse, c'est de pouvoir coder la fonction solvePDE.

Il faut donc que tu réfléchisse au type des données qui correspondent :
au type de retour de la fonction (quel type correspond à function [u,vu] :question:)
au type de donnée représentée par f (quel type correspond à f :question:)
au type de donnée représentée par g (quel type correspond à g :question:)
au type de donnée représentée par bound (quel type correspond à bound :question:)
au type de donnée représentée par dx (quel type correspond à dx :question:)
au type de donnée représentée par dy (quel type correspond à dy :question:)
au type de donnée représentée par DEBUG (quel type correspond à DEBUG :question:)
A vue de nez, je dirais que le type de retour, f, g, dx et dy correspondront soit à des valeurs numériques entières soit à des valeurs numériques décimales.

Quant à DEBUG, je dirais qu'il serait pas mal que ce soit une valeur énumérée (donc, une des valeurs possibles fournies par une énumération)

Par contre, je n'ai strictement aucune idée pour bound :aie:

Si la valeur de retour, f, g, dx et dy sont des valeurs entières, il faudra te poser deux questions pour pouvoir définir quel à quel type cela correspond en C++:

est-il possible d'avoir des valeurs négatives :question:
quel est l'intervalle de valeurs susceptible d'être utilisé (est-on plus proche de 255 valeurs possibles ou du milliard de valeur possible) :question:
La première réponse te permettra de choisir entre un type signé (qui permet de représenter des valeurs positives et négatives) et un type non signé (qui ne permet la représentation que de valeur positives), spécifié grace au mot clé unsigned et la deuxième réponse te permettra de choisir le type le plus adapté parmi char (typiquement 8 bits), short (souvent 16 bits), int (souvent 32 bits), long (généralement 32 bits) ou long long (généralement 64 bits).

Si ce sont plutôt des valeurs décimales, tu devra faire le choix entre float, double et long double, en fonction de la précision qui t'est nécessaire.

Ces questions ont pour but de te permettre de déterminer la signature de la fonction solvePDE qui pourrait prendre une forme proche de
Code:

1 2 3 4 5 6 enum ModeEnumeration{ DEBUG, RELEASE }; int solvePDE(int f, int g, UnType bound, int dx, int dy, ModeEnumeration mode);
NOTA:
j'ai choisi de considérer que le type de retour, f, g, dx et dy étaient des entiers potentiellement négatifs... Ce sera à toi de faire en sorte que cela corresponde à tes besoin ;)
Comme je ne sais rien de bound, j'ai utilisé un type nommé "UnType" qu'il s'agira de définir plus précisément
Typiquement, la première valeur d'une énumération vaut 0 et les valeurs énumérées prennent la valeur suivante. Dans mon exemple, DEBUG vaut 0 et RELEASE vaut 1... Cela devra aussi être adapté à tes besoins ;)

tu pourras alors créer le code de ta fonction, sous une forme proche de
Code:

1 2 3 4 int solvePDE(int f, int g, UnType bound, int dx, int dy, ModeEnumeration mode){ /* tout ce qui doit être fait */ return /* quelque chose à rajouter ici */; }
Cette fonction devra, bien sûr, être compilée avec un compilateur C++

La dernière étape sera de permettre à scilab d'accéder à cette fonction.

Je soupçonne très fortement le fait qu'il est plus facile d'utiliser des fonctions C que des fonctions C++ en scilab (bien que ce ne soit qu'un apriori qui n'est peut être pas fondé ;)).

Si tu veux développer ta fonction en C++ il faudra indiquer qu'elle doit être reconnue comme une fonction C grâce au mot clé extern C.

La déclaration de la fonction ressemblera alors à quelque chose comme
Code:

1 2 3 extern "C"{ int solvePDE(int f, int g, UnType bound, int dx, int dy, ModeEnumeration mode); }
La dernière difficulté consistera à savoir comment scilab est en mesure d'accéder aux fonctions programmées en C.

Il est possible que sciliab soit en mesure d'utiliser des bibliothèques statiques, mais il est beaucoup plus probable qu'il ne soit en mesure d'utiliser que des bibliothèques dynamiques ( dll sous windows).

Il faudra donc que ta fonction soit placée dans une bibliothèque, statique ou dynamique en fonction du cas.

La création d'une bibliothèque statique ne demandera rien d'autre de particulier, mis à part le recours à l'outil qui permettra de créer la dite bibliothèque (à voir en fonction du compilateur utilisé)

Par contre, la génération d'une bibliothèque dynamique est un peu plus complexe, car elle dépend très fortement du compilateur utilisé et de la plateforme visée.

Pour éviter d'en arriver à écrire un roman, je vais m'arrêter là pour ma première intervention et te laisser le temps de te renseigner sur tout ce que j'ai déjà abordé ;)

Salut, merci pour ta réponse.

En lisant ta réponse je me rend compte que j'ai pas été super claire...

En fait j'ai déjà codé solvePDE en Scilab, et comme elle est super lente, je voudrais la porter en C++.

Du coup je connais mes types de données :

u, f, et g sont des matrices de doubles de taille N,M
vu est un vecteur de doubles de taille (N-2)*(M-2)
bound est une matrice de double de taille 4,max(N,M)
dx et dy sont des doubles
DEBUG est un booléen qui indique si il faut afficher des trucs...

Je sait que Scilab est capable de charger des *.so/*.dll, mais je ne sait pas comment se fait la traduction des types de données, et comment "renvoyer" plusieurs données.

Désolé de ne pas avoir été claire.

Salut,

en fait ton problème touche pas vraiment à du C++.
Ce qu'il te faut c'est trouver dans la doc scilab comment doit être déclarer une fonction qui réalise cela.
D'après cette page une fonction C++ exportée vers scilab aura cette signature :
Code:

1 2 3 4 extern "C" _declspec(dllexport) void matcpy_c(const double *in, const int *nrow, const int *ncol, double *out);
Comme son nom l'indique il s'agit de copier in dans out.

Tu as aussi toutes les chances d'en savoir davantages sur leur propre doc. 10s m'ont suffit pour arriver sur ça : http://wiki.scilab.org/howto/Create%20a%20toolbox

Finalement : Google sera ton meilleur ami
http://www.scilab.org/fr/resources/documentation

Salut,

Merci pour ta réponse.