Discussion :

[wiwaxia]

Ta remarque ci-dessous, ainsi que la mystérieuse courbe aux circonvolutions minimales que l'on retrouve sur chacune de tes images, conduisent à penser que tu as envisagé (ou demandé par l'appel d'une procédure appropriée) le tracé de la courbe de Bézier d'ordre maximal (n), déduite des (n + 1) points présents.

... Le seul hic au delà de 35 points de contrôle ma courbe ne s'affiche pas. J'ai l'impression que je doit dépasser les limites des virgules flottantes ou c'est la fonction Math.power / BZMath.pow qui atteigne leurs limites. Ou bien autre chose, je vais approfondir ...

Dans le cas d'une programmation basique, il ne faut pas calculer séparément les termes figurant dans les monômes de Bernstein, parce qu'ils peuvent prendre des valeurs franchement démesurées

35! = 10333147966386144929666651337523200000000 ~1.0E40
C(17, 35) = 4537567650

mais déduire la valeur de chaque monôme de celle de son prédécesseur par une relation de récurrence:

B_k+1ⁿ(x) / B_kⁿ(x) = [(n - k)/(k + 1)]*[t/(1 - t)]

afin de consigner les (n + 1) résultats dans un tableau de réels, qui présentent des ordres de grandeur raisonnables.
On passera ensuite seulement au calcul de la combinaison linéaire définissant la courbe à tracer.

On évitera ainsi les pièges liés à la limitation éventuelle des grands nombres, et à la précision limitée des calculs.
Il va de soi qu'interviennent les flottants de précision maximale, au format LongInt.

