utiliser une DLL écrite en Delphi

ou Currency ?

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

Jean-Marc wrote:

"ng" <ng@ngsoft-fr.com> a écrit dans le message de
news:e7A9Pk1yEHA.2692@TK2MSFTNGP10.phx.gbl...

Salut,

Je ne connais pas Delphi, a quoi correspond exactement le type
extended (si c'est un type) ?

Sinon si c'est du variant, j'aurais plutot fais ca :

Private Declare Sub TerreRef Lib "terredll.dll" (ByRef jd as
variant, ByVal x0 as variant, ByVal y0 as variant, ByVal z0 as
variant, ByVal vx0 as variant, ByVal vy0 as variant, ByVal vz0 As
Variant)

Extended est un type de données, c'est un genre de super Double de
la mort, codé sur 10 octets (rien que ça...) et qui peut
prendre des valeurs assez intéressantes: de -3.4 * 10^4932 à +
1.1 * 10^4932 si j'ai bien compris. Sais pas trop dans quoi
mapper ça en fait. Je suppose que le mieux c'est dans un double VB,
mais suis pas sur que ça colle cette affaire là...

Bonjour,

Sans vouloir trop polémiquer le VB n'est pas aussi bien que Delphi pour
les applications scientifiques.

Si je me trompe pas votre &appli fait des calculs astronomiques (sans
jeu de mot), pour certaine transfo notemment utilisant des angles la
précision (ou le nombre de décimales significatives) est plus
qu'importante et 8 digit après la virgule c'est à peine suffisant dans
bien des cas.

A ce sujet je cherche un lien ou des explications pour démontrer à mes
employeurs, que le nombre de chiffres après la virgule n'est pas le
nombre de digit significatifs.

Christophe

jdd deschamps a écrit :

J'ai récupéré une DLL dont j'ai la source. Il y est écrit :

procedure TerreRef(jd:extended;var x0,y0,z0,vx0,vy0,vz0:extended); stdcall;

J'ai mis la DLL dans le répertoire de mon projet, et j'écris en VB :

Private Declare Sub TerreRef Lib "terredll.dll" _
(ByRef jd as variant, ByVal x0, y0, z0, vx0, vy0, vz0 As Variant)

puis dans le code : Call TerreRef(jd,...)

Cela vous paraît-il correct ?
Le logiciel plante avec arrêt de VB :
AppName: vb5.exe AppVer: 5.0.37.24 ModName: terredll.dll
ModVer: 0.0.0.0 Offset: 0008e73f

Je ne sais pas si c'est la DLL ou ma déclaration qui fait planter.

christophe-pasde<> @wanadoo.fr>" < wrote:

Sans vouloir trop polémiquer le VB n'est pas aussi bien que Delphi
pour les applications scientifiques.

Ce n'est pas de la polémique. C'est la réalité. Je n'aurais pas a priori
le réflexe, sauf contrainte particulière, d'utiliser VB6 pour une appli
scientifique fortement demandeuse de calculs. Delphi, C, C++,
Fortran,... Quoique le problème est plutôt au niveau des types que des
performances. Quand on fait des calculs, la runtime VB est tout de suite
très proche de la CPU et l'impact de cette couche intermédiaire reste
souvent très relatif. Par exemple, un benchmark comparant VB6 et VB .Net
sur un calcul de nombre premiers montre des écarts très faibles
(attention, je ne suis pas en train de dire que VB .Net a les mêmes
performances que VB6 - ce serait tout à fait ridicule).

--
Patrick Philippot - Microsoft MVP
MainSoft Consulting Services
www.mainsoft.fr

Oui quand on a la chance de connaitre plusieurs langages,

Pour moi qui programme en amateur dans un cadre professionel (si ça
existe), j'ai fait avec ce que j'avais ...

Pour la deuxième partie de ma question,
une idée ?
je précise : je cherche à connaitre la précision d'un calcul utilisant
un type virgule flottante sur 32 bits et fournissant un résultat dans le
même type.
et ceci qq soit le langage C++, VB, Delphi.

Christophe


Patrick Philippot a écrit :

christophe-pasde<> @wanadoo.fr>" < wrote:

Sans vouloir trop polémiquer le VB n'est pas aussi bien que Delphi
pour les applications scientifiques.

Ce n'est pas de la polémique. C'est la réalité. Je n'aurais pas a priori
le réflexe, sauf contrainte particulière, d'utiliser VB6 pour une appli
scientifique fortement demandeuse de calculs. Delphi, C, C++,
Fortran,... Quoique le problème est plutôt au niveau des types que des
performances. Quand on fait des calculs, la runtime VB est tout de suite
très proche de la CPU et l'impact de cette couche intermédiaire reste
souvent très relatif. Par exemple, un benchmark comparant VB6 et VB .Net
sur un calcul de nombre premiers montre des écarts très faibles
(attention, je ne suis pas en train de dire que VB .Net a les mêmes
performances que VB6 - ce serait tout à fait ridicule).

christophe-pasde<> @wanadoo.fr>" < wrote:

Oui quand on a la chance de connaitre plusieurs langages,

Pour moi qui programme en amateur dans un cadre professionel (si ça
existe), j'ai fait avec ce que j'avais ...

Oui, j'ai souvent en cours des gens dans votre situation. Ce n'est pas
une critique. Mais si on vous demande d'écrire un tel logiciel, il
serait bon que l'on vous donne les moyens de le faire avec les bons
outils.

A ce sujet je cherche un lien ou des explications pour démontrer à mes
employeurs, que le nombre de chiffres après la virgule n'est pas le
nombre de digit significatifs.

Cela a besoin d'être démontré? :-)

http://www.cs.utah.edu/%7Ezachary/isp/applets/FP/FP.html
http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/overview/reals.html
http://www.delorie.com/gnu/docs/glibc/libc_195.html

Google devrait vous aider à trouver d'autres pages similaires.

--
Patrick Philippot - Microsoft MVP
MainSoft Consulting Services
www.mainsoft.fr

Sans vouloir être exhaustif sur la question mais plutôt car ma formation de
prof maths et d'enseignant d'informatique il y a plus de 20 ans m'ont amené
à me poser ce genre de question je peux essayer de répondre.
Tous d'abord le nombre de chiffres significatifs dépend de la base dans
laquelle on calcule, en général en base 10. Le plus souvent dans le domaine
scientifique, le dernier chiffre n'est pas significatif, au sens où il ne
correspond pas nécessairement au chiffre de l'écriture du nombre.
Ainsi 2/3 s'écrit 0,66666.... les points de suspension indiquent que le
chiffre 6 est répété à l'infini. Mais dans un calculateur on ne dispose pas
d'un nombre infini de chiffres, donc il faut adopter une méthode d'écriture
(supposons que nous ne disposions que de trois chiffres). Soit on écrit
0,666 avec trois chiffres siginificatifs, c'est à dire que les chiffres
affichés sont bien ceux de l'écriture décimale, soit on écrit 0,667 car ce
nombre est plus proche de 2/3 que le précédent (arrondi à la troisième
décimale), mais alors le 7 n'est pas significatif car il ne figure pas dans
l'écriture de 2/3. Seuls les deux premiers sont significatifs.
En fait une écriture d'un nombre décimal représente en réalité un intervalle
de réels et il n'existe pas d'arithmétqiue ayant les mêmes bonnes propriétés
que l'arithmétique habituelle pour les intervalles. Donc 0,666 dans le
premier cas représente n'importe quel nombre compris entre 0,666 et 0,667
(cette valeur étant exclue)
Pour le deuxième cas 0,666 représentera n'importe quel nombre entre 0,6655
(borne inclue) et 0,6665 (borne exclue).
Pour cette raison les calculatrices modernes utilisent des "chiffres caché",
c'est à dire que le calcul se fait sur (en général) trois chiffres de plus
que ceux qui ont affichés, ce qui permet d'améliorer la précision des
calculs. En effet comme le nombre représente un intervalle, cela signifie
qu'il y a une imprécision sur celui-ci, imprécision qui va s'accroitre au
fur et à mesure des multiplications et divisions successives. En diminuant
l'erreur dans l'écriture, on diminue l'erreur finale.
Ainsi avec notre écriture sur trois chiffres après la virgule, supposons que
l'on ajoute un chiffre caché et que de plus on travaille en arrondi (comme
c'est le cas maintennat sur tous les calculateurs)
1/3 s'écrit 0,333(3) en interne et 0,333 à l'affichage.
Si on multiplie par 3, on obtient avec la méthode précédente (sans chiffre
caché) 0,999, avec la méthode du chiffre caché 0,999(9) en interne et donc
1,000 en affichage.
Pour ce qui concerne les digits, on va supposer qu'il s'agit des bits et
donc d'une écriture en base 2 d'un nombre flottant. Il faut donc connaître
exactement la transformation sur le nombre de bits utilisés permettant
l'écriture (en interne) du nombre considéré, et bien entendu la méthode
inverse. Par exemple
2/3 = 1/2 + 1/8 + 1/32 + 1/128 + ...
On ajoute toutes les puissances négatives et impaires de 2.
Ce qui donnerait (attention ce n'est pas vraiment cela, car il y a aussi la
notion de mantisse et d'exposant ...) 0,10101010...
Sur trois digits réécrits en décimal cela donne 0,101 soit 0,625, on voit
que l'on est un peu loin de 0,667.
J'espère avoir pu éclairer certains aspects de l'écriture des nombres en
informatique, vaste et délicat sujet.
Je termine par une annecdocte : il y plusieurs années, en utilisant une
calculatrice programmable et le calcul d'une série de nombre dont la valeur
s'approchait de plus en plus de PI, j'avais montré aux élèves que PI=0 car
au bout d'un certain temps c'est cette dernière valeur qui revenait
constamment. C'était un problème d'arrondi qui faisait qu'une valeur
positive mais trop petite pour se coder dans la machine prenait la valeur 0.







"Patrick Philippot" <patrick.philippot@mainsoft.xx.fr> a écrit dans le
message de news: uEB9rVJzEHA.748@TK2MSFTNGP14.phx.gbl...

christophe-pasde<> @wanadoo.fr>" < wrote:

Oui quand on a la chance de connaitre plusieurs langages,

Pou .r moi qui programme en amateur dans un cadre professionel (si ça
existe), j'ai fait avec ce que j'avais ...

Oui, j'ai souvent en cours des gens dans votre situation. Ce n'est pas une
critique. Mais si on vous demande d'écrire un tel logiciel, il serait bon
que l'on vous donne les moyens de le faire avec les bons outils.

A ce sujet je cherche un lien ou des explications pour démontrer à mes
employeurs, que le nombre de chiffres après la virgule n'est pas le
nombre de digit significatifs.

Cela a besoin d'être démontré? :-)

http://www.cs.utah.edu/%7Ezachary/isp/applets/FP/FP.html
http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/overview/reals.html
http://www.delorie.com/gnu/docs/glibc/libc_195.html

Google devrait vous aider à trouver d'autres pages similaires.

--
Patrick Philippot - Microsoft MVP
MainSoft Consulting Services
www.mainsoft.fr

Salut,

Que faites vous du pseudo-type Decimal de VB ? (je dis pseudo car il n'est
pas accessible directement).

<quote src="MSDN">

Type de données stockant des nombres décimaux avec un décalage exprimé en
puissance de 10. Pour les nombres à décalage nul, c'est-à-dire qui ne
comportent pas de décimales, la plage de valeurs est +/-79 228 162 514 264
337 593 543 950 335. Pour les nombres à 28 décimales, la plage est
+/-7,9228162514264337593543950335. Le plus petit nombre différent de zéro
pouvant être représenté dans le type Decimal est
0,0000000000000000000000000001.

</quote>

--
Nicolas G.
FAQ VB : http://faq.vb.free.fr
API Guide : http://www.allapi.net
Google Groups : http://groups.google.fr/
MZ-Tools : http://www.mztools.com/

christophe-pasde<> @wanadoo.fr>" < wrote:

Bonjour,

Sans vouloir trop polémiquer le VB n'est pas aussi bien que Delphi
pour les applications scientifiques.

Si je me trompe pas votre &appli fait des calculs astronomiques (sans
jeu de mot), pour certaine transfo notemment utilisant des angles la
précision (ou le nombre de décimales significatives) est plus
qu'importante et 8 digit après la virgule c'est à peine suffisant dans
bien des cas.

A ce sujet je cherche un lien ou des explications pour démontrer à mes
employeurs, que le nombre de chiffres après la virgule n'est pas le
nombre de digit significatifs.

Christophe

jdd deschamps a écrit :

J'ai récupéré une DLL dont j'ai la source. Il y est écrit :

procedure TerreRef(jd:extended;var x0,y0,z0,vx0,vy0,vz0:extended);
stdcall; J'ai mis la DLL dans le répertoire de mon projet, et j'écris en
VB :

Private Declare Sub TerreRef Lib "terredll.dll" _
(ByRef jd as variant, ByVal x0, y0, z0, vx0, vy0, vz0 As Variant)

puis dans le code : Call TerreRef(jd,...)

Cela vous paraît-il correct ?
Le logiciel plante avec arrêt de VB :
AppName: vb5.exe AppVer: 5.0.37.24 ModName: terredll.dll
ModVer: 0.0.0.0 Offset: 0008e73f

Je ne sais pas si c'est la DLL ou ma déclaration qui fait planter.

merci à tous deux

Christophe

Patrice Henrio a écrit :

Sans vouloir être exhaustif sur la question mais plutôt car ma formation de
prof maths et d'enseignant d'informatique il y a plus de 20 ans m'ont amené
à me poser ce genre de question je peux essayer de répondre.
Tous d'abord le nombre de chiffres significatifs dépend de la base dans
laquelle on calcule, en général en base 10. Le plus souvent dans le domaine
scientifique, le dernier chiffre n'est pas significatif, au sens où il ne
correspond pas nécessairement au chiffre de l'écriture du nombre.
Ainsi 2/3 s'écrit 0,66666.... les points de suspension indiquent que le
chiffre 6 est répété à l'infini. Mais dans un calculateur on ne dispose pas
d'un nombre infini de chiffres, donc il faut adopter une méthode d'écriture
(supposons que nous ne disposions que de trois chiffres). Soit on écrit
0,666 avec trois chiffres siginificatifs, c'est à dire que les chiffres
affichés sont bien ceux de l'écriture décimale, soit on écrit 0,667 car ce
nombre est plus proche de 2/3 que le précédent (arrondi à la troisième
décimale), mais alors le 7 n'est pas significatif car il ne figure pas dans
l'écriture de 2/3. Seuls les deux premiers sont significatifs.
En fait une écriture d'un nombre décimal représente en réalité un intervalle
de réels et il n'existe pas d'arithmétqiue ayant les mêmes bonnes propriétés
que l'arithmétique habituelle pour les intervalles. Donc 0,666 dans le
premier cas représente n'importe quel nombre compris entre 0,666 et 0,667
(cette valeur étant exclue)
Pour le deuxième cas 0,666 représentera n'importe quel nombre entre 0,6655
(borne inclue) et 0,6665 (borne exclue).
Pour cette raison les calculatrices modernes utilisent des "chiffres caché",
c'est à dire que le calcul se fait sur (en général) trois chiffres de plus
que ceux qui ont affichés, ce qui permet d'améliorer la précision des
calculs. En effet comme le nombre représente un intervalle, cela signifie
qu'il y a une imprécision sur celui-ci, imprécision qui va s'accroitre au
fur et à mesure des multiplications et divisions successives. En diminuant
l'erreur dans l'écriture, on diminue l'erreur finale.
Ainsi avec notre écriture sur trois chiffres après la virgule, supposons que
l'on ajoute un chiffre caché et que de plus on travaille en arrondi (comme
c'est le cas maintennat sur tous les calculateurs)
1/3 s'écrit 0,333(3) en interne et 0,333 à l'affichage.
Si on multiplie par 3, on obtient avec la méthode précédente (sans chiffre
caché) 0,999, avec la méthode du chiffre caché 0,999(9) en interne et donc
1,000 en affichage.
Pour ce qui concerne les digits, on va supposer qu'il s'agit des bits et
donc d'une écriture en base 2 d'un nombre flottant. Il faut donc connaître
exactement la transformation sur le nombre de bits utilisés permettant
l'écriture (en interne) du nombre considéré, et bien entendu la méthode
inverse. Par exemple
2/3 = 1/2 + 1/8 + 1/32 + 1/128 + ...
On ajoute toutes les puissances négatives et impaires de 2.
Ce qui donnerait (attention ce n'est pas vraiment cela, car il y a aussi la
notion de mantisse et d'exposant ...) 0,10101010...
Sur trois digits réécrits en décimal cela donne 0,101 soit 0,625, on voit
que l'on est un peu loin de 0,667.
J'espère avoir pu éclairer certains aspects de l'écriture des nombres en
informatique, vaste et délicat sujet.
Je termine par une annecdocte : il y plusieurs années, en utilisant une
calculatrice programmable et le calcul d'une série de nombre dont la valeur
s'approchait de plus en plus de PI, j'avais montré aux élèves que PI=0 car
au bout d'un certain temps c'est cette dernière valeur qui revenait
constamment. C'était un problème d'arrondi qui faisait qu'une valeur
positive mais trop petite pour se coder dans la machine prenait la valeur 0.







"Patrick Philippot" <patrick.philippot@mainsoft.xx.fr> a écrit dans le
message de news: uEB9rVJzEHA.748@TK2MSFTNGP14.phx.gbl...

christophe-pasde<> @wanadoo.fr>" < wrote:

Oui quand on a la chance de connaitre plusieurs langages,

Pou .r moi qui programme en amateur dans un cadre professionel (si ça
existe), j'ai fait avec ce que j'avais ...

Oui, j'ai souvent en cours des gens dans votre situation. Ce n'est pas une
critique. Mais si on vous demande d'écrire un tel logiciel, il serait bon
que l'on vous donne les moyens de le faire avec les bons outils.

A ce sujet je cherche un lien ou des explications pour démontrer à mes
employeurs, que le nombre de chiffres après la virgule n'est pas le
nombre de digit significatifs.

Cela a besoin d'être démontré? :-)

http://www.cs.utah.edu/%7Ezachary/isp/applets/FP/FP.html
http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/overview/reals.html
http://www.delorie.com/gnu/docs/glibc/libc_195.html

Google devrait vous aider à trouver d'autres pages similaires.

--
Patrick Philippot - Microsoft MVP
MainSoft Consulting Services
www.mainsoft.fr

ng wrote:

Que faites vous du pseudo-type Decimal de VB ?

Bonjour,

A priori, ça ne résout pas le pb qui est la compatibilité avec le type
extended de Delphi.

--
Patrick Philippot - Microsoft MVP
MainSoft Consulting Services
www.mainsoft.fr

Bonjour voici la réponse d'un spécialiste delphi
Michel Martin. Je vous la transmet

Christophe


voici la page d'aide sur les types réels de Delphi:

{
Un type réel définit un ensemble de nombres pouvant être représentés par
une notation à virgule flottante. Le tableau suivant donne l'étendue et
le format de stockage des types réels fondamentaux.

Type, Etendue, Chiffres significatifs, Taille en octets
Single, 1.5 x 10^–45 .. 3.4 x 10^38, 7–8, 4
Double, 5.0 x 10^–324 .. 1.7 x 10^308, 15–16, 8
Extended, 3.6 x 10^–4951 .. 1.1 x 10^4932, 19–20, 10
Currency, –922337203685477.5808.. 922337203685477.5807, 19–20, 8
Les remarques suivantes s'appliquent aux types réels fondamentaux.

Extended propose une meilleure précision que les autres types réels,
mais il est moins portable. Evitez d'utiliser Extended si vous créez des
fichiers de données qui doivent être partagés sur plusieurs plates-formes.
Currency est un type de données à virgule fixe qui limite les erreurs
d'arrondi dans les calculs monétaires. Il est stocké dans un entier sur
64 bits, les quatre chiffres les moins significatifs représentant
implicitement les chiffres après la virgule. Quand il est combiné avec
d'autres types réels dans des affectations et des expressions, les
valeurs Currency sont automatiquement divisées ou multipliées par 10000.}

Voici ensuite la page d'aide sur les conventions d'appel:

{Dans la déclaration d'une procédure ou d'une fonction, vous pouvez
spécifier une convention d'appel en utilisant l'une des directives
register, pascal, cdecl, stdcall et safecall. Par exemple :

function MaFonction(X, Y: Real): Real; cdecl;

...

Les conventions d'appel déterminent l'ordre dans lequel les paramètres
sont transmis à la routine. Elles affectent également la suppression des
paramètres de la pile, l'utilisation de registres, la transmission des
paramètres et la gestion des erreurs et des exceptions. register est la
convention d'appel par défaut.

Les conventions register et pascal transmettent les paramètres de gauche
à droite ; c'est-à-dire que le paramètre de gauche est évalué et
transmis en premier, le paramètre de droite est évalué et transmis en
dernier. Les conventions cdecl, stdcall et safecall transmettent les
paramètres de droite à gauche.
Pour toutes les conventions sauf cdecl, les procédures et fonctions
suppriment les paramètres de la pile lors de la sortie. Avec la
convention cdecl, c'est à l'appelant de supprimer les paramètres de la
pile au retour de l'appel.

La convention register utilise jusqu'à trois registres de la CPU pour
transmettre des paramètres alors que toutes les autres conventions
transmettent tous les paramètres dans la pile.
La convention safecall implémente la gestion d'erreur et d'exception COM.

Le tableau suivant résume les caractéristiques des conventions d'appel.

Directive, Ordre des paramètres, Nettoyage, Transfert de paramètre dans
les registres?
register, De gauche à droite, Routine, Oui
pascal, De gauche à droite, Routine, Non
cdecl, De droite à gauche, Appelant, Non
stdcall, De droite à gauche, Routine, Non
safecall, De droite à gauche, Routine, Non
La convention d'appel par défaut register est la plus efficace car elle
évite la création d'un cadre de pile. (Les méthodes d'accès aux
propriétés publiées doivent utiliser register.) La convention cdecl est
utile pour les appels de fonction dans des DLL écrites en C ou en C++,
alors que stdcall et safecall s'utilisent pour des appels de l'API
Windows. La convention safecall doit être utilisée pour déclarer des
méthodes d'interface dual . La convention pascal est conservée dans un
souci de compatibilité ascendante. Pour davantage d'informations sur les
conventions d'appel, voir Contrôle du programme.
}



jdd deschamps a écrit :

J'ai récupéré une DLL dont j'ai la source. Il y est écrit :

procedure TerreRef(jd:extended;var x0,y0,z0,vx0,vy0,vz0:extended); stdcall;

J'ai mis la DLL dans le répertoire de mon projet, et j'écris en VB :

Private Declare Sub TerreRef Lib "terredll.dll" _
(ByRef jd as variant, ByVal x0, y0, z0, vx0, vy0, vz0 As Variant)

puis dans le code : Call TerreRef(jd,...)

Cela vous paraît-il correct ?
Le logiciel plante avec arrêt de VB :
AppName: vb5.exe AppVer: 5.0.37.24 ModName: terredll.dll
ModVer: 0.0.0.0 Offset: 0008e73f

Je ne sais pas si c'est la DLL ou ma déclaration qui fait planter.