[Langage] Comment créer des fonctions qui sont des variables

Bonjour

Je voudrais créer des variables qui sont en fait des fonctions mathématiques.

Ceci est un code Maple, et c'est exactement ce que je veux faire:
La variable g[1,2] est une fonction par morceaux qui dépend de x.

g[1,2]:=unapply(piecewise(x<1,0,x=>1,1),x):

Si on fait g[1,2](2), on obtient la valeur de cette fonction en 2, c'est a dire 1.

Comment faire ceci en C++? Je penche pour des pointeurs de fonctions.

Par exemple, je pourrait créer un prototype d'une telle fonction, qui prend des paramètres abstraits.
Lors de l'instantiation de fonctions, je précise les paramètres qui vont avec cette fonction. Je pourrais ainsi appeler à n'importe quel moment du code la fonction. Je pourrais aussi la détruire...
Qu'en pensez vous?

des foncteurs iraient effectivement, mais tu dois pour le cas de ton g créer une matrice de foncteurs avec des double en argument.

par foncteurs tu veux dire pointeurs vers des fonctions ?

créer une matrice de foncteurs avec des double en argument.
La matrice servirait à stocker les fonction g[i,j]_{i,j}??

As tu un exemple de foncteur?
merci

Voila ce que j'ai fait:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

double f(double x,double param){ if(x<0){return 0;} if(x>1){return 0;} if(x<0.5){return param;} if(x>=0.5){return 1-param;}   }   double fonction2(double a1,double a2,double a3,double m,double x){ if(x<a1){return 0;} if(x>a3){return 0;} if(x<a2){return f(x,m)*m;} if(x>=a2){return f(x,m)*(1-m);} }   int main(){ double *g=new double[100]; fonction2 *tableau=new fonction2[100]; double (*p)(double,double,double,double,double); p=&fonction2; cout<<(*p)(2,3,4,2,4); return 0;   }

---

ensuite j'aimerais créer un tableau dont les case contiennent le pointeur vers la fonction g. (en gros, la fonction g elle-même).
Je me suis basé sur double *g=new double[100]; pour faire: fonction2 *tableau=new fonction2[100];

mais bien sur fonction2 n'est pas un type de C++
Alors faut il créer un typdef, enfin qqch comme ca pour créer un type?

dans ton cas, je mettrais pour g:

Code:

---

1 2 3 4

typedef double (*Tonpointeur)(double); Tonpointeur **g=new Tonpointeur*[largeur] for(int i=0; i<largeur;++i) g[i]=newTonpointeur[longeur]

---

ahhh j'y étais presque
j'ai fait:

Code:

---

typedef double (*t)(double,double,double,double,double);

---

ca compile, mais je ne sais pas quoi ca fait.
que signifie la ligne de code ci dessus par rapport à la tienne?

ca créé un type qui est un pointeur sur fonction ce que tu as fait :D

Tu as deux solutions : les pointeurs de fonctions, comme déjà expliqué, ou bien les foncteurs, qui sont plus dans l'esprit C++.

http://cpp.developpez.com/faq/cpp/?page=STL#STL_functor

Citation:

---

ca créé un type qui est un pointeur sur fonction ce que tu as fait

---

Ben, lui ca fait quoi?
ca crée un type qui est?
pour moi ce qu'il a fait, c'est un type qui est une fonction qui renvoie un double.

Cette ligne déclare un alias de type nommé t sur le type "pointeur vers fonction prenant cinq double en paramètre et retournant un double".

Code:

---

1 2 3 4 5 6 7 8 9 10

typedef double (*funcPtr)(double);   double fonction1(double toto){ return toto; } double fonction2(double toto){ return toto*2; }   //Puis plus loin dans ton code :   funcPtr mafonction = fonction1; //funcPtr mafonction = fonction2; peut convenir aussi. std::cout << mafonction(3.2) << std::endl; //Cette ligne va appeler fonction1 avec un code tel quel.

---

Si tu manipules des éléments de type pointeur de fonctions, tu ne pourras presque rien faire comme manipulation.

Composition, application partielle de fonction...

Tu devrais passer par boost::function<>, qui acceptent tout foncteur ou pointeur de fonction.