La difficulté permanente des échanges actuels vient de ce que tes programmes font appel à des procédures et des fonctions vraiment spécialisées, qui sont autant de boîtes noires pour les non-initiés (dont je fais partie); de sorte que tes explications sont invérifiables, et qu'il n'est pas possible de localiser l'instruction éventuellement défectueuse compromettant la bonne exécution du programme.
Les seules références claires (et d'ailleurs fort intéressantes) concernaient l'utilisation des courbes de Bézier les plus simples, d'ordre 3.

Et puisqu'il a été question de la procédure (ou fonction) Math.power / BZMath.pow , sais-tu exactement ce qu'elle calcule, comment elle le fait et surtout dans quelles limites ? Il n'y a aucune ironie dans cette question. Malgré l'a-priori favorable que l'on peut accorder à Free Pascal & apparentés, les réponses pourraient se révéler intéressantes.

[wiwaxia]

... Il va de soi qu'interviennent les flottants de précision maximale, au format LongInt ...

Ce lapsus m'a échappé; il s'agit bien sûr du format Extended.

[BeanzMaster]

Bonjour,

Ta remarque ci-dessous, ainsi que la mystérieuse courbe aux circonvolutions minimales que l'on retrouve sur chacune de tes images, conduisent à penser que tu as envisagé (ou demandé par l'appel d'une procédure appropriée) le tracé de la courbe de Bézier d'ordre maximal (n), déduite des (n + 1) points présents.

Dans le cas d'une programmation basique, il ne faut pas calculer séparément les termes figurant dans les monômes de Bernstein, parce qu'ils peuvent prendre des valeurs franchement démesurées

35! = 10333147966386144929666651337523200000000 ~1.0E40
C(17, 35) = 4537567650

mais déduire la valeur de chaque monôme de celle de son prédécesseur par une relation de récurrence:

B_k+1ⁿ(x) / B_kⁿ(x) = [(n - k)/(k + 1)]*[t/(1 - t)]

afin de consigner les (n + 1) résultats dans un tableau de réels, qui présentent des ordres de grandeur raisonnables.
On passera ensuite seulement au calcul de la combinaison linéaire définissant la courbe à tracer.

On évitera ainsi les pièges liés à la limitation éventuelle des grands nombres, et à la précision limitée des calculs.
Il va de soi qu'interviennent les flottants de précision maximale, au format LongInt.

Je vais regardé cette solution, pour le moment je m'en suis sortie avec ce qui a été dit précédemment

La difficulté permanente des échanges actuels vient de ce que tes programmes font appel à des procédures et des fonctions vraiment spécialisées, qui sont autant de boîtes noires pour les non-initiés (dont je fais partie); de sorte que tes explications sont invérifiables, et qu'il n'est pas possible de localiser l'instruction éventuellement défectueuse compromettant la bonne exécution du programme.
Les seules références claires (et d'ailleurs fort intéressantes) concernaient l'utilisation des courbes de Bézier les plus simples, d'ordre 3.

En fait tous les codes utilisés sont dans cette discussion, le problème à mon sens c'est que c'est très orienté objet d'ou la difficulté de comprendre par bout de code. Ce code englobe une assez grosse bibliothèque graphique que je développe BZScene

et ici le code de l'exemple (encore un peu fouillis) des captures d'ecran fournis ici

Voici par exemple mon unité BZGeoTools qui regroupe des objets pour manipuler des primitives géométrique (ligne, cercle, polygone, courbes...) dont je donne la référence ici

Et puisqu'il a été question de la procédure (ou fonction) Math.power / BZMath.pow , sais-tu exactement ce qu'elle calcule, comment elle le fait et surtout dans quelles limites ? Il n'y a aucune ironie dans cette question. Malgré l'a-priori favorable que l'on peut accorder à Free Pascal & apparentés, les réponses pourraient se révéler intéressantes.

Concernant ces deux fonctions "Math.Power" est la fonction de base de FreePascal :

Code Pascal :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
function Math.power(base,exponent : float) : float;
  begin
    if Exponent=0.0 then
      result:=1.0
    else if (base=0.0) and (exponent>0.0) then
      result:=0.0
    else if (abs(exponent)<=maxint) and (frac(exponent)=0.0) then
      result:=intpower(base,trunc(exponent))
    else
      result:=exp(exponent * ln (base));
  end; 
 
function intpower(base : float;const exponent : Integer) : float;
  var
     i : longint;
  begin
     if (base = 0.0) and (exponent = 0) then
       result:=1
     else
       begin
         if exponent<0 then
           base:=1.0/base;
         i:=abs(exponent);
         intpower:=1.0;
         while i>0 do
           begin
              while (i and 1)=0 do
                begin
                   i:=i shr 1;
                   base:=sqr(base);
                end;
              i:=i-1;
              intpower:=intpower*base;
           end;
       end;
  end;

et la mienne dans BZMath (pas grande différence, un poil plus rapide )

Code Pascal :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
function BZMath.Pow(const Base, Exponent : Single) : Single;
begin
    {$HINTS OFF}
    if exponent=cZero then Result:=cOne
    else if (base=cZero) and (exponent>cZero) then Result:=cZero
    else if RoundFloat(exponent)=exponent then Result := Math.IntPower(base, Integer(Round(exponent)))
    else Result:=Exp(exponent*Ln(base));
    {$HINTS ON}   
end;

Merci

A (Très) bientôt (j'ai un autre soucis, dans un autre domaine)

Jérôme

[Guesset]

Bonjour Jérôme,

...

Code Pascal :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
function Math.power(base,exponent : float) : float;
  begin
    if Exponent=0.0 then
      result:=1.0
    else if (base=0.0) and (exponent>0.0) then
      result:=0.0
    else if (abs(exponent)<=maxint) and (frac(exponent)=0.0) then
      result:=intpower(base,trunc(exponent))
    else
      result:=exp(exponent * ln (base));
  end;

Il y a un truc qui me gène dans ce code (et le tiens). Si la base = 0, ne faudrait il pas d'emblée traiter les puissances négatives (division par 0) ?

Salut

[BeanzMaster]

Bonjour Jérôme,

Il y a un truc qui me gène dans ce code (et le tiens). Si la base = 0, ne faudrait il pas d'emblée traiter les puissances négatives (division par 0) ?

Salut

Salut, oui effectivement, cela peut poser un problème dans la fonction IntPower. Je me demande comment est codé Power dans Delphi ou autre langage ? Je n'avais jamais fait attention.

A+

[wiwaxia]

Pour l'exponentiation, un code relativement simple permet d'éviter le plantage accidentel du programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 FUNCTION XpuissY(x, y: Reel): Reel;
   VAR z: Reel;
   BEGIN
     IF (x=0) THEN z:= 0
              ELSE z:= Power(Abs(x), y);
     Result:= z
   END;

Maintenant lorsqu'un calcul est susceptible de conduire à des nombres anormalement petits ou grands - c'est le cas des monômes de Bernstein d'ordre quelconque - il convient de s'en tenir prudemment à l'évaluation du logarithme afin de savoir à quoi on s'engage, et d'avoir une conscience claire des limitations propres à chaque type de flottant:

J'ai regardé quelles étaient les valeurs du logarithme décimal - pour diverses valeurs de la variable (z) - des termes d'ordre 50 B_k⁵⁰(z):

Les valeurs des termes les plus petits (10^-150) demeurent accessibles au calcul.
Ont été affichés en blanc les résultats dépassant 10^-20, compte tenu des maximums observés (~0.1 à 1) et de la précision permise en Pascal (2^-63 ~ 10^-19).
Remarquer la symétrie présentée par le tableau.

Les sommations requises par le tracé des courbes de Bézier doivent être effectuées à partit des termes les plus petits, afin de limiter les erreurs liées au cumul d'arrondi; donc:
- à (k) décroissant lorsque (z) est inférieur à 0.5 ,
- à (k) croissant dans le cas contraire.

[Guesset]

Bonjour wiwaxia,

Pour l'exponentiation, un code relativement simple permet d'éviter le plantage accidentel du programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 FUNCTION XpuissY(x, y: Reel): Reel;
   VAR z: Reel;
   BEGIN
     IF (x=0) THEN z:= 0
              ELSE z:= Power(Abs(x), y);
     Result:= z
   END;

Ce code évite certainement des plantages mais il ne renvoie pas réellement l'exponentiation si x < 0 (où x^y a de bonnes chances de pas être un réel) et si x et y = 0 (NaN ?). Peut être qu'une propagation d'erreur ou au moins des assertions seraient plus saines. Le camouflage d'erreur ne les fait pas disparaître et rend le diagnostic hasardeux.

Par ailleurs, est-ce que nous sommes vraiment dans un cas où y n'est pas un entier positif ? Sinon l'algorithme d'exponentiation rapide (je crois dû à Dijkstra) est peut être intéressant même s'il se bat contre des instructions implémentées dans les CPU.

Salut

[Alex64]

A mon avis "mélanger" des cubique et des quadratiques peut causer problemes.
voir le chapitre "courbes de bezier spéciales" dans le Pdf joint :
Pièce jointe 611778