Partie fractionnaire d'un flottant

Bonsoir à tous !

Constat et interrogation : scratch

Pourquoi la partie fractionnaire de 12,85 est différente de 112,85 ? Question

Code:: DIM a,b
a=112.85
b=12.85
PRINT FRAC(a)
PRINT FRAC(b)

Résultat :
$Partie fractionnaire d'un flottant 156$

Autre remarque :

MOD(112.85,112) donne le même résultat : 0.849999999999994

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Troublant en effet... problèmes de calcul interne...
il faudrait écrire
PRINT a-INT(a)
pour avoir la valeur exacte (0.85)

Oui, JL35 et merci d'avoir répondu.

C'est effectivement ce que j'ai fait pour savoir combien il y a de décimales dans un nombre flottant.

Ceci est dans le cas d'une mise en forme (formatage) pour un affichage à l'écran, et non pas pour un quelconque calcul où l'erreur serait totalement insignifiante.

Tu veux rester en 100 % Panoramic, ou est-ce qu'une fonction DLL pourrait être utile ? Du genre à passer la valeur et une chaîne de caractères représentant le format, et au retour, tu recevrais une chaîne de caractères avec t valeur formatée selon tes critères ? Nombre de chiiffres avant et après la virgule, présence du signe ou non, et si oui, devant ou derrière le nombre, présentation flottante classique ou scientifique ? Ca peut se faire... Comme ça, tu maîtriserais les dimensions à afficher, et la virgule serait toujours à la même place.

Tiens, je te propose une vieille routine qui est publiée sur mon site Web, page "Panoramic". Je l'ai mis un peu au goût du jour en transformant le sous-programme en fonction. Voici ce que ça donne, en 100 % Panoramic:

Code:: rem -------------------------------------------------------
rem Test de la routine FORMAT_nombre
rem
rem Seuls les labels et variables avec le préfixe format_
rem font partie du code utile et doivent être inclus dans
rem un programme utilisant cette routine. Voir la routine
rem format_nombre pour le mode d emploi.
rem

label execute_format, window, objets
dim test_st$, test_n%, test_err%

dim format_nbr, format_frm$, format_out$, format_in$
dim format_maxdec%, format_nbr_virg%, format_frm_virg%, format_neg$
dim format_i%, format_j%, format_car$
rem On peut modifier ne nombre maximales de décimales à volonté:
format_maxdec% = 5

gosub window
gosub objets

end

window:
   left 0,223
   top 0,182
   width 0,380
   height 0,250
   caption 0,"Function FORMAT"
   return

objets:
   alpha 11
   left 11,31
   top 11,20
   width 11,80
   height 11,20
   caption 11,"Nombre:"
   edit 1
   left 1,131
   top 1,20

   alpha 12
   left 12,31
   top 12,50
   width 12,80
   height 12,20
   caption 12,"Décimales maxi:"
   edit 2
   left 2,131
   top 2,50
   width 2,40

   alpha 13
   left 13,31
   top 13,80
   width 13,80
   height 13,20
   caption 13,"Format:"
   edit 3
   left 3,131
   top 3,80
   width 3,220

   button 4
   left 4,131
   top 4,120
   caption 4,"Appliquer"
   on_click 4,execute_format

   alpha 15
   left 15,31
   top 15,160
   width 15,80
   height 15,20
   caption 15,"Résultat:"
   alpha 5
   left 5,131
   top 5,160
   width 5,220
   height 5,20
   return

execute_format:
  format_nbr = val(trim$(text$(1)))
  format_maxdec% = val(trim$(text$(2)))
  format_frm$ = trim$(text$(3))
  caption 5,format_nombre$(format_nbr,format_maxdec%,format_frm$)
  return

