Arrondir un réel à deux chiffres après la virgule

En effet !!!!

Salut ygeronimi

Voici le lien de FBIDE de FREEBASIC

http://fbide.freebasic.net/download

A+

@ygeronimi

Pour la traduction, il n’y a pas de problème puisque tu peux utiliser FBIDE en Français.
Pour cela procèdes comme ceci.
Après avoir chargé FBIDE, installes-le dans ton répertoire préféré.
Ensuite, exécute FBIDE.EXE : il s’exécute en Anglais.
Cliques sur VIEWS, puis sur SETTINGS, SELECT YOUR LANGUAGE, choisis alors FRENCH puis OK.
Quittes FBIDE et relances-le : il t’indique un message d’erreur ‘file ",line 261 : ‘=’ expected’
Ignores ce message en cliquant sur OK : FBIDE est désormais en Français. Alors bonne programmation.

en voulant compiler avec Fbedit j'ai un message d'erreur


C:\FreeBASIC\fbc -s gui -dll -export "format.bas"
format.bas(10) error 114: Expected 'END EXTERN' in 'end function'

Build error(s)

Et avec Fbide :

Command executed:
"C:\FreeBasic\fbc.exe" "C:\Users\Yannick\Documents\Prog dll FBasic\format.bas"

Compiler output:
C:\Users\Yannick\Documents\Prog dll FBasic\format.bas(10) error 114: Expected 'END EXTERN' in 'end function'

Results:
Compilation failed

System:
FBIde: 0.4.6
fbc: FreeBASIC Compiler - Version 0.23.0 (08-14-2011) for win32 (target:win32)
OS: Windows NT 6.1 (build 7601, Service Pack 1)

Salut tout le monde.

J’ai compilé la DLL ‘FORMAT.BAS’ donnée par jean_debord.
Je l’ai testé et ça fonctionne : ça répond exactement à la demande, à savoir afficher la valeur sur la longueur et avec le nombre de décimales qu’on veut.

Voici le résultat de mon test

Code:

dim montant, format$, xstr$, result% ,i%
label formater

gosub formater
end

formater:
  dll_on "format.dll"
  for i% = 1 to 20
    montant = 100000*rnd(1000)
   
  format$ = "  *** 00000000.00000"
'  format$ = "00,000,000.00 $"
'  format$ = " 00 000 000.00 Dollars"
'  format$ = "00 000 000.00 E"
'  format$ = "00 000 000.00 EUROS"    : ' ----> Erreur dans l'affichage
'  Cette erreur est provoquée lorsque le texte commence par E ou par e
'  et comporte d'autres caractères.
'  Peut-être que le système considère qu'il s'agit de l'opérateur de
'  l'exponentiation.
    xstr$ = format$
    result% = dll_call3("print_format", adr(montant), adr(format$), adr(xstr$))
    print "montant = ";xstr$
  next i%

dll_off
return

On peut choisir le format de différentes manières sauf celui donné en ligne 16.

A+

perso j'arrive pas a la compiler cette P........ de dll , avec fbide ou fbedit j'ai droit à des erreurs

ygeronimi a écrit:

GRRRRRRR......c'est en mode console
.....enfin bref je ne sais pas comment ca marche....snif

As-tu chargé, entre autre, ‘start-shell.exe’ ? c'est en mode console.
Si oui, exécute-le : puis tapes ceci
fbc format.bas

Le source ‘format.bas’ doit être dans le même répertoire que celui où se trouve ‘start-shell.exe’.

CA Y EST , J Y SUIS ARRIVE !!!!!!!!!


Ben c 'est pas pour demain que je vais imiter Klaus et pondre des dll à la demande.......

OUFFF.......

F E L I C I T A T I O N S

Y G E R O N I M I

Comme je fais parti des

y a un truc qui me derange dans l'appelle de la dll.....

en principe si j'écrivai

Code:

print str$(result%)

là je devrai avoir le retour.... y a un truc de pas net la dessous......non?

Non ygeronimi, tu ne peux pas faire ‘ print str$(result%)’
Ça donne 0
Tu dois faire

Code:

print  xstr$

xstr$ étant le 3ème paramètre de l’appel de la DLL

Code:

result% = dll_call3("print_format", adr(montant), adr(format$), adr(xstr$))

Regardes mon test posté ci-haut.

L’appel de cette DLL se fait ainsi :

Code:

result% = dll_call3("print_format", adr(montant), adr(format$), adr(xstr$))