oui, mais alors comment déclarer par exemple g[2][2]?
tel que je le désire, g[2][2] doit être un pointeur sur fonction, et on doit l'appeller n'importe quand dans le code.

Citation:

---

Si tu manipules des éléments de type pointeur de fonctions, tu ne pourras presque rien faire comme manipulation.

Composition, application partielle de fonction...

---

ok mais BOOST c'est vachement compliquer a installer, et utiliser

mais moi, je veux effectivement faire un appel de fonction partiel par exemple on a:

la fonction f:(x,y)->5*x+y;

je veux créer la fonction g(x)=f(5,x) et h(x)=f(4,x)

puis plus tard faire la somme de g(x) et h(x) pour x=4 par ex

Citation:

---

Envoyé par HanLee

Tu devrais passer par boost::function<>, qui acceptent tout foncteur ou pointeur de fonction.

---

Ca + boost::bind voir même boost.lambda en plus, ça devrait aller effectivement ;)

Citation:

---

Envoyé par deubelte

ok mais BOOST c'est vachement compliquer a installer, et utiliser

mais moi, je veux effectivement faire un appel de fonction partiel par exemple on a:

la fonction f:(x,y)->5*x+y;

je veux créer la fonction g(x)=f(5,x) et h(x)=f(4,x)

puis plus tard faire la somme de g(x) et h(x) pour x=4 par ex

---

Les modules dont tu as besoin sont header-only... Autrement dit, tu as juste à les inclure, il n'y a rien à lier.

ok je verrais, mais si on en revient a nos moutons,

j'ai fait ca comme code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

double fonction2(double a1,double a2,double a3,double m,double x){ if(x<a1){return 0;} if(x>a3){return 0;} if(x<a2){return f(x,m)*m;} if(x>=a2){return f(x,m)*(1-m);} }   typedef double (*Tonpointeur)(double); Tonpointeur **g=new Tonpointeur*[6]; for(i=0;i<6;i++){ g[i]=new Tonpointeur[largeur]; }

---

maintenant, comment définir par exemple g[0][0]??
merci

Citation:

---

Envoyé par deubelte

maintenant, comment définir par exemple g[0][0]??
merci

---

Code:

---

1 2	double f(double d) { return 0.1*x; } g[0][0] = &f;

---

j'ai fait:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

double fonction2(double a1,double a2,double a3,double m,double x){return 2*x;}       int main(){ double m1,m2,m3,m4,m5; m1=0;m2=0.25;m3=0.5;m4=0.75;m5=1;   double largeur=pow((int) 2,(double) 5); long j,i;   typedef double (*Tonpointeur)(double); Tonpointeur **g=new Tonpointeur*[6]; for(i=0;i<6;i++){ g[i]=new Tonpointeur[largeur]; }   g[0][0]=&fonction2; double *gl=new double[100];   return 0;   }

---

ca me renvoie une erreur:

error C2440: '='*: impossible de convertir de 'double (__cdecl *)(double,double,double,double,double)' en 'Tonpointeur'

Ben, c'est normal: Tonpointeur est un alias sur le type "pointeur vers une fonction qui prend un seul double en paramètre et retourne un double", et tu cherches en faire pointer un vers une fonction qui prend cinq double en paramètre...

ok merci
c'est ce que j'avais fait au départ.
j'ai l'impression que l'usage de pointeurs en C+ sur fonction est tres limité.

Peut on utiliser les pointeurs avec des appels de fonctions partiels, des compositions de fonction? (je donne un exemple plus haut de ce que je veux faire).

Citation:

---

Envoyé par deubelte

ok merci
c'est ce que j'avais fait au départ.
j'ai l'impression que l'usage de pointeurs en C+ sur fonction est tres limité.

Peut on utiliser les pointeurs avec des appels de fonctions partiels, des compositions de fonction? (je donne un exemple plus haut de ce que je veux faire).

---

Je t'ai dit non plus haut, à moins de tricher salement et difficilement...

Citation:

---

Envoyé par HanLee

Je t'ai dit non plus haut, à moins de tricher salement et difficilement...

---

Ce qui est possible toutefois. boost::bind permet l'application partielle et la composition est aisee avec boost::function et boost::bind. On peut meme aller plus loin avec boost.phoenix / boost.lambda.

