Forum TI-Planet.org

Bonjour,
Je n'arrive pas à extraire la partie décimale d'un nombre.
Par exemple 125.36.
int(125.36) donne 125, int doit vouloir dire integer part et fonctionne comme floor, ou IP.
Mais je ne vois l'instruction FRAC ou FP (fractional part). Si cette instruction n'existe pas comment extraire la partie décimale ?

Bonjour.

Tu as déjà trouvé tout ce qu'il faut pour la calculer.

Voici une fonction en ce sens :

Code: Select all

def fp(i): return i-int(i)

Par exemple dans les calculs calendaires, on recours souvent à FP qui tombe juste, mais là : i_int(i) pour 125.36 retourne :
0.3599999999999994. Alors j'utilise round(x,digits) mais j'obtiens toujours .3599999999994.
Les arrondis me posent problèmes sur Ti.

EDIT : Si je connais le nombre de décimales désiré, je fais par exemple :

Code: Select all

def fp(i):
  s=(i-int(i))
  s=round(s,3)   # je désire n décimales, j'indique : n+1, ici 3 pour être sûr. C'est bon aussi avec n=2.
  print(s)


exemple : fp(125.36) ===> 0.36 (youpi !)
------------ fp(2.1935) ===> 0.1935 (ici je mets n+1 = 5)

Ajouter 1 à n n'est peut-être pas nécessaire.

Ce n'est pas la faute de TI ici ; nous sommes en Micropython et donc les nombres non entiers sont représentés en virgule flottante double précision (64 bits).

La NumWorks et la Casio Graph 90/35+E II font très exactement les mêmes erreurs de calcul que la TI-Nspire CX II :

Il y a toujours ce genre d'erreurs avec les flottants : on ne peut pas y échapper.
On peut les contourner :

• soit en codant uniquement avec des entiers à la place des flottants,
• soit en acceptant une petite erreur sur les calculs avec les flottants.

Dans ton cas, les entiers seraient sans doute plus adaptés, mais cela obligerait à récrire tous tes algorithmes.

PS : La fonction int ne donne ni un arrondi, ni la partie entière, lorsqu'elle est appliquée à un flottant, mais la troncature vers 0.
Autrement dit, int(12.8) renvoie 12 et int(-17.7) renvoie -17.

Merci pour vos avis et nullement je n'ai dit que c'était la faute de Ti. Bien sûr je découvre le python et cela m'oblige à raisonner
autrement qu'en PPL, tant mieux. Il y a toujours des solutions quand un seul arbre ne cache pas la forêt. A l'école le maître nous disait
raisonnez rai pas ré !

Pour int j'ignorais ce que me dit Bisam, en effet important.

ggauny@live.fr wrote:Merci pour vos avis et nullement je n'ai dit que c'était la faute de Ti.

Alors toutes mes excuses si j'ai mal compris.

Mais c'était une simple précision, il n'y avait aucune connotation négative envers quiconque.

Je pense surtout m'être mal exprimé. Mais vos conseils en programmation sont très importants et en voici une preuve.
Pour décomposer une date entrée en format JJ,MMAAAA en JJ, MM, AAAA et puisque int est une troncature qui a le même effet que IP sur les Primes,
voilà ma dernière routine de départ :

Code: Select all

def da(date):
  j=int(date)
  print(j)
 
  m=int((date-j)*100)
  print(m)

  a=((date*100)-int(date*100))*10000
  a=int(round(a,4))
  print(a)


Et j'obtiens exactement ce qu'il me faut :

def(23.021935)
==> 23
==> 2
==> 1935

Bonne soirée à tous. Je peaufinerai demain, je ne peux plus me concentrer aussi longtemps
que quand j'étais plus jeune !

Il y a une autre solution:

Code: Select all

def da(jour, mois, annee):

Et plus besoin de calcul...
À signaler qu'en pur python il n'y a pas de fonction pour retourner la partie fractionnaire d'un flottant, donc:

Code: Select all

fpart(x) = x - int(x)

parce que

Code: Select all

int

est avant tout une fonction de conversion de type primitif qui transforme l'argument passé en nombre entier. En d'autres termes, vous levez une exception (ValueError) si l'argument n'est pas numérique.

Il y a toujours ce genre d'erreurs avec les flottants : on ne peut pas y échapper.

En python standard, le module

Code: Select all

decimal

rempli ce rôle mais n'existe pas sur la Nspire CX II-T CAS. Et ce doit être pareil sur autres Nspire.
Pour plus d'information à ce sujet voir page 2 du "Python dans l'environnement TI-Nspire : Guide de programmation".