On transmet donc à la fonction "print_format" 3 paramètres par adresse qui sont, dans cet exemple ‘montant’,’format$’ et ‘xstr$’
Le nom de la fonction (print_format) doit-être rigoureusement identique à celui déclaré dans la DLL (ce nom est donc sensible à la casse).
Les 3 paramètres doivent-être déclarés avant l’appel de la DLL. Tu es libre de les nommer comme tu veux, à condition, bien sûr, de respecter leurs types.
Dans ce cas, le 1er paramètre (montant par exemple) est du type réel,
Le 2ème paramètre (format$) est du type string et le 3ème paramètre est également du type strings

Cet exemple est correct

Code:

dim m, f$, r%
m = 123456.0123456789 : ' la valeur à formater
f$ = "00000000.00000" : ' définir le format
dll_on "Format.dll"  : ' charger la DLL en mémoire
r% = dll_call3("print_format", adr(m), adr(f$), adr(f$)) : ' appeler la DLL
print f$  : ' Afficher la valeur de m formatée
dll_off  : ' libérer la mémoire utilisée par la DLL

A+

@Papydall :

Je ne conteste pas le fonctionnement , c'est comme çà , c'est comme çà et puis c'est tout.
Mais je trouve curieux

- de déclarer une variable r%
- avec un signe d'égalité qui signifie que cette variable est égal à ce qui la suit
- puis faire un appel de dll et afficher en résultat le troisième paramètre de cette dll.

exemple dans la dll dont je me sers pour les dates et qui me renvoie en fait la date en nombre depuis une date départ comme dans excell

j'initialise 3 variables pour le jour , le mois et l'année

soit pour exemple : a$ , b$ , c$

Code:

r% = dll_call3("NbreJours",a$,b$,c$)

print str$(r%) ' me renvoit le nombre de jours correspondant à la date

et là je trouve celà logique

je voulais juste souligner quelque chose que je trouvais curieux .


Bon... aller....je vais prendre ma dose de valium...c'est bon....

à moins que ....j'avais pas fait gaff à "adr" , c'est peut etre ce truc qui change quelque chose.....mais bon à quoi sert le "r%" si il n'est égal à rien....
aller ....ca coup ci, c'est double dose....

Bonjour ygeronimi,
le r% est une valeur de retour de la DLL. Elle t'indique juste si elle a réussi à faire ce que tu lui demande.
Cette valeur doit être obligatoirement un entier, donc on ne peut pas l'utiliser pour renvoyer un réel.
L'exemple fourni par jean te fais une conversion de ta valeur numerique en une chaine de caractère dans le format d'affichage que tu désires.

Code:

r% = dll_call3("print_format", adr(montant), adr(format$), adr(xstr$))

La fonction print_format te renverra toujours 0 (cf le return 0 dans le source de la DLL)

Concernant les ADR() : Comme ta DLL est un programme externe à Panoramic, on est obligé de passer l'emplacement en RAM où se situe les paramètres (l'adresse) pour que la DLL puisse les retrouver et les modifier...

Quand au passage de l'adresse du 1er paramètre, cela n'est pas nécessaire puisque c'est juste une valeur numérique que l'on passe et que l'on a pas l'intention de modifier son contenu...

Ce sont les limites actuelles de Panoramic qui nous imposent toutes ces acrobaties !

Panoramic est ainsi fait que :

1) les paramètres de la DLL doivent être des entiers, donc pour les réels et les chaînes de caractères on est obligés de passer leurs adresses ; il n'y a que les entiers qui peuvent passer directement

