Fonction

par **Le Chat** » 13 Sep 2014, 06:00

Bonjour à tous!

Alors, le défi de cette semaine:

Trouver une fonction

(n'importe quelle qui vous vient à l'esprit :id: ) telle que:

si

où

est un nombre réel.

Bonne chance! :zen:

par **fatal_error** » 13 Sep 2014, 07:19

salut,

heavyside

par **Le Chat** » 13 Sep 2014, 07:28

hmmm...je cherchais quelque chose de beaucoup plus simple pour résoudre un problème de programmation.

je dois utiliser une autre approche alors... :hum:

par **fatal_error** » 13 Sep 2014, 07:37

je vois pas ce qu'il y a de plus simple que
f(x) return x>0

par **Le Chat** » 13 Sep 2014, 07:43

fatal_error a écrit:je vois pas ce qu'il y a de plus simple que
f(x) return x>0

Eh bien. Il faut écrire un programme qui

donne 500 pour t = 0 où t est un réel.

La difficulté consiste à ne pas utiliser de function(si/partie entière/arrondi).

par **fatal_error** » 13 Sep 2014, 07:53

ben déjà, "si" c'est pas une fonction mais un (conditionnal) statement.

Ensuite, t'aurais du préciser directement dès le début, parce que sans ca, ta question est triviale comme je l'ai fait remarquer

Et enfin, t'as qu'à utiliser t/|t| qui vaut 1 ou -1...
genre tu prends un truc comme lagrange qui à -1 associe 500 et 1 associe 600:
f(x)=(x-1)(x+1)(a/(x+1) + b/(x-1))
avec a tq quand x vaut -1, (x-1)a=500
et b tq quand x vaut 1, (x+1)b=600

par **Le Chat** » 13 Sep 2014, 08:04

fatal_error a écrit:ben déjà, "si" c'est pas une fonction mais un (conditionnal) statement.

Ensuite, t'aurais du préciser directement dès le début, parce que sans ca, ta question est triviale comme je l'ai fait remarquer

Et enfin, t'as qu'à utiliser t/|t| qui vaut 1 ou -1...
genre tu prends un truc comme lagrange qui à -1 associe 500 et 1 associe 600:
f(x)=(x-1)(x+1)(a/(x+1) + b/(x-1))
avec a tq quand x vaut -1, (x-1)a=500
et b tq quand x vaut 1, (x+1)b=600

oui, mais t/|t| n'est pas défini pour t =0

J'ai essayé toutes sortes de choses pour f(t), mais rien qui satisfait complètement les conditions de départ.

Je pense qu'il va falloir utiliser une autre approche, comme une astuce dans la programmation. non?

par **fatal_error** » 13 Sep 2014, 08:44

ben essaies de creuser un peu quand même
tout ce que t'as à faire c'est trouver un moyen pour trouver une fonction genre (t/abs(t)) définie en zéro.

Ce qui te fait peur c'est diviser par zéro...alors t'as qu'à diviser par un offset genre t+0.01

style t/(abs(t)+FLOAT_MIN)
Comme ca tu joues sur la précision de ta machine :D

une autre possibilité c'est d'utiliser une convergence,
genre arctan(infini)=pi/2 et arctan(-infini)=-pi/2
du coup, t'as juste à prendre un gros nombre genre
arctan(t*FLOAT_MAX) * 2/pi qui vaut -1 ou 1...

c'est à tester, mais théoriquement, c'est possiiiible, après si ton résultat c'est un float...
c'est à voir :D

edit: plus intéressant que ca en a l'air...
je m'en sors pour ma part en combinant les deux

par **Le Chat** » 13 Sep 2014, 15:48

fatal_error a écrit:ben essaies de creuser un peu quand même
tout ce que t'as à faire c'est trouver un moyen pour trouver une fonction genre (t/abs(t)) définie en zéro.

Ce qui te fait peur c'est diviser par zéro...alors t'as qu'à diviser par un offset genre t+0.01

style t/(abs(t)+FLOAT_MIN)
Comme ca tu joues sur la précision de ta machine

une autre possibilité c'est d'utiliser une convergence,
genre arctan(infini)=pi/2 et arctan(-infini)=-pi/2
du coup, t'as juste à prendre un gros nombre genre
arctan(t*FLOAT_MAX) * 2/pi qui vaut -1 ou 1...

c'est à tester, mais théoriquement, c'est possiiiible, après si ton résultat c'est un float...
c'est à voir

edit: plus intéressant que ca en a l'air...
je m'en sors pour ma part en combinant les deux

aah...intéressant. Je vais essayer! :zen:

par **Le Chat** » 13 Sep 2014, 21:47

résolu!

J'ai combiné les fonctions 0^t et arctan (t) pour obtenir qqch qui imite parfaitement la fonction de Heaviside.

merci à toi, fatal_error :zen:

par **fatal_error** » 13 Sep 2014, 21:51

y compris en +l'infini et -l'infini? jvois bien un NaN se profiler avec 0^t :D

par **Le Chat** » 14 Sep 2014, 00:20

ah...non pas pour t = +/- inf...

mais ce n'est pas nécessaire pour la question. :zen: Sinon, t'as des idées pour que ça fonctionne, même pour t = +/- inf...?

par **fatal_error** » 14 Sep 2014, 09:02

oui, de manière grossière, une solution possible est:
une fonction qui fasse NaN nulle part, et qui mappe +l'infini en un truc positif et -l'infini en un truc négatif. T'en as une sous le nez :D

Puis tu la composes avec ta fonction qui fait à priori tout bien sauf en +l'infini et -l'infini !

je suis curieux de voir comment tu te sers de 0^t

par **Le Chat** » 14 Sep 2014, 16:28

