Restriction d'une fonction à plusieurs paramètres

On Fri, 23 Apr 2004 14:26:52 +0200, "Boris Sargos"
<bsargos@wanadoo.fr> wrote:

Salut à tous,

supposons que j'aie les prototypes suivants (exemples simples et peu
intéressants en eux-mêmes) :

-) une fonction Primitive qui me calcule la primitive d'une fonction f
passée en argument en un point t donné :

double Primitive ( double(*f)(double), t);

double Primitive ( double(*f)(double), double);

"la primitive d'une fonction en un point donné" n'existe pas, mais bon
;-)

-) une fonction Indicatrice qui détermine si un nombre est compris dans
un certain intervalle [i, i+1] :

double Indicatrice ( int, double );

Je suppose que Indicatrice retourne 0 ou 1...

Mon objectif est de pouvoir écrire une fonction du type :

double (*Indicatrice_i)(double) = Indicatrice(i); //
restriction à l'intervalle i de la fonction Indicatrice

pour entre autres utiliser une boucle propre du genre :

for(int i ...;;) {
// Calcul de la primitive en t
double It = Primitive ( Indicatrice_i , t );
}

Quelqu'un a-t-il une idée ?

static int ii;
double Indicatrice0(double t)
{
return Indicatrice(ii,t);
}

for (i=0;i<42;i++) {
ii=i;
Primitive (Indicatrice0, 42);
}

ou bien

double (*setindicatrice(int i))(double)
{
ii = i;
return Indicatrice0;
}

for (i=0;i<42;i++)
Primitive (setindicatrice(i), 42);


--
Horst

Merci Horst,

la deuxième solution que tu proposes se rapproche plus de ce que je
recherche. Au fait,
"la primitive d'une fonction en un point donné" existe bel et bien. J'aurais
dû être plus clair : "évaluer en un point donné la primitive F de la
fonction f" :-)
Merci.
Boris.

On Fri, 23 Apr 2004 16:38:41 +0200, "Boris Sargos"
<bsargos@wanadoo.fr> wrote:

Merci Horst,

la deuxième solution que tu proposes se rapproche plus de ce que je
recherche. Au fait,
"la primitive d'une fonction en un point donné" existe bel et bien. J'aurais
dû être plus clair : "évaluer en un point donné la primitive F de la
fonction f" :-)

Mais de quelle primitive parles-tu? Si F est une primitive de F, alors
F + 42 est aussi une primitive... Quelle est ta définition de
"primitive" ?

--
Horst

J'ai la même définition que tout le monde. Mais tu as raison : j'aurais dû
dire "une" primitive. Pour l'unicité, le tout est de choisir une origine.
Pour mon exemple, je pensais que ce n'était qu'un détail...

Boris

Salut à tous,

supposons que j'aie les prototypes suivants (exemples simples et peu
intéressants en eux-mêmes) :

-) une fonction Primitive qui me calcule la primitive d'une fonction f
passée en argument en un point t donné :

double Primitive ( double(*f)(double), t);

-) une fonction Indicatrice qui détermine si un nombre est compris dans
un certain intervalle [i, i+1] :

double Indicatrice ( int, double );


Mon objectif est de pouvoir écrire une fonction du type :

double (*Indicatrice_i)(double) = Indicatrice(i); //
restriction à l'intervalle i de la fonction Indicatrice

pour entre autres utiliser une boucle propre du genre :

for(int i ...;;) {
// Calcul de la primitive en t
double It = Primitive ( Indicatrice_i , t );
}

Bonjour,
outre la solution de H.K., une autre assez différente est disponible.
Elle repose sur les "closures" (désolé pour l'anglicisme, mais je ne
connais pas le terme français, fermeture ? Clôture ?). Elle fait
intervenir la surcharge de l'opérateur ().

class Indicatrice {
public:
Indicatrice( int i ) : val(i) {}
inline double operator() (double x) {
if (x >= i && x <= i+1) {
return x;
} else {
return 0;
}
}
int val;
};

Indicatrice ind(5);
double t1 = ind(3.5); // t1 vaut 0
double t2 ind(5.5); // t2 vaut 5.5

L'intérêt est, en autre, de ne pas subir l'overhead des pointeurs
de fonctions.

Évidemment le prototype de Primitive doit être ajusté en conséquence.

Enfin, si tu veux jouer avec les closures, je te conseille plutôt de
regarder du côté de Boost::Lambda.

--
Djelal Raouf
djelal point raouf at ensta point org

Djelal Raouf <shahinshah@invalid.fr> wrote in message
news:<c6bkp1$fqs$1@aphrodite.grec.isp.9tel.net>...

supposons que j'aie les prototypes suivants (exemples simples et peu
intéressants en eux-mêmes) :

-) une fonction Primitive qui me calcule la primitive d'une fonction f
passée en argument en un point t donné :

double Primitive ( double(*f)(double), t);

-) une fonction Indicatrice qui détermine si un nombre est
compris dans un certain intervalle [i, i+1] :

double Indicatrice ( int, double );

Mon objectif est de pouvoir écrire une fonction du type :

double (*Indicatrice_i)(double) = Indicatrice(i); //
restriction à l'intervalle i de la fonction Indicatrice

pour entre autres utiliser une boucle propre du genre :

for(int i ...;;) {
// Calcul de la primitive en t
double It = Primitive ( Indicatrice_i , t );
}

outre la solution de H.K., une autre assez différente est disponible.
Elle repose sur les "closures" (désolé pour l'anglicisme, mais je ne
connais pas le terme français, fermeture ? Clôture ?). Elle fait
intervenir la surcharge de l'opérateur ().

class Indicatrice {
public:
Indicatrice( int i ) : val(i) {}
inline double operator() (double x) {
if (x >= i && x <= i+1) {
return x;
} else {
return 0;
}
}
int val;
};

Indicatrice ind(5);
double t1 = ind(3.5); // t1 vaut 0
double t2 ind(5.5); // t2 vaut 5.5

L'intérêt est, en autre, de ne pas subir l'overhead des pointeurs de
fonctions.

L"intérêt surtout, c'est de permettre plusieurs utilisations à la fois.
Imagine ce qui se passera dans la solution de H.K. si dans la boucle il
y avait une fonction qui elle aussi se servait d'Indicatrice. Sans
parler des histoires de threads. En général, les variables à durée de
vie statique sont à éviter, sauf quand la conception veut qu'il n'y en a
qu'une seule instance, toujours disponible (interface au fichier de
config, par exemple, ou quelque chose de ce genre).

Question vitesse, ça dépend de l'implémentation. C'est vrai que sur la
plupart (toutes) des implémentations aujourd'hui, l'objet fonctionnel
serait plus vite, mais c'est en prime. AMHA, ce sont les autres
avantages qui l'impose, et même si le rapport des performances était
l'inverse, il faudrait le préférer tant que le profiler ne dit pas
autrement.

Évidemment le prototype de Primitive doit être ajusté en conséquence.

Enfin, si tu veux jouer avec les closures, je te conseille plutôt de
regarder du côté de Boost::Lambda.

En attendant quelque chose au niveau du langage. (En fait, si tu veux
jouer avec les clotures, je te conseille un autre langage:-).)

--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34