Correct façon d'imiter en virgule flottante simple précision en python?

Quelle est la meilleure façon d'imiter virgule flottante simple précision en python? (Ou d'autres floating point format pour que la matière?) Utilisez simplement ctypes?

  • Qu'entendez-vous par "émuler"? Lire la flotte de blobs binaires? Exécuter les mathématiques en simple précision et d'obtenir les mêmes résultats qu'une autre langue? (Dans ce dernier cas, la note qui "flottent" les mathématiques en C sur x86 est réellement évalué à 80 bits et réduit à 32 bits lorsqu'il est stocké.)
InformationsquelleAutor Ryan | 2010-02-09
  2. 12

    Si numpy (l'excellente suggestion d'autres réponses) est inapplicable pour vous (par exemple parce que vous êtes dans un environnement qui ne permet pas arbitraire les extensions tierce partie), le tableau module en Python standard library est bien aussi -- type de code 'f' vous donne 32 bits flottant. En plus de ceux-ci et l' (d'habitude) le double de la précision des flotteurs, il n'y en a pas beaucoup pour les "autres floating point format" -- qu'avez-vous en tête? (par exemple, gmpy offre BPF modeste soutien pour des flotteurs avec beaucoup plus de temps, peu arbitraire tailles-mais il est modeste, en effet, par exemple, pas de fonctions trigonométriques).

    InformationsquelleAutor Alex Martelli
  3. 8

    que diriez-ctypes.c_float de la bibliothèque standard?

    InformationsquelleAutor Kugel
  4. 4

    Si votre application convient à des tableaux ou des matrices, vous pouvez utiliser numpy avec float32

    InformationsquelleAutor John La Rooy
  5. 1

    Il est possible d'utiliser Python struct module de tronquer une 64-bit à virgule flottante à la précision de 32 bits à virgule flottante.

    Par exemple:

    >>> x = 1.1122334455667788
>>> x
1.1122334455667788
>>> struct.unpack('f', struct.pack('f', x))[0]
1.1122334003448486

    De faire des opérations uniquement avec les versions 32 bits de flotteurs, vous devez appliquer cette opération de troncature pour le résultat de chaque opération arithmétique.

    InformationsquelleAutor Mark Seaborn
  6. 0

    De développer un peu sur le ctypes option [1]:

    >>> import ctypes
>>> ctypes.sizeof(ctypes.c_int)                                                                                                                                                        
4
>>> ctypes.sizeof(ctypes.c_long)                                                                                                                                                       
8

>>> ctypes.sizeof(ctypes.c_float)                                                                                                                                                      
4
>>> ctypes.sizeof(ctypes.c_double)                                                                                                                                                     
8

    Avec numpy [2], par exemple:

    >>> import numpy as np
>>> np.zeros((1,1), dtype='uint8').nbytes                                                                                                                                              
1
>>> np.zeros((1,1), dtype='uint16').nbytes                                                                                                                                             
2
>>> np.zeros((1,1), dtype='uint64').nbytes                                                                                                                                             
8
>>> np.zeros((1,1), dtype='float').nbytes  # watch out for this one
8
>>> np.zeros((1,1), dtype='float32').nbytes                                                                                                                                            
4
>>> np.zeros((1,1), dtype='float64').nbytes                                                                                                                                            
8
>>> np.zeros((1,1), dtype='single').nbytes                                                                                                                                             
4
>>> np.zeros((1,1), dtype='double').nbytes                                                                                                                                             
8

    numpy.astype ne les conversions, par exemple

    >>> np.zeros((1,1), dtype='double').astype('single').nbytes                                                                                                                            
4

    [1] https://docs.python.org/3/library/ctypes.html#fundamental-data-types

    [2] https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.dtypes.html

    InformationsquelleAutor Darren Weber