fatal_error a écrit:oui, de manière grossière, une solution possible est:
une fonction qui fasse NaN nulle part, et qui mappe +l'infini en un truc positif et -l'infini en un truc négatif. T'en as une sous le nez

Puis tu la composes avec ta fonction qui fait à priori tout bien sauf en +l'infini et -l'infini !

je suis curieux de voir comment tu te sers de 0^t

D'autres problèmes viennent de se poser : je dois résoudre le problème en codant avec un langage de racket qui ne défini pas 0^t pour t < 0, alors que j'expérimentais avec le langage avancé de racket depuis le début. Tout vient de s'effondrer. :hein: Je dois trouver autre chose.

J'ai déjà une piste, mais qui consiste plutôt à jouer sur la précision de l'ordinateur. Alors pour la fonction, je verrai plus tard.

par **Le Chat** » 14 Sep 2014, 22:36

Et...un autre bon 4 heures de passées sur ce problème, sans résultat :crash:

par **fatal_error** » 14 Sep 2014, 23:20

tu peux par ex utiliser cette approche:
tu prends tjs t/abs(t) pour le signe
problème en 0 donc tu prends un offset
f(t)=(t+epsilone) / (abs(t) + epsilone)
qui vaut bien 1 quand t vaut 0 ou plus et qui ne divise pas par zéro
c'est également pas mal pour t très grand devant epsilone.

Il reste le problème de t de l'ordre de grandeur de epsilone.
L'erreur maximal commise c'est donc quand t==epsilone ou -epsilone.
si t vaut epsilone, alors c'est bon. Donc il faut gérer -epsilone.
et f(-epsilone) = 0
f(-2 epsilone) = -1.3
f(-3 epsilone) = -1/2
donc tu peux par exemple soustraire epsilone...
du coup f(-epsilone) vaudra -epsilone, les valeurs inférieures à -epsilone donne
ront f négative, et f(0) vaudra 1-epsilone qui reste positive!

autrement dit g(t)=f(t) - epsilone
puis après t'as plus qu'à scaler avec arctan pour avoir ta fonction
h(t)=arctan(g(t))

par **Le Chat** » 15 Sep 2014, 00:03

fatal_error a écrit:tu peux par ex utiliser cette approche:
tu prends tjs t/abs(t) pour le signe
problème en 0 donc tu prends un offset
f(t)=(t+epsilone) / (abs(t) + epsilone)
qui vaut bien 1 quand t vaut 0 ou plus et qui ne divise pas par zéro
c'est également pas mal pour t très grand devant epsilone.

Il reste le problème de t de l'ordre de grandeur de epsilone.
L'erreur maximal commise c'est donc quand t==epsilone ou -epsilone.
si t vaut epsilone, alors c'est bon. Donc il faut gérer -epsilone.
et f(-epsilone) = 0
f(-2 epsilone) = -1.3
f(-3 epsilone) = -1/2
donc tu peux par exemple soustraire epsilone...
du coup f(-epsilone) vaudra -epsilone, les valeurs inférieures à -epsilone donne
ront f négative, et f(0) vaudra 1-epsilone qui reste positive!

autrement dit g(t)=f(t) - epsilone
puis après t'as plus qu'à scaler avec arctan pour avoir ta fonction
h(t)=arctan(g(t))

très astucieux, du moins pour moi en ce moment pcq j'ai pas mangé depuis ce matin.
Quoi que, je viens de trouver plus simple encore.

On utilise 0^t comme toujours, mais on remplace t avec une fonction «(min x y)»
Oui, je viens de remarquer que la fonction min est permise. :ptdr:

je posterai les 2 résultats dans quelques jours...lorsque cela sera sécuritaire

par **fatal_error** » 15 Sep 2014, 00:17

ui avec min ca marche aussi
min(t, epsilone)*2
si t >= epsilone => epsilone
si t < epsilone => t donc offset si t vaut 0
si t = -epsilone => -epsilone*2
on peut prendre
f(t) = min(t, epsilone)*2 + epsilone
qui devrait donc suffire

par **Le Chat** » 15 Sep 2014, 00:18

fatal_error a écrit:Donc il faut gérer -epsilone.
et f(-epsilone) = 0

Jusqu'ici, ça va.

fatal_error a écrit:f(-2 epsilone) = -1.3
f(-3 epsilone) = -1/2
donc tu peux par exemple soustraire epsilone...
du coup f(-epsilone) vaudra -epsilone, les valeurs inférieures à -epsilone donne
ront f négative, et f(0) vaudra 1-epsilone qui reste positive!

autrement dit g(t)=f(t) - epsilone
puis après t'as plus qu'à scaler avec arctan pour avoir ta fonction
h(t)=arctan(g(t))

Là, je ne suis plus, et puis après, h(t)=arctan(g(t)) donnera des valeurs 0 tout aussi réparties que les valeurs de g(t), non?

h(t)=arctan(g(t)) n'est utile que lorsqu'il y a convergence comme tu l'as mentionné dans un précédent message.

PS: tu n'aimes pas le 0^t? :lol3:

par **fatal_error** » 15 Sep 2014, 00:27

ouais mais la différence avec arctan c'est qu'au lieu de prendre arctan(g(t)) vu que tu sais que g(t) prendra jamais la valeur 0 mais une valeur positive en 0, tu peux scaler genre
arctan(g(t)*infty))
qui te donne respectivement -pi/2 ou pi/2 et que t'as qu'à ramener à -1 ou 1...

(j'ai pas précisé que fallait multiplier par l'infini, j'ai oublié)

par rapport à 0^t, t'as toujours pas dit comment tu t'en servais, et je vois pas trop comment m'en servir
je sais même pas ce que ca vaut 0^0 :)

Fonction

Fonction

Qui est en ligne