rem ----------------------------------------------------------------------
rem ici on a la partie utile du code
rem en entrée, les variables suivantes doivent être chargées:
rem format_nbr nombre réel à convertir
rem format_maxdec% nombre de décimales maxi (5 est raisonnable)
rem format_frm$ masque de formattage
rem Le masque de formattage peut contenir n importe quelle chaîne de
rem caractères. Les caractères #, °, µ et la virgule sont réservés:
rem # est remplacé par un chiffre
rem ° est remplacé par un chiffre ou un espace
rem µ est remplacé par "-" si le nombre est négatif, sinon espace
rem , représente l emplacement da la virgule décimale
rem
rem Exemples: (le signe ^ représente un espace)
rem Nombre: -12.3456
rem Format Résultat
rem ---------------------------------------------------------------
rem ###,## 012,34
rem °°°#,#### ^^12,3400
rem Avant:^°°#^Après:^### Avant:^^12^Après:^340
rem µ###,## -012,34
rem °#,##^µ 12,34^-
rem # 2
rem
rem Nombre: 12072009 (12 Juillet 2009)
rem Format Résultat
rem ---------------------------------------------------------------
rem °#/##/#### 12/07/2010
rem ##-^#-#### 12-^7-2010
rem
rem Au retour, le nombre formatté est dans la variable format_out$
rem
rem ----------------------------------------------------------------------
fnc format_nombre$(format_nbr,format_maxdec%,format_frm$)

  dim_local format_out$, format_in$
  dim_local format_nbr_virg%, format_frm_virg%, format_neg$
  dim_local format_i%, format_j%, format_car$

   format_out$ = ""
   format_neg$ = " "
   if format_nbr<0 then format_neg$ = "-"
   format_in$ = string$(20,"°")+str$(format_nbr)
   format_nbr_virg% = instr(format_in$,".")
   if format_nbr_virg%=0
   format_in$ = format_in$ + ","
   format_nbr_virg% = len(format_in$)
   end_if
   format_in$ = format_in$ + string$(format_maxdec%,"0")
   format_frm_virg% = instr(format_frm$,",")
   if format_frm_virg%=0
   format_frm$ = format_frm$ + ","
   format_frm_virg% = len(format_frm$)
   end_if
   format_j% = format_nbr_virg%
   for format_i%=format_frm_virg%-1 to 1 step -1
   format_car$ = mid$(format_frm$,format_i%,1)
   if format_car$="#"
   format_j% = format_j% - 1
   format_car$ = mid$(format_in$,format_j%,1)
   if format_car$="°" then format_car$ = "0"
   format_out$ = format_car$ + format_out$
   else
   if format_car$="°"
   format_j% = format_j% - 1
   format_car$ = mid$(format_in$,format_j%,1)
   if numeric(format_car$)=0 then format_car$ = " "
   format_out$ = format_car$ + format_out$
   else
   if format_car$="µ"
   format_out$ = format_neg$ + format_out$
   else
   format_out$ = format_car$ + format_out$
   end_if
   end_if
   end_if
   next format_i%
   if format_frm_virg%<len(format_frm$)
   format_out$ = format_out$ + ","
   format_j% = format_nbr_virg%
   for format_i%=format_frm_virg%+1 to len(format_frm$)
   format_car$ = mid$(format_frm$,format_i%,1)
   if format_car$="#"
   format_j% = format_j% + 1
   format_car$ = mid$(format_in$,format_j%,1)
   if format_car$="°" then format_car$ = "0"
   format_out$ = format_out$+ format_car$
   else
   if format_car$="°"
   format_j% = format_j% + 1
   format_car$ = mid$(format_in$,format_j%,1)
   if numeric(format_car$)=0 then format_car$ = " "
   format_out$ = format_out$ + format_car$
   else
   if format_car$="µ"
   format_out$ = format_out$ + format_neg$
   else
   format_out$ = format_out$ + format_car$
   end_if
   end_if
   end_if
   next format_i%
   end_if

   result format_out$
end_fnc

C'est améliorable, mais c'est pas mal comme point de départ. J'ai écrit et publié cela en 2008 ou 2009, je pense.

Merci Klaus ! J'étudie ça...

Grace aux fonctions, tu peux te simplifier la vie. (J'ai adopté une convention personnel pour les fonctions que je te recommande)
Un mini code:

Code:: DIM a,b
a=-112.85
b=-12.85
PRINT FRAC(a)
PRINT FRAC(b)
print
PRINT FRAC_(a)
PRINT FRAC_(b)
END
' convention pour le caractère terminal d'une fonction:
' % pour les nombres entier(convention panoramic)
' _ pour les nombres à virgule <---convention personnel
' $ pour les chaînes de caratères(convention panoramic)
fnc FRAC_(v)
result (abs(v)-int(abs(v)))*sgn(v)
end_fnc

EDIT: Tu peux aussi appeler cette fonction FRAC()(cad avec le mot-clé panoramic, sans ma convention personnel), car une "fnc" est vu comme une "variable" par panoramic et est prioritaire aux mot-clés de panoramic. Cela ne pose pas de pb pour une varaible d'être nommée avec le nom d'un mot-clé, comme l'a expliqué jack ICI(à la fin)
J'utilise cette convention personnel juste pour assurer une compatibilité des "fnc" avec la future version du compilateur

Nombre de messages : 812 Localisation : Troyes Date d'inscription : 05/02/2011

bonjour
extraire la partie fractionnaire d'un chiffre

Code:: Dim Numerateur$,Fraction$
  Label Fraction
  Input "Chiffre? ";Numerateur$
  INPUT_REDO_ON
  Gosub Fraction
  End
  Fraction:
If frac(Val(Numerateur$))>0
Fraction$=mid$(Numerateur$,instr_Pos(Numerateur$,".",1)+1,10)
End_If
Print Numerateur$
Print "Extraction de la partie fractionnaire du chiffre"
Print Fraction$
  Return

c'est une façon que j'utilise pour calculus

Bonjour à tous et merci pour toutes vos réponses !

@Klaus : merci pour ton programme de formatage d'un nombre à l'affichage. C'est très pratique et universel ! Je le garde précieusement.

@JL35 : merci mais malheureusement la solution PRINT a-INT(a) ne fonctionne pas avec tous les flottants. Essaie avec 64932.951 et tu auras :

$Partie fractionnaire d'un flottant 224$

@Siverman : merci mais... ce n'est pas bon non plus :

$Partie fractionnaire d'un flottant 160$

@Pascal1000: merci aussi. Effectivement en tronquant le nombre de décimales, on supprime l'erreur d'affichage.

J'ai donc adopté la solution de tronquer les décimales.

Encore merci et bonne programmation à tous !

Tu peux également utiliser cette fonction:

Code:: fnc FRAC_(v)
result val("0"+right$(str$(a),len(str$(a))-len(str$(int(a)))))*sgn(a)
end_fnc

Elle renvoie un nombre dans tous les cas et tient compte du signe

» Extraire une partie d'image bmp
» mettre en REM une partie du code
» Zoom d'une partie d'image
» Ecraser une partie d'un string par un autre
» Faire passer toutes les balles rouges dans la partie droite