cpython@0a883a7 (original) (raw)

`@@ -11,106 +11,44 @@ PyFloatObject represents a (double precision) floating point number.

11

`extern "C" {

12

`#endif

13

14

#ifndef Py_LIMITED_API

15

typedef struct {

16

PyObject_HEAD

17

double ob_fval;

18

} PyFloatObject;

19

#endif

20

-

21

14

`PyAPI_DATA(PyTypeObject) PyFloat_Type;

22

15

23

16

`#define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type)

24

17

`#define PyFloat_CheckExact(op) Py_IS_TYPE(op, &PyFloat_Type)

25

18

26

19

`#ifdef Py_NAN

27

#define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN)

20

define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN)

28

21

`#endif

29

22

30

#define Py_RETURN_INF(sign) do \

31

if (copysign(1., sign) == 1.) { \

32

return PyFloat_FromDouble(Py_HUGE_VAL); \

33

} else { \

34

return PyFloat_FromDouble(-Py_HUGE_VAL); \

23

#define Py_RETURN_INF(sign) \

24

do { \

25

if (copysign(1., sign) == 1.) { \

26

return PyFloat_FromDouble(Py_HUGE_VAL); \

27

} \

28

else { \

29

return PyFloat_FromDouble(-Py_HUGE_VAL); \

30

} \

35

31

` } while(0)

36

32

37

33

`PyAPI_FUNC(double) PyFloat_GetMax(void);

38

34

`PyAPI_FUNC(double) PyFloat_GetMin(void);

39

PyAPI_FUNC(PyObject *) PyFloat_GetInfo(void);

35

PyAPI_FUNC(PyObject*) PyFloat_GetInfo(void);

40

36

41

37

`/* Return Python float from string PyObject. */

42

PyAPI_FUNC(PyObject ) PyFloat_FromString(PyObject);

38

PyAPI_FUNC(PyObject*) PyFloat_FromString(PyObject*);

43

39

44

40

`/* Return Python float from C double. */

45

PyAPI_FUNC(PyObject *) PyFloat_FromDouble(double);

41

PyAPI_FUNC(PyObject*) PyFloat_FromDouble(double);

46

42

47

43

`/* Extract C double from Python float. The macro version trades safety for

48

44

` speed. */

49

PyAPI_FUNC(double) PyFloat_AsDouble(PyObject *);

50

#ifndef Py_LIMITED_API

51

#define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval)

52

#endif

45

PyAPI_FUNC(double) PyFloat_AsDouble(PyObject*);

53

46

54

47

`#ifndef Py_LIMITED_API

55

/* PyFloat{Pack,Unpack}{4,8}

56

57

The struct and pickle (at least) modules need an efficient platform-

58

independent way to store floating-point values as byte strings.

59

The Pack routines produce a string from a C double, and the Unpack

60

routines produce a C double from such a string. The suffix (4 or 8)

61

specifies the number of bytes in the string.

62

63

On platforms that appear to use (see _PyFloat_Init()) IEEE-754 formats

64

these functions work by copying bits. On other platforms, the formats the

65

4- byte format is identical to the IEEE-754 single precision format, and

66

the 8-byte format to the IEEE-754 double precision format, although the

67

packing of INFs and NaNs (if such things exist on the platform) isn't

68

handled correctly, and attempting to unpack a string containing an IEEE

69

INF or NaN will raise an exception.

70

71

On non-IEEE platforms with more precision, or larger dynamic range, than

72

754 supports, not all values can be packed; on non-IEEE platforms with less

73

precision, or smaller dynamic range, not all values can be unpacked. What

74

happens in such cases is partly accidental (alas).

75

76

-

77

/* The pack routines write 2, 4 or 8 bytes, starting at p. le is a bool

78

argument, true if you want the string in little-endian format (exponent

79

last, at p+1, p+3 or p+7), false if you want big-endian format (exponent

80

first, at p).

81

Return value: 0 if all is OK, -1 if error (and an exception is

82

set, most likely OverflowError).

83

There are two problems on non-IEEE platforms:

84

1): What this does is undefined if x is a NaN or infinity.

85

2): -0.0 and +0.0 produce the same string.

86

87

PyAPI_FUNC(int) _PyFloat_Pack2(double x, unsigned char *p, int le);

88

PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le);

89

PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le);

90

-

91

/* The unpack routines read 2, 4 or 8 bytes, starting at p. le is a bool

92

argument, true if the string is in little-endian format (exponent

93

last, at p+1, p+3 or p+7), false if big-endian (exponent first, at p).

94

Return value: The unpacked double. On error, this is -1.0 and

95

PyErr_Occurred() is true (and an exception is set, most likely

96

OverflowError). Note that on a non-IEEE platform this will refuse

97

to unpack a string that represents a NaN or infinity.

98

99

PyAPI_FUNC(double) _PyFloat_Unpack2(const unsigned char *p, int le);

100

PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le);

101

PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le);

102

-

103

PyAPI_FUNC(void) _PyFloat_DebugMallocStats(FILE* out);

104

-

105

/* Format the object based on the format_spec, as defined in PEP 3101

106

(Advanced String Formatting). */

107

PyAPI_FUNC(int) _PyFloat_FormatAdvancedWriter(

108

_PyUnicodeWriter *writer,

109

PyObject *obj,

110

PyObject *format_spec,

111

Py_ssize_t start,

112

Py_ssize_t end);

113

#endif /* Py_LIMITED_API */

48

define Py_CPYTHON_FLOATOBJECT_H

49

include "cpython/floatobject.h"

50

undef Py_CPYTHON_FLOATOBJECT_H

51

#endif

114

52

115

53

`#ifdef __cplusplus

116

54