|
Server : Apache System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64 User : njnconst ( 1116) PHP Version : 8.4.18 Disable Function : NONE Directory : /proc/self/root/opt/alt/python27/lib64/python2.7/site-packages/numpy/core/ |
Upload File : |
�
� 9Zc @` s� d Z d d l m Z m Z m Z d d l Z d d l Z d d l m Z d d l m
Z d d l m
Z
m Z m Z d d d
g Z e j Z i d d 6d
d 6d d 6d d 6d
d 6d d 6d d 6d d 6d d 6d
d
6d d 6d d 6d d 6d d 6Z e j Z d � Z d
f d � � YZ d e j f d � � YZ d e f d � � YZ e e e e e e e d � Z e e e e e e e d � Z e e d e e e e e d � Z d � Z e e d e e e e e d! � Z e e d e e e e e e e! d" �
Z" d S(# s�
Record Arrays
=============
Record arrays expose the fields of structured arrays as properties.
Most commonly, ndarrays contain elements of a single type, e.g. floats,
integers, bools etc. However, it is possible for elements to be combinations
of these using structured types, such as::
>>> a = np.array([(1, 2.0), (1, 2.0)], dtype=[('x', int), ('y', float)])
>>> a
array([(1, 2.0), (1, 2.0)],
dtype=[('x', '<i4'), ('y', '<f8')])
Here, each element consists of two fields: x (and int), and y (a float).
This is known as a structured array. The different fields are analogous
to columns in a spread-sheet. The different fields can be accessed as
one would a dictionary::
>>> a['x']
array([1, 1])
>>> a['y']
array([ 2., 2.])
Record arrays allow us to access fields as properties::
>>> ar = np.rec.array(a)
>>> ar.x
array([1, 1])
>>> ar.y
array([ 2., 2.])
i ( t divisiont absolute_importt print_functionNi ( t numeric( t numerictypes( t isfileobjt bytest longt recordt recarrayt
format_parsert >t bt <t lt =t nt Bt Lt Nt st St |t It ic C` sf g } xY t t | � � D]E } | | | | d k r | | | k r^ | j | | � q^ q q W| S( s@ Find duplication in a list, return a list of duplicated elementsi ( t ranget lent append( t listt dupR ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt find_duplicateJ s c B` s; e Z d Z e d d � Z d d � Z d � Z d � Z RS( s�
Class to convert formats, names, titles description to a dtype.
After constructing the format_parser object, the dtype attribute is
the converted data-type:
``dtype = format_parser(formats, names, titles).dtype``
Attributes
----------
dtype : dtype
The converted data-type.
Parameters
----------
formats : str or list of str
The format description, either specified as a string with
comma-separated format descriptions in the form ``'f8, i4, a5'``, or
a list of format description strings in the form
``['f8', 'i4', 'a5']``.
names : str or list/tuple of str
The field names, either specified as a comma-separated string in the
form ``'col1, col2, col3'``, or as a list or tuple of strings in the
form ``['col1', 'col2', 'col3']``.
An empty list can be used, in that case default field names
('f0', 'f1', ...) are used.
titles : sequence
Sequence of title strings. An empty list can be used to leave titles
out.
aligned : bool, optional
If True, align the fields by padding as the C-compiler would.
Default is False.
byteorder : str, optional
If specified, all the fields will be changed to the
provided byte-order. Otherwise, the default byte-order is
used. For all available string specifiers, see `dtype.newbyteorder`.
See Also
--------
dtype, typename, sctype2char
Examples
--------
>>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
... ['T1', 'T2', 'T3']).dtype
dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4'),
(('T3', 'col3'), '|S5')])
`names` and/or `titles` can be empty lists. If `titles` is an empty list,
titles will simply not appear. If `names` is empty, default field names
will be used.
>>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
... []).dtype
dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '|S5')])
>>> np.format_parser(['f8', 'i4', 'a5'], [], []).dtype
dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', '|S5')])
c C` s= | j | | � | j | | � | j | � | j | _ d S( N( t
_parseFormatst _setfieldnamest _createdescrt _descrt dtype( t selft formatst namest titlest alignedt byteorder( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt __init__� s
i c C` s | d k r t d � � n t | t � r^ t | � d k rL | j d � n d j | � } n t j | | � } | j } | d k r� t j d | f g | � } | j } n | j
} g | D] } | | d ^ q� | _ g | D] } | | d ^ q� | _ t | � | _
d S( s Parse the field formats s Need formats argumenti t t ,t f1i i N( t Nonet
ValueErrort
isinstanceR R R t joint sbR# t fieldsR& t
_f_formatst _offsetst _nfields( R$ R% R( R# R3 t keyst key( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR � s $$c C` sp | r� t | � t t g k r! n7 t | t � rB | j d � } n t d t | � � � g | | j D] } | j � ^ qf | _
n g | _
| j
g t t | j
� | j � D] } d | ^ q� 7_
t
| j
� } | r� t d | � � n | r"g | | j D] } | j � ^ q| _ n g | _ g } | j t | � k rl| j d g | j t | � 7_ n d S( sQ convert input field names into a list and assign to the _names
attribute R, s illegal input names %ss f%ds Duplicate field names: %sN( t typeR t tupleR0 t strt splitt NameErrort reprR6 t stript _namesR R R R/ t _titlesR. ( R$ R& R' R R t _dup( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR � s& , ", c C` sp t j i | j d 6| j d 6| j d 6| j d 6� } | d k rc t | d } | j | � } n | | _ d S( NR& R% t offsetsR' i (
R2 R# R@ R4 R5 RA R. t _byteorderconvt newbyteorderR" ( R$ R) t descr( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR! � s
N( t __name__t
__module__t __doc__t FalseR. R* R R R! ( ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR
S s
: $c B` sP e Z d Z d Z d Z d � Z d � Z d � Z d � Z d � Z d � Z RS( sE A data-type scalar that allows field access as attribute lookup.
R t numpyc C` s
| j � S( N( t __str__( R$ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt __repr__� s c C` s t | j � � S( N( R; t item( R$ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyRL � s c C` s� | d k r t j j | | � Sy t j j | | � SWn t k
rI n Xt j j | d � j } | j | d � } | r� | j | d � } y
| j } Wn t k
r� | SX| j r� | j | j
| j j f � S| St d | � � d S( Nt setfieldt getfieldR# i s% 'record' object has no attribute '%s'( RO RP R# ( t ntt voidt __getattribute__t AttributeErrorR3 t getR. RP R# t viewt __class__( R$ t attrt fielddictt rest objt dt( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyRS � s&
c C` s� | d k r t d | � � n t j j | d � j } | j | d � } | rc | j | | d � St | | d � r� t j j | | | � St d | � � d S( NRO RP R# s Cannot set '%s' attributei s% 'record' object has no attribute '%s'( RO RP R# (
RT RQ RR RS R3 RU R. RO t getattrt __setattr__( R$ RX t valRY RZ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR^ � s c C` sW t j j | | � } t | t j � rO | j j rO | j | j | j j f � S| Sd S( N( RQ RR t __getitem__R0 R# R3 RV RW ( R$ t indxR[ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR`
s c C` sp | j j } t d � | D� � } g } d | } x. | D]& } | j | | t | | � f � q9 Wd j | � S( s Pretty-print all fields.c s` s | ] } t | � Vq d S( N( R ( t .0t name( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pys <genexpr> s s %% %ds: %%ss
( R# R& t maxR R] R1 ( R$ R& t maxlent rowst fmtRc ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt pprint s
$( RG RH RI RM RL RS R^ R` Rh ( ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR � s
c B` sz e Z d Z d Z d Z d d d d d d d d e d d �
Z d � Z d � Z d � Z d � Z d
� Z
d d � Z RS(
s2 Construct an ndarray that allows field access using attributes.
Arrays may have a data-types containing fields, analogous
to columns in a spread sheet. An example is ``[(x, int), (y, float)]``,
where each entry in the array is a pair of ``(int, float)``. Normally,
these attributes are accessed using dictionary lookups such as ``arr['x']``
and ``arr['y']``. Record arrays allow the fields to be accessed as members
of the array, using ``arr.x`` and ``arr.y``.
Parameters
----------
shape : tuple
Shape of output array.
dtype : data-type, optional
The desired data-type. By default, the data-type is determined
from `formats`, `names`, `titles`, `aligned` and `byteorder`.
formats : list of data-types, optional
A list containing the data-types for the different columns, e.g.
``['i4', 'f8', 'i4']``. `formats` does *not* support the new
convention of using types directly, i.e. ``(int, float, int)``.
Note that `formats` must be a list, not a tuple.
Given that `formats` is somewhat limited, we recommend specifying
`dtype` instead.
names : tuple of str, optional
The name of each column, e.g. ``('x', 'y', 'z')``.
buf : buffer, optional
By default, a new array is created of the given shape and data-type.
If `buf` is specified and is an object exposing the buffer interface,
the array will use the memory from the existing buffer. In this case,
the `offset` and `strides` keywords are available.
Other Parameters
----------------
titles : tuple of str, optional
Aliases for column names. For example, if `names` were
``('x', 'y', 'z')`` and `titles` is
``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then
``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``.
byteorder : {'<', '>', '='}, optional
Byte-order for all fields.
aligned : bool, optional
Align the fields in memory as the C-compiler would.
strides : tuple of ints, optional
Buffer (`buf`) is interpreted according to these strides (strides
define how many bytes each array element, row, column, etc.
occupy in memory).
offset : int, optional
Start reading buffer (`buf`) from this offset onwards.
order : {'C', 'F'}, optional
Row-major (C-style) or column-major (Fortran-style) order.
Returns
-------
rec : recarray
Empty array of the given shape and type.
See Also
--------
rec.fromrecords : Construct a record array from data.
record : fundamental data-type for `recarray`.
format_parser : determine a data-type from formats, names, titles.
Notes
-----
This constructor can be compared to ``empty``: it creates a new record
array but does not fill it with data. To create a record array from data,
use one of the following methods:
1. Create a standard ndarray and convert it to a record array,
using ``arr.view(np.recarray)``
2. Use the `buf` keyword.
3. Use `np.rec.fromrecords`.
Examples
--------
Create an array with two fields, ``x`` and ``y``:
>>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', float), ('y', int)])
>>> x
array([(1.0, 2), (3.0, 4)],
dtype=[('x', '<f8'), ('y', '<i4')])
>>> x['x']
array([ 1., 3.])
View the array as a record array:
>>> x = x.view(np.recarray)
>>> x.x
array([ 1., 3.])
>>> x.y
array([2, 4])
Create a new, empty record array:
>>> np.recarray((2,),
... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP
rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),
(3471280, 1.2134086255804012e-316, 0)],
dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')])
R RK i t Cc C` s� | d k r t j | � } n t | | | |
| � j } | d k ri t j | | t | f d | �}
n3 t j | | t | f d | d | d | d | �}
|
S( Nt ordert buffert offsett strides( R. R2 R# R
R" t ndarrayt __new__R ( t subtypet shapeR# t bufRl Rm R% R& R' R) R( Rj RF R$ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyRo � s $ c C` s% | j j t k r! | j | _ n d S( N( R# R9 R ( R$ R[ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt __array_finalize__� s c C` s� y t j | | � SWn t k
r' n Xt j | d � j } y | | d } Wn' t t f k
rx t d | � � n X| j | � } | j j r� t | j j
t j � r� | j
d | j j
| j f � S| S| j
t � Sd S( NR# i s recarray has no attribute %s( t objectRS RT Rn R3 t TypeErrort KeyErrorRP R# t
issubclassR9 RQ RR RV ( R$ RX RY RZ R[ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyRS � s
c C` s_ | d k rB t | j t j � rB | j rB t j t | f � } n | | j k } y t j
| | | � } WnS t j | d � j p� i } | | k rt
j � d \ } } | | � � qnT Xt j | d � j p� i } | | k r� | S| ry t j | | � Wq| SXn y | | d } Wn' t t f k
rNt d | � � n X| j | | � S( NR# i s record array has no attribute %s( Rw R9 RQ RR R3 R2 R# R t __dict__Rt R^ Rn RS t syst exc_infot __delattr__Ru Rv RT RO ( R$ RX R_ t newattrt retRY t exctypet valueRZ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR^ � s. * c C` s� t t | � j | � } t | t � r� | j j r� | j t | � � } t | j j t
j � r | j d | j j | j f � S| S| j d t � Sn | Sd S( NR# R9 ( t superR R` R0 Rn R# R3 RV R9 Rw RQ RR ( R$ Ra R[ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR` � s c C` s | j d k s | j d k r6 t j | d d �} n d t | j � f } | j j t k sw t | j j t j
� r� | j } | j t k r� t j t j
| f � } n d d t d � } d | | | f Sd d t d � } d
| | t | j � f Sd S( Ni t separators , s [], shape=%ss
t s
rec.array(s rec.array(%s, %sdtype=%s)s array(s* array(%s, %sdtype=%s).view(numpy.recarray)( i (
t sizeRq R2 t array2stringR> R# R9 R Rw RQ RR R R; ( R$ t lstt plain_dtypet lf( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyRM s c C` s� t | t � r1 t j | d � j } | | } n t j | d � j } | | d } | d k r� | j | � } | j j r | S| j t � S| j
| | � Sd S( NR# i ( R0 t intRn RS R& R3 R. RP R# RV RO ( R$ RX R_ R& RY RZ R[ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt field s
N( RG RH RI R. RJ Ro Rs RS R^ R` RM R� ( ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR * s h " c C` s- g | D] } t j | � ^ q } | d k s: | d k rJ | d j } n t | t � re | f } n | d k r� | d k r� g } x? | D]7 } t | t � s� t d � � n | j | j j
� q� Wd j | � } n | d k r� t j | � }
|
j } n* t
| | | | | � } | j } | j }
t |
� t | � k rOt d � � n |
d j }
t |
� } | d k r�| | } n xf t | � D]X \ } } t |
| j � } | j t | j � | } | | k r�t d | � � q�q�Wt | |
� } x, t t | � � D] } | | | | | <q
W| S( sA create a record array from a (flat) list of arrays
>>> x1=np.array([1,2,3,4])
>>> x2=np.array(['a','dd','xyz','12'])
>>> x3=np.array([1.1,2,3,4])
>>> r = np.core.records.fromarrays([x1,x2,x3],names='a,b,c')
>>> print(r[1])
(2, 'dd', 2.0)
>>> x1[1]=34
>>> r.a
array([1, 2, 3, 4])
i s* item in the array list must be an ndarray.R, s> mismatch between the number of fields and the number of arrayss array-shape mismatch in array %dN( R2 t asarrayR. Rq R0 R� Rn R/ R R# R; R1 R& R
R@ R" R t enumerateR R ( t arrayListR# Rq R% R& R' R( R) t xR[ RF R@ t parsedt d0t nnt kt testshapet _arrayR ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt
fromarrays2 sB "
c C` s� t | d � } | d k r� | d k r� t j | d t �} g t | � D]% }
t j | d |
f j � � ^ qJ } t | d | d | d | d | d | d | �S| d k r� t j t | f � } n t
| | | | | � j } y t j | d | �}
Wn� t k
r�| d k s#| d k r2t | � } n t
| t t f � rS| f } n t | � d
k rtt d � � n t | | � } x+ t | j � D] } t | | � | | <q�W| SX| d k r�|
j | k r�| |
_ n |
j t � } | S(
sd create a recarray from a list of records in text form
The data in the same field can be heterogeneous, they will be promoted
to the highest data type. This method is intended for creating
smaller record arrays. If used to create large array without formats
defined
r=fromrecords([(2,3.,'abc')]*100000)
it can be slow.
If formats is None, then this will auto-detect formats. Use list of
tuples rather than list of lists for faster processing.
>>> r=np.core.records.fromrecords([(456,'dbe',1.2),(2,'de',1.3)],
... names='col1,col2,col3')
>>> print(r[0])
(456, 'dbe', 1.2)
>>> r.col1
array([456, 2])
>>> r.col2
array(['dbe', 'de'],
dtype='|S3')
>>> import pickle
>>> print(pickle.loads(pickle.dumps(r)))
[(456, 'dbe', 1.2) (2, 'de', 1.3)]
i R# .R% Rq R& R' R( R) i s Can only deal with 1-d array.N( R R. R2 t arrayRt R t tolistR� R# R R
R" Ru R0 R� R R/ R R� R: Rq RV ( t recListR# Rq R% R& R' R( R) t nfieldsR[ R t arrlistRF t retvalR� R� RZ ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt fromrecordst s4 8
c C` s� | d k r' | d k r' t d � � n | d k rE t j | � } n t | | | | | � j } | j }
| d k s� | d k s� | d k r� t | � | |
} n t | | d | d | �} | S( sM create a (read-only) record array from binary data contained in
a strings Must have dtype= or formats=i i����Rr Rl N( R. R/ R2 R# R
R" t itemsizeR R ( t
datastringR# Rq Rl R% R& R' R( R) RF R� R� ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt
fromstring� s $c C` sd y | j � } Wn+ t k
r= t j j | j � | j � SXt j | � } | j | j � } | S( N( t filenoRT t ost patht getsizeRc t tellt fstatt st_size( t fdt fnt stR� ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt get_remaining_size� s
c C` s� | d k s | d k r! d } n! t | t t f � rB | f } n d } t | t � ro d } t | d � } n | d k r� | j | d � n t | � }
| d k r� t j | � } n t
| | | | | � j } | j } t j
| � j � }
|
| } | d k rOt | � } |
| | | j d � <t | � } t j
| � j � }
n |
| } | |
k rtt d � � n t | | � } | j | j � } | | k r�t d � � n | r�| j � n | S( s Create an array from binary file data
If file is a string then that file is opened, else it is assumed
to be a file object.
>>> from tempfile import TemporaryFile
>>> a = np.empty(10,dtype='f8,i4,a5')
>>> a[5] = (0.5,10,'abcde')
>>>
>>> fd=TemporaryFile()
>>> a = a.newbyteorder('<')
>>> a.tofile(fd)
>>>
>>> fd.seek(0)
>>> r=np.core.records.fromfile(fd, formats='f8,i4,a5', shape=10,
... byteorder='<')
>>> print(r[5])
(0.5, 10, 'abcde')
>>> r.shape
(10,)
i i����i t rbs: Not enough bytes left in file for specified shape and types% Didn't read as many bytes as expectedN( i����( R. R0 R� R R; t opent seekR� R2 R# R
R" R� R� t prodR t indexR: R/ R t readintot datat IOErrort close( R� R# Rq Rl R% R& R' R( R) Rc R� RF R� t shapeprodt shapesizet nbytesR� t
nbytesread( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt fromfile� sB
c C` s
t | t d � t f � s' t | � rN | d k rN | d k rN t d � � n i } | d k rr t j | � } nS | d k r� t | | | | | � j } n) i | d 6| d 6| d 6| d 6| d 6} | d k r | d k r� t d � � n t
| | d | d | d
| �St | t � r6t | | d | d | | �St | t
t f � r�t | d t t
f � r}t | d
| d | | �St | d
| d | | �Snmt | t
� r�| d k r�| j | k r�| j | � } n | } |
r�| j � } n | St | � r t | d
| d | d | �St | t � r�| d k rX| j | k rX| j | � } n | } |
rs| j � } n | j t
� St | d d � }
|
d k s�t |
t � r�t d � � n t j | � } | d k r�| j | k r�| j | � } n | j t
� Sd S( s= Construct a record array from a wide-variety of objects.
sI Must define formats (or dtype) if object is None, string, or an open fileR% R& R' R( R) s" Must define a shape if obj is NoneRr Rl Rm Rq i R# t __array_interface__s Unknown input typeN( R0 R9 R. R; R R/ R2 R# R
R" R R R� R R: R� R� RV t copyR� Rn R] t dictR� ( R[ R# Rq Rl Rm R% R& R' R( R) R� t kwdst newt interface( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyR� s^ '
(# RI t
__future__R R R Ry R� R+ R R2 R RQ t numpy.compatR R R t __all__Rn RD t typeDictt numfmtR R
RR R R R. RJ R� R� R� R� R� t TrueR� ( ( ( sE /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/records.pyt <module>$ sN
�S� A ? C