Toutes les opérations que tu peux faire dans un langage fonctionnel et même plus sont possibles.

Je n'ai jamais trouvé de solution agréable pour la mémoization. En particulier, le point qui me manque est le "remplacement" dans un code existant, pas spécialement écrit pour, d'une fonction par sa version mémoizée.

auto f_memoized = memoize<argument_type>(f);
devrait parfaitement être capable de générer une fonction f_memoized qui fera de la memoization sur f... (argument_type n'a même pas forcément besoin d'être spécifié si il peut être déduit d'après f, comme c'est le cas pour un pointeur de fonction par exemple)
Il suffit de faire une table avec les arguments comme clé, de chercher la valeur dans la table, et si elle n'y est pas d'appeler la fonction enrobée.

Boost.Flyweight (avec le système key_value) permet ce genre de choses, sauf que c'est orienté constructeur plutôt que fonction, ce qui est équivalent.

Oui, mais mon problème est de pouvoir ensuite dans un code :

Code:

---

1 2 3 4

int g() { return f(); }

---

Utiliser f_memoized à la place de f sans pour autant avoir à toucher une virgule de la définition de g. Dans l'idéal, je voudrais pouvoir écrire :

Code:

---

auto g_optimized = memoize(g, f);

---

Qui ferait l'équivalent de :

Code:

---

1 2 3 4

int g_optimized() { return f_memoized(); }

---

J'avais même pas pensé qu'il pouvait être utile de memoizer une fonction sans arguments.

Tu peux pas vraiment faire ce que tu veux, non, à moins de remplacer l'invocation de f par celle de memoize(f) ce qui demanderait sûrement de l'aide de la part de l'éditeur de liens.

Citation:

---

Envoyé par loufoque

J'avais même pas pensé qu'il pouvait être utile de memoizer une fonction sans arguments.

---

J'ai juste zappé les morceaux qui ne me semblaient pas pertinents pour mon problème.

Citation:

---

Envoyé par loufoque

Tu peux pas vraiment faire ce que tu veux, non, à moins de remplacer l'invocation de f par celle de memoize(f) ce qui demanderait sûrement de l'aide de la part de l'éditeur de liens.

---

Oui. Ou alors une abomination à base de macros peut-être, mais je n'ai pas trop voulu chercher dans cette voie.

Citation:

---

Envoyé par JolyLoic

Oui. Ou alors une abomination à base de macros peut-être, mais je n'ai pas trop voulu chercher dans cette voie.

---

On doit pouvoir s'en sortir. Mais 1/ ça serait affreusement inutilisable (fonctionnel mais dégueulasse quoi) 2/ le besoin est faible à ma connaissance :aie:

Citation:

---

Envoyé par Alp

2/ le besoin est faible à ma connaissance :aie:

---

Je pense que mémoizer du code non prévu pour sans le retoucher pourrait avoir une certaine valeur pendant une phase d'optimisation. Mais ça demande certainement un langage plus dynamique que le C++...

Citation:

---

Envoyé par JolyLoic

Je pense que mémoizer du code non prévu pour sans le retoucher pourrait avoir une certaine valeur pendant une phase d'optimisation. Mais ça demande certainement un langage plus dynamique que le C++...

---

En plus de ça, j'imagine déjà la complexité de la chose...

Faire de la memoization ça change la complexité des algorithmes et tout, moi c'est plus quelque chose auquel je penserais au début de la conception qu'à la fin.

Citation:

---

Envoyé par JolyLoic

Oui, mais mon problème est de pouvoir ensuite dans un code :

Code:

---

1 2 3 4

int g() { return f(); }

---

Utiliser f_memoized à la place de f sans pour autant avoir à toucher une virgule de la définition de g. Dans l'idéal, je voudrais pouvoir écrire :

Code:

---

auto g_optimized = memoize(g, f);

---

Qui ferait l'équivalent de :

Code:

---

1 2 3 4

int g_optimized() { return f_memoized(); }

---

---

Quand je memoize (ce qui m'est arrive en phase d'optimisation), c'est f() que je touche, pas les clients que je ne connais parfois meme pas. Je comprends donc mal ta problematique; pour ce que j'en percois, je me demande si une piste n'est pas de jouer avec la recherche des noms (rendre f() non visible et importer un f() d'un namespace memoized).

