zmc
2023-08-08 e792e9a60d958b93aef96050644f369feb25d61b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
from __future__ import annotations
 
import numpy as np
 
from pandas.core.dtypes.base import register_extension_dtype
from pandas.core.dtypes.common import is_float_dtype
 
from pandas.core.arrays.numeric import (
    NumericArray,
    NumericDtype,
)
 
 
class FloatingDtype(NumericDtype):
    """
    An ExtensionDtype to hold a single size of floating dtype.
 
    These specific implementations are subclasses of the non-public
    FloatingDtype. For example we have Float32Dtype to represent float32.
 
    The attributes name & type are set when these subclasses are created.
    """
 
    _default_np_dtype = np.dtype(np.float64)
    _checker = is_float_dtype
 
    @classmethod
    def construct_array_type(cls) -> type[FloatingArray]:
        """
        Return the array type associated with this dtype.
 
        Returns
        -------
        type
        """
        return FloatingArray
 
    @classmethod
    def _str_to_dtype_mapping(cls):
        return FLOAT_STR_TO_DTYPE
 
    @classmethod
    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
        """
        Safely cast the values to the given dtype.
 
        "safe" in this context means the casting is lossless.
        """
        # This is really only here for compatibility with IntegerDtype
        # Here for compat with IntegerDtype
        return values.astype(dtype, copy=copy)
 
 
class FloatingArray(NumericArray):
    """
    Array of floating (optional missing) values.
 
    .. versionadded:: 1.2.0
 
    .. warning::
 
       FloatingArray is currently experimental, and its API or internal
       implementation may change without warning. Especially the behaviour
       regarding NaN (distinct from NA missing values) is subject to change.
 
    We represent a FloatingArray with 2 numpy arrays:
 
    - data: contains a numpy float array of the appropriate dtype
    - mask: a boolean array holding a mask on the data, True is missing
 
    To construct an FloatingArray from generic array-like input, use
    :func:`pandas.array` with one of the float dtypes (see examples).
 
    See :ref:`integer_na` for more.
 
    Parameters
    ----------
    values : numpy.ndarray
        A 1-d float-dtype array.
    mask : numpy.ndarray
        A 1-d boolean-dtype array indicating missing values.
    copy : bool, default False
        Whether to copy the `values` and `mask`.
 
    Attributes
    ----------
    None
 
    Methods
    -------
    None
 
    Returns
    -------
    FloatingArray
 
    Examples
    --------
    Create an FloatingArray with :func:`pandas.array`:
 
    >>> pd.array([0.1, None, 0.3], dtype=pd.Float32Dtype())
    <FloatingArray>
    [0.1, <NA>, 0.3]
    Length: 3, dtype: Float32
 
    String aliases for the dtypes are also available. They are capitalized.
 
    >>> pd.array([0.1, None, 0.3], dtype="Float32")
    <FloatingArray>
    [0.1, <NA>, 0.3]
    Length: 3, dtype: Float32
    """
 
    _dtype_cls = FloatingDtype
 
    # The value used to fill '_data' to avoid upcasting
    _internal_fill_value = np.nan
    # Fill values used for any/all
    # Incompatible types in assignment (expression has type "float", base class
    # "BaseMaskedArray" defined the type as "<typing special form>")
    _truthy_value = 1.0  # type: ignore[assignment]
    _falsey_value = 0.0  # type: ignore[assignment]
 
 
_dtype_docstring = """
An ExtensionDtype for {dtype} data.
 
This dtype uses ``pd.NA`` as missing value indicator.
 
Attributes
----------
None
 
Methods
-------
None
"""
 
# create the Dtype
 
 
@register_extension_dtype
class Float32Dtype(FloatingDtype):
    type = np.float32
    name = "Float32"
    __doc__ = _dtype_docstring.format(dtype="float32")
 
 
@register_extension_dtype
class Float64Dtype(FloatingDtype):
    type = np.float64
    name = "Float64"
    __doc__ = _dtype_docstring.format(dtype="float64")
 
 
FLOAT_STR_TO_DTYPE = {
    "float32": Float32Dtype(),
    "float64": Float64Dtype(),
}