2) la valeur de retour de la fonction est obligatoirement une valeur entière. Donc lorsque le résultat du calcul est un entier on affecte sa valeur au résultat de la fonction (c'est le plus "naturel"). Lorsque le résultat est un réel ou (comme ici) une chaîne de caractères, on l'affecte à un paramètre de la fonction (ici le paramètre xstr$) et on donne une valeur entière quelconque un résultat, p. ex. un code d'erreur.

Mais il est certain que l'intégration de Panoramic avec FreeBASIC permettra à Jack de concevoir un système beaucoup plus souple, car FreeBASIC peut utiliser tous types de fonctions dans les DLL.

Bonjour Jean,
Je viens de faire le test avec le source de la DLL que tu as fourni.
peux-tu me dire pourquoi j'ai un message d'erreur à la ligne 15 ?

Code:

DLL_ON "format.dll"

DIM x, format$, chaine$, result%

x = 4 * atn(1)

print "Valeur numerique de départ :";x
chaine$=str$(x)
print "Valeur convertie en chaine :";chaine$
print "Valeur de la chaine        :";val(chaine$)

format$ = "0.00000" : chaine$ = format$      : ' pour dimensionner la chaine
result% = dll_call3("print_format", adr(x), adr(format$), adr(chaine$))
print "Resultat de la dll        :";chaine$
print "Valeur de la chaine        :";val(chaine$)

DLL_OFF

La chaine de retour est corrompue ?

EDIT: C'est bon j'ai trouvé ! le point décimal est transformé en virgule... d'où l'erreur...

Donc pour résumer ygeronimi, tu n'as que l'embarras du choix:

Code:

DIM x

' ---------------------------------------
' Par le calcul:
' ---------------------------------------
x = 4 * atn(1)
x = int((x+0.00005)*10000)/10000
print "Valeur du calcul :";x


' ---------------------------------------
' Par l'appel d'une DLL
' ---------------------------------------
x = 4 * atn(1)
DLL_ON "format.dll"
DIM format$, chaine$, result%
format$ = "0.0000" : chaine$ = format$      : ' pour dimensionner la chaine
result% = dll_call3("print_format", adr(x), adr(format$), adr(chaine$))
chaine$=LEFT$(chaine$,INSTR(chaine$,",")-1)+"."+RIGHT$(chaine$,LEN(chaine$)-INSTR(chaine$,","))
x=val(chaine$)
print "Valeur de la dll :";x
DLL_OFF

Merci à Tous ,

Grace à cette petite discussion , je suis un peu moins c...
ce matin et je comprends mieux l'histoire des dll.


Ps : C'est pas pour autant que je saurai en codé une demain

Salut tout le monde.

Si, pour la transmission des paramètres à une procédure ou fonction contenue dans une DLL, je récapitule un peu, je dirais ceci.
Le système permet de transmettre des valeurs de l’appelant (le programme) à la fonction/procédure appelée dans la DLL.
La fonction/procédure traitera ensuite les valeurs reçues. Cela augmente les possibilités de réemploi de cette fonction/procédure, chaque programme pouvant transmettre des valeurs propres à la fonction/procédure.
De même, au sein d’un seul programme les appels peuvent se multiplier, car ils se distinguent par la transmission de valeurs différentes.

Le système dépose sur la pile une copie de chaque paramètre transmis, la pile correspond à une certaine zone de la mémoire vive.
Une fois la routine exécutée, lors du retour au programme appelant le système éliminera les paramètres de la pile. Ces valeurs sont en fait des copies temporaires, les valeurs d’origines connues du programme appelant ne sont pas modifiées par l’exécution de la procédure.

Lorsque nous désirons qu’entre le programme appelant et la fonction/procédure appelée, la transmission des paramètres se réalise dans les deux sens, autrement dit que la fonction/procédure puisse elle aussi transmettre des informations au programme appelant, nous devons alors employer ce que l’on nomme la transmission de paramètres par adresse.
Au contraire de ce qui a été dit pour une transmission par valeur, le système ne dépose pas une copie du contenu sur la pile, il travaille directement en mémoire, sur la variable. Cela provient de ce que la procédure/fonction reçoit l’adresse mémoire à laquelle figure le contenu de la variable.

De ce fait, une procédure/fonction est en mesure de modifier la valeur d’une variable, et de transmettre au programme appelant cette valeur modifiée.
Seule différence, le mot réservé ADR précédera les paramètres.

J’espère que je n’ai pas écrits des bêtises !

j'ai écrit ceci :

Code:

dim x,format$,xstr$,result%

x=123123212/10000
format$="00.00000"
xstr$=format$
dll_on "format.dll"
result%=dll_call3("print_format",adr(x),adr(format$),adr(xstr$))
print xstr$
dll_off
x= val(xstr$)

Resultat : Erreur Not correct arithmetic....... line 10

alors je fais comment pour remettre le resultat ds une variable.....

Salut ygeronimi.

Je comprends pourquoi tu as une erreur à la ligne 10.
La variable XSTR$ contient "12312,32"
Il y a, à l’intérieur de cette chaîne une virgule décimal et non un point décimal !
Or PANORAMIC ne reconnait que le point décimal.
Donc, la variable XSTR$ ne contient pas une valeur numérique, d’où l’erreur.

Maintenant, comment faire pour remettre le résultat dans une variable ?
Ce n’est pas simple. Mais on peut y arriver, par exemple comme ceci

Code:

dim x,format$,xstr$,result% ,i%,tempo$

x=123123212/10000
format$ = "00000.00"
xstr$=format$
dll_on "format.dll"
result%=dll_call3("print_format",adr(x),adr(format$),adr(xstr$))
print "xstr$ = ";xstr$
dll_off

for i% = 1 to len(xstr$)
  if mid$(xstr$,i%,1) <> ","
    tempo$ = tempo$ +  mid$(xstr$,i%,1)
    else
    tempo$ = tempo$ + "."
  end_if
next i%
x = val(tempo$)
print "    x = " ; x

C’est un peu laborieux mai ça marche.
En vérité, la programmation sert à trouver des solutions à des problèmes.
Peu importe si la solution n’est pas.....élégante, pourvue qu’elle fasse ce qu'on attend d'elle.

ygeronimi a écrit:

...
Resultat : Erreur Not correct arithmetic....... line 10
alors je fais comment pour remettre le resultat ds une variable.....

Bonjour ygeronimi,

Je suis tombé sur la même erreur que toi et je t'ai donné la solution dans ma réponse précédente, je l'ai même écrit en rouge....
(faut descendre l'ascenseur dans la partie code pour voir la version avec appel de la DLL...)

Je te remet les 3 lignes qui t'interesse...

Code:

result% = dll_call3("print_format", adr(x), adr(format$), adr(chaine$))
chaine$=LEFT$(chaine$,INSTR(chaine$,",")-1)+"."+RIGHT$(chaine$,LEN(chaine$)-INSTR(chaine$,","))
x=val(chaine$)

on remplace la virgule par un point décimal avant de faire l'appel à VAL( )...

J'ai pas trouvé dans la doc de FB l'astuce qui permettrai de faire en sorte que la décimale soit signalée par un point et non pas par une virgule...

Nardo26 a écrit:

J'ai pas trouvé dans la doc de FB l'astuce qui permettrai de faire en sorte que la décimale soit signalée par un point et non pas par une virgule...

Après quelques essais infructueux j'ai trouvé ceci :

Code:

#include "vbcompat.bi"

extern "Windows-MS"

function print_format(byref x as double, byref format_str as zstring ptr, byref x_str as zstring ptr) as integer export
 
  dim as integer p
  dim as string  s
 
  ' Convertir le nombre x en chaine de caracteres
  s = format(x, *format_str)
 
  ' Chercher si la chaine contient une virgule
  p = instr(s, ",")
 
  ' Si oui, la remplacer par un point
  if p > 0 then mid(s, p) = "."
 
  ' Retourner la chaine
  *x_str = s
 
  return 0
end function

end extern

Apparemment, il faut utiliser une chaîne intermédiaire (s). On a des erreurs quand on travaille directement avec le pointeur déréférencé (*x_str)

Je n'avais pas eu l'erreur lors de mes premiers tests car mon Windows était configuré avec le point décimal !

papydall a écrit:

Lorsque nous désirons qu’entre le programme appelant et la fonction/procédure appelée, la transmission des paramètres se réalise dans les deux sens, autrement dit que la fonction/procédure puisse elle aussi transmettre des informations au programme appelant, nous devons alors employer ce que l’on nomme la transmission de paramètres par adresse.
Au contraire de ce qui a été dit pour une transmission par valeur, le système ne dépose pas une copie du contenu sur la pile, il travaille directement en mémoire, sur la variable. Cela provient de ce que la procédure/fonction reçoit l’adresse mémoire à laquelle figure le contenu de la variable.
De ce fait, une procédure/fonction est en mesure de modifier la valeur d’une variable, et de transmettre au programme appelant cette valeur modifiée.
Seule différence, le mot réservé ADR précédera les paramètres.

En fait, les paramètres de la fonction appelée doivent toujours être des entiers. Donc il faut passer par adresse toutes les variables réelles ou chaîne, même si la fonction ne modifie pas les paramètres.

OUAAHOU....je suis admiratif...

@Nardo

Excuses moi j'avais sauté la ligne, comme il me faut attendre que tout le monde
pour pouvoir me concentrer, dès fois j'ai pas les yeux en face des trous.

@Jean Debord

Merci pour ce nouveau code, je compile et je teste

@Papydall

Merci pour ton analyse