Citation:

---

Envoyé par loufoque

Faire de la memoization ça change la complexité des algorithmes et tout, moi c'est plus quelque chose auquel je penserais au début de la conception qu'à la fin.

---

C'est avant tout déplacer le curseur sur le compromis mémoire/performances et c'est donc quelque-chose que j'estime légitime de faire quand j'ai de vraies données de profiling pour étayer mon choix.

Citation:

---

Envoyé par Jean-Marc.Bourguet

Quand je memoize (ce qui m'est arrive en phase d'optimisation), c'est f() que je touche, pas les clients que je ne connais parfois meme pas.

---

Pour l'instant, c'est plus une interrogation théorique qu'un besoin concret, je passe donc peut-être à coté de certains problèmes. L'idée de base étant comment fournir de la mémoization en C++ qui tienne en une seule ligne.

Le faire à l'extérieur de la fonction à mémoizer est envisageable avec de la métaprogrammation, mais dans ce cas là, on doit modifier le code client, ce que j'aurais aimé éviter. L'avantage est que pour deux clients différents, qui n'auraient pas les mêmes profils de donnée en entrée, on pourrait décider que l'un utilise la version mémoizée, pas l'autre.

Le faire depuis l'intérieur de la fonction en question me semble un peu moins direct, et demande un refactoring du code. De plus, tous les clients utilisent alors la version mémoizée.

Dans mon monde idéal, on n'a besoin de toucher ni au code de f, ni à celui de g, mais uniquement au code initialement client de g, pour décider d'appeler un code équivalent à g mais qui fait appel à une version mémoizée de f. J'hésite sur les compromis qui me semblent les plus acceptables par rapport à cette vision, et je manque un peu d'un cas concret pour m'aider à choisir.

Citation:

---

Envoyé par Jean-Marc.Bourguet

Je comprends donc mal ta problematique; pour ce que j'en percois, je me demande si une piste n'est pas de jouer avec la recherche des noms (rendre f() non visible et importer un f() d'un namespace memoized).

---

C'est effectivement une piste intéressante. C'est la partie "rendre f non visible" qui me pose problème, je ne vois pas trop comment y parvenir dans mes hypothèses de travail.

Citation:

---

Envoyé par JolyLoic

Le faire à l'extérieur de la fonction à mémoizer est envisageable avec de la métaprogrammation, mais dans ce cas là, on doit modifier le code client, ce que j'aurais aimé éviter. L'avantage est que pour deux clients différents, qui n'auraient pas les mêmes profils de donnée en entrée, on pourrait décider que l'un utilise la version mémoizée, pas l'autre.

---

Si tu ne le fais pas pour tout les clients avec le meme algo (on peut jouer sur le nombre de valeur dans le cache et la maniere dont les valeurs dans le cache sont remplacee), il va te falloir faire quelque chose pour indiquer a chaque client ce qu'il appelle. Le plus simple me semble de changer le nom de la fonction appelee.

Citation:

---

Dans mon monde idéal, on n'a besoin de toucher ni au code de f, ni à celui de g, mais uniquement au code initialement client de g, pour décider d'appeler un code équivalent à g mais qui fait appel à une version mémoizée de f. J'hésite sur les compromis qui me semblent les plus acceptables par rapport à cette vision, et je manque un peu d'un cas concret pour m'aider à choisir.

---

Ca, je ne vois pas comment faire sans liaison dynamique -- tel que tu le specifies, deux appels differents a g() peuvent utiliser des versions differentes de f(). Donc difficile a faire sans refactoriser pour passer a g l'info necessaire ou passer aux astuces plus ou moins avouables.

Evidemment, trivial avec un lisp scope dynamiquement -- mais bon ils sont un peu hors mode -- ou qui permet le choix (Common Lisp, demande a Pascal, il se fera un plaisir de te renseigner :D)

Citation:

---

C'est effectivement une piste intéressante. C'est la partie "rendre f non visible" qui me pose problème, je ne vois pas trop comment y parvenir dans mes hypothèses de travail.

---

En toute generalite, ce n'est pas simple; et ca ne permet pas le choix dynamique. Mais c'est une approche qui peut etre utile.