3
���h�� � @ s� d Z ddddddddd g Zd
Zd d lZd d lZyd d
lmZ W n ek
r^ d d
lmZ Y nX d d l Z
ddl m Z
ddlmZmZmZmZ ddl mZ ddlmZmZmZmZmZmZmZ ddlm Z ddl m Z m Z m Z ddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z' ddl(m)Z)m*Z* d d l+Z+d d l,Z,dddddd d d d d dd � Z-dpd!d"�Z.e*d#�dqd d$�d%d��Z/e*d#�d&d� �Z0e*d#�e,j1d'd� ��Z2f fd(d)�Z3d*d+� Z4d,d-� Z5d.d/� Z6d0d1� Z7d2d3� Z8drd5d6�Z9e9� dsd9d:��Z:dtd d$�d;d<�Z;e)e;d#d=�d d d d7d8e
j<d d d d d d8f d d$�d>d��Z=d?d@� Z>dAdB� Z?dCdD� Z@G dEdF� dF�ZAe*d#�dudId ��ZBe*d#�dvdJd��ZCG dKdL� dL�ZDG dMdN� dN�ZEG dOdP� dP�ZFG dQdR� dR�ZGG dSdT� dTeG�ZHG dUdV� dVeG�ZIG dWdX� dX�ZJG dYdZ� dZ�ZKd[d\� ZLe#e$e%e&gZMeNe"eO��r eMjPe"� eNe!eO��reMjPe!� d]d^� ZQd_d`� ZRd d d e=fdadb�ZSdwdcdd�ZTe)eTd#d=�dxded��ZUe9� dfdg� �ZVd d d e=fdhdi�ZWdydjdk�ZXe)eXd#d=�dzdld��ZYeZe=dme=�Z[ej\eWe[dn�Z]ej\eSe[dn�Z^d{dod�Z_e_e]d� e_e^dG� d S )|zXArray printing function
$Id: arrayprint.py,v 1.9 2005/09/13 13:58:44 teoliphant Exp $
� array2string� array_str�
array_repr�set_string_function�set_printoptions�get_printoptions� printoptions�format_float_positional�format_float_scientificZrestructuredtext� N)� get_ident� )� numerictypes)�absolute�isinf�isfinite�isnat)�
multiarray)�array�dragon4_positional�dragon4_scientific�datetime_as_string�
datetime_data�ndarray�set_legacy_print_mode)�any)� concatenate�asarray�errstate)�longlong�intc�int_�float_�complex_�bool_�flexible)�array_function_dispatch�
set_module� i� �maxprec� F�K �nan�inf�-) � edgeitems� threshold� floatmode� precision�suppress� linewidth�nanstr�infstr�sign� formatter�legacyc
C s� dd� t � j� D �} |dk r(t|�| d< ddddg} | | dg kr^td d
jd d � | D �� ��|dkrntd��|
dkr�tjddd� |dk r�t|tj �s�t
d��t j |�r�td��| S )zE make a dictionary out of the non-None arguments, plus sanity checks c S s i | ]\}}|d k r||�qS )N� )�.0�k�vr9 r9 �6/tmp/pip-build-5_djhm0z/numpy/numpy/core/arrayprint.py�
<dictcomp>A s z&_make_options_dict.<locals>.<dictcomp>Nr2 �fixed�uniquer( �
maxprec_equalz floatmode option must be one of z, c s s | ]}d j |�V qdS )z"{}"N)�format)r: �mr9 r9 r= � <genexpr>I s z%_make_options_dict.<locals>.<genexpr>r- �+� z+sign option must be one of ' ', '+', or '-'F�1.13z>legacy printing option can currently only be '1.13' or `False`r' )�
stacklevelzthreshold must be numericzIthreshold must be non-NAN, try sys.maxsize for untruncated representation)Nr- rE rF )NFrG )
�locals�items�bool�
ValueError�join�warnings�warn�
isinstance�numbers�Number� TypeError�np�isnan)
r1 r/ r. r3 r2 r4 r5 r6 r7 r0 r8 �options�modesr9 r9 r= �_make_options_dict< s$
rX �numpy)r8 c
C sd t | ||||||||| |
� } || d< tj| � td dkrLtd� dtd< ntd dkr`td� d S )
a�
Set printing options.
These options determine the way floating point numbers, arrays and
other NumPy objects are displayed.
Parameters
----------
precision : int or None, optional
Number of digits of precision for floating point output (default 8).
May be None if `floatmode` is not `fixed`, to print as many digits as
necessary to uniquely specify the value.
threshold : int, optional
Total number of array elements which trigger summarization
rather than full repr (default 1000).
To always use the full repr without summarization, pass `sys.maxsize`.
edgeitems : int, optional
Number of array items in summary at beginning and end of
each dimension (default 3).
linewidth : int, optional
The number of characters per line for the purpose of inserting
line breaks (default 75).
suppress : bool, optional
If True, always print floating point numbers using fixed point
notation, in which case numbers equal to zero in the current precision
will print as zero. If False, then scientific notation is used when
absolute value of the smallest number is < 1e-4 or the ratio of the
maximum absolute value to the minimum is > 1e3. The default is False.
nanstr : str, optional
String representation of floating point not-a-number (default nan).
infstr : str, optional
String representation of floating point infinity (default inf).
sign : string, either '-', '+', or ' ', optional
Controls printing of the sign of floating-point types. If '+', always
print the sign of positive values. If ' ', always prints a space
(whitespace character) in the sign position of positive values. If
'-', omit the sign character of positive values. (default '-')
formatter : dict of callables, optional
If not None, the keys should indicate the type(s) that the respective
formatting function applies to. Callables should return a string.
Types that are not specified (by their corresponding keys) are handled
by the default formatters. Individual types for which a formatter
can be set are:
- 'bool'
- 'int'
- 'timedelta' : a `numpy.timedelta64`
- 'datetime' : a `numpy.datetime64`
- 'float'
- 'longfloat' : 128-bit floats
- 'complexfloat'
- 'longcomplexfloat' : composed of two 128-bit floats
- 'numpystr' : types `numpy.string_` and `numpy.unicode_`
- 'object' : `np.object_` arrays
- 'str' : all other strings
Other keys that can be used to set a group of types at once are:
- 'all' : sets all types
- 'int_kind' : sets 'int'
- 'float_kind' : sets 'float' and 'longfloat'
- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
- 'str_kind' : sets 'str' and 'numpystr'
floatmode : str, optional
Controls the interpretation of the `precision` option for
floating-point types. Can take the following values
(default maxprec_equal):
* 'fixed': Always print exactly `precision` fractional digits,
even if this would print more or fewer digits than
necessary to specify the value uniquely.
* 'unique': Print the minimum number of fractional digits necessary
to represent each value uniquely. Different elements may
have a different number of digits. The value of the
`precision` option is ignored.
* 'maxprec': Print at most `precision` fractional digits, but if
an element can be uniquely represented with fewer digits
only print it with that many.
* 'maxprec_equal': Print at most `precision` fractional digits,
but if every element in the array can be uniquely
represented with an equal number of fewer digits, use that
many digits for all elements.
legacy : string or `False`, optional
If set to the string `'1.13'` enables 1.13 legacy printing mode. This
approximates numpy 1.13 print output by including a space in the sign
position of floats and different behavior for 0d arrays. If set to
`False`, disables legacy mode. Unrecognized strings will be ignored
with a warning for forward compatibility.
.. versionadded:: 1.14.0
See Also
--------
get_printoptions, printoptions, set_string_function, array2string
Notes
-----
`formatter` is always reset with a call to `set_printoptions`.
Use `printoptions` as a context manager to set the values temporarily.
Examples
--------
Floating point precision can be set:
>>> np.set_printoptions(precision=4)
>>> np.array([1.123456789])
[1.1235]
Long arrays can be summarised:
>>> np.set_printoptions(threshold=5)
>>> np.arange(10)
array([0, 1, 2, ..., 7, 8, 9])
Small results can be suppressed:
>>> eps = np.finfo(float).eps
>>> x = np.arange(4.)
>>> x**2 - (x + eps)**2
array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00])
>>> np.set_printoptions(suppress=True)
>>> x**2 - (x + eps)**2
array([-0., -0., 0., 0.])
A custom formatter can be used to display array elements as desired:
>>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
>>> x = np.arange(3)
>>> x
array([int: 0, int: -1, int: -2])
>>> np.set_printoptions() # formatter gets reset
>>> x
array([0, 1, 2])
To put back the default options, you can use:
>>> np.set_printoptions(edgeitems=3, infstr='inf',
... linewidth=75, nanstr='nan', precision=8,
... suppress=False, threshold=1000, formatter=None)
Also to temporarily override options, use `printoptions` as a context manager:
>>> with np.printoptions(precision=2, suppress=True, threshold=5):
... np.linspace(0, 10, 10)
array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ])
r7 r8 z1.13�q r- r6 Fr
N)rX �_format_options�updater ) r1 r/ r. r3 r2 r4 r5 r7 r6 r0 r8 �optr9 r9 r= r [ s
c C s t j� S )a.
Return the current print options.
Returns
-------
print_opts : dict
Dictionary of current print options with keys
- precision : int
- threshold : int
- edgeitems : int
- linewidth : int
- suppress : bool
- nanstr : str
- infstr : str
- formatter : dict of callables
- sign : str
For a full description of these options, see `set_printoptions`.
See Also
--------
set_printoptions, printoptions, set_string_function
)r[ �copyr9 r9 r9 r= r s c o s6 t j� }zt j| |� t j� V W dt jf |� X dS )a� Context manager for setting print options.
Set print options for the scope of the `with` block, and restore the old
options at the end. See `set_printoptions` for the full description of
available options.
Examples
--------
>>> from numpy.testing import assert_equal
>>> with np.printoptions(precision=2):
... np.array([2.0]) / 3
array([0.67])
The `as`-clause of the `with`-statement gives the current print options:
>>> with np.printoptions(precision=2) as opts:
... assert_equal(opts, np.get_printoptions())
See Also
--------
set_printoptions, get_printoptions
N)rT r r )�args�kwargs�optsr9 r9 r= r ! s
c C s� t |�}|| jkr| | S | j| d| krjtt| ||tjd|� �t| ||tj| d� �f|d�S t| ||tjdd� �S dS )z�
Keep only the N-D corners (leading and trailing edges) of an array.
Should be passed a base-class ndarray, since it makes no guarantees about
preserving subclasses.
� N)�axis)�len�ndim�shaper �_leading_trailingrT Z index_exp)�ar. �indexrc r9 r9 r= rg D s
rg c C s t | �tkrd}nd}|j| �S )z@ Object arrays containing lists should be printed unambiguously z
list({!r})z{!r})�type�listrB )�o�fmtr9 r9 r= �_object_formatX s rn c C s t | �S )N)�repr)�xr9 r9 r= � repr_format` s rq c C s t | �S )N)�str)rp r9 r9 r= �
str_formatc s rs c
s� � fdd�� fdd�� �����fdd�� �����fdd�� �����fdd�� �����fdd�� �fdd�� fd d�d
d� d d� d d� d
d� d� }dd� } �d k �r��fdd��j � D �}
d|
kr�x |j � D ]} | �d �|| < q�W d|
k�rx d D ]} | �d �|| < q�W d|
k�r<x d D ]} | �d �|| < �q"W d|
k�rfx d!D ]} | �d �|| < �qLW d |
k�r�x d"D ]} | �d �|| < �qvW x,|j � D ] } | |
k�r�| �| �|| < �q�W |S )#Nc s t � �S )N)�
BoolFormatr9 )�datar9 r= �<lambda>l s z!_get_formatdict.<locals>.<lambda>c s t � �S )N)�
IntegerFormatr9 )ru r9 r= rv m s c s t � �����d�S )N)r8 )�FloatingFormatr9 )ru r0 r8 r1 r6 r2 r9 r= rv n s c s t � �����d�S )N)r8 )rx r9 )ru r0 r8 r1 r6 r2 r9 r= rv p s c s t � �����d�S )N)r8 )�ComplexFloatingFormatr9 )ru r0 r8 r1 r6 r2 r9 r= rv r s c s t � �����d�S )N)r8 )ry r9 )ru r0 r8 r1 r6 r2 r9 r= rv t s c s t � �d�S )N)r8 )�DatetimeFormatr9 )ru r8 r9 r= rv v s c s t � �S )N)�TimedeltaFormatr9 )ru r9 r= rv w s c S s t S )N)rn r9 r9 r9 r= rv x s c S s t S )N)rs r9 r9 r9 r= rv y s c S s t S )N)rq r9 r9 r9 r= rv z s c S s t S )N)rr r9 r9 r9 r= rv { s ) rK �int�float� longfloat� complexfloat�longcomplexfloat�datetime� timedelta�object�void�numpystrrr c s � fdd�S )Nc s � S )Nr9 r9 )rp r9 r= rv � s z3_get_formatdict.<locals>.indirect.<locals>.<lambda>r9 )rp r9 )rp r= �indirect s z!_get_formatdict.<locals>.indirectc s g | ]}� | d k r|�qS )Nr9 )r: r; )r7 r9 r= �
<listcomp>� s z#_get_formatdict.<locals>.<listcomp>�allZint_kindr| Z
float_kindr} r~ Z complex_kindr r� Zstr_kindr� rr )r| )r} r~ )r r� )r� rr )�keys) ru r1 r0 r2 r6 r8 r7 r` �
formatdictr� Zfkeys�keyr9 )ru r0 r7 r8 r1 r6 r2 r= �_get_formatdictf sD
r� c K sD | j }|j}t| f|�}t|tj�r.|d � S t|tj�r\t|tj�rP|d � S |d � S n�t|tj�r�t|tj �r~|d � S |d � S n�t|tj
�r�t|tj �r�|d � S |d � S n�t|tj tj
f�r�|d � S t|tj�r�|d � S t|tj��r|d
� S t|tj��r6|jd k �r*tj| f|�S |d � S n
|d � S d S )
z;
find the right formatting function for the dtype_
rK r� r| r~ r} r� r r� r� r� Nr� )�dtyperj r� �
issubclass�_ntr# �integerZ timedelta64Zfloatingr~ ZcomplexfloatingZ
clongfloatZunicode_Zstring_Z
datetime64Zobject_r� �names�StructuredVoidFormat� from_data)ru rV Zdtype_Zdtypeobjr� r9 r9 r= �_get_format_function� s8
r� �...c s � fdd�}|S )a
Like the python 3.2 reprlib.recursive_repr, but forwards *args and **kwargs
Decorates a function such that if it calls itself with the same first
argument, it returns `fillvalue` instead of recursing.
Largely copied from reprlib.recursive_repr
c s$ t � �tj� �� ��fdd��}|S )Nc sF t | �t� f}|�kr�S �j|� z� | f|�|�S �j|� X d S )N)�idr �add�discard)�selfr_ r` r� )�f� fillvalue� repr_runningr9 r= �wrapper� s
z>_recursive_guard.<locals>.decorating_function.<locals>.wrapper)�set� functools�wraps)r� r� )r� )r� r� r= �decorating_function� s z-_recursive_guard.<locals>.decorating_functionr9 )r� r� r9 )r� r= �_recursive_guard� s
r� rF � c
C s� t | �}| jf kr|} | j|d kr8d}t||d �}nd}t|f|�}d}|dt|� 7 }t| ||d |||d ||d �}|S )Nr/ z...r. r� rF r3 r8 )r rf �sizerg r� rd � _formatArray) rh rV � separator�prefixru �summary_insert�format_function�next_line_prefix�lstr9 r9 r= �
_array2string� s
r� c
C s | fS )Nr9 )rh �max_line_widthr1 �suppress_smallr� r� �styler7 r/ r. r6 r0 �suffixr8 r9 r9 r= �_array2string_dispatcher� s r� )�modulec
C s� t ||| ||dd|
|| |
� }tj� }|j|� |d dkrl|tjkrHt}| jf kr�| jj dkr�|| j
� �S n|tjk r�t j dt
dd� |d dkr�|d t| �8 < | jdkr�d S t| |||�S )
a�
Return a string representation of an array.
Parameters
----------
a : array_like
Input array.
max_line_width : int, optional
Inserts newlines if text is longer than `max_line_width`.
Defaults to ``numpy.get_printoptions()['linewidth']``.
precision : int or None, optional
Floating point precision.
Defaults to ``numpy.get_printoptions()['precision']``.
suppress_small : bool, optional
Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
Defaults to ``numpy.get_printoptions()['suppress']``.
separator : str, optional
Inserted between elements.
prefix : str, optional
suffix: str, optional
The length of the prefix and suffix strings are used to respectively
align and wrap the output. An array is typically printed as::
prefix + array2string(a) + suffix
The output is left-padded by the length of the prefix string, and
wrapping is forced at the column ``max_line_width - len(suffix)``.
It should be noted that the content of prefix and suffix strings are
not included in the output.
style : _NoValue, optional
Has no effect, do not use.
.. deprecated:: 1.14.0
formatter : dict of callables, optional
If not None, the keys should indicate the type(s) that the respective
formatting function applies to. Callables should return a string.
Types that are not specified (by their corresponding keys) are handled
by the default formatters. Individual types for which a formatter
can be set are:
- 'bool'
- 'int'
- 'timedelta' : a `numpy.timedelta64`
- 'datetime' : a `numpy.datetime64`
- 'float'
- 'longfloat' : 128-bit floats
- 'complexfloat'
- 'longcomplexfloat' : composed of two 128-bit floats
- 'void' : type `numpy.void`
- 'numpystr' : types `numpy.string_` and `numpy.unicode_`
- 'str' : all other strings
Other keys that can be used to set a group of types at once are:
- 'all' : sets all types
- 'int_kind' : sets 'int'
- 'float_kind' : sets 'float' and 'longfloat'
- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
- 'str_kind' : sets 'str' and 'numpystr'
threshold : int, optional
Total number of array elements which trigger summarization
rather than full repr.
Defaults to ``numpy.get_printoptions()['threshold']``.
edgeitems : int, optional
Number of array items in summary at beginning and end of
each dimension.
Defaults to ``numpy.get_printoptions()['edgeitems']``.
sign : string, either '-', '+', or ' ', optional
Controls printing of the sign of floating-point types. If '+', always
print the sign of positive values. If ' ', always prints a space
(whitespace character) in the sign position of positive values. If
'-', omit the sign character of positive values.
Defaults to ``numpy.get_printoptions()['sign']``.
floatmode : str, optional
Controls the interpretation of the `precision` option for
floating-point types.
Defaults to ``numpy.get_printoptions()['floatmode']``.
Can take the following values:
- 'fixed': Always print exactly `precision` fractional digits,
even if this would print more or fewer digits than
necessary to specify the value uniquely.
- 'unique': Print the minimum number of fractional digits necessary
to represent each value uniquely. Different elements may
have a different number of digits. The value of the
`precision` option is ignored.
- 'maxprec': Print at most `precision` fractional digits, but if
an element can be uniquely represented with fewer digits
only print it with that many.
- 'maxprec_equal': Print at most `precision` fractional digits,
but if every element in the array can be uniquely
represented with an equal number of fewer digits, use that
many digits for all elements.
legacy : string or `False`, optional
If set to the string `'1.13'` enables 1.13 legacy printing mode. This
approximates numpy 1.13 print output by including a space in the sign
position of floats and different behavior for 0d arrays. If set to
`False`, disables legacy mode. Unrecognized strings will be ignored
with a warning for forward compatibility.
.. versionadded:: 1.14.0
Returns
-------
array_str : str
String representation of the array.
Raises
------
TypeError
if a callable in `formatter` does not return a string.
See Also
--------
array_str, array_repr, set_printoptions, get_printoptions
Notes
-----
If a formatter is specified for a certain type, the `precision` keyword is
ignored for that type.
This is a very flexible function; `array_repr` and `array_str` are using
`array2string` internally so keywords with the same name should work
identically in all three functions.
Examples
--------
>>> x = np.array([1e-16,1,2,3])
>>> np.array2string(x, precision=2, separator=',',
... suppress_small=True)
'[0.,1.,2.,3.]'
>>> x = np.arange(3.)
>>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x})
'[0.00 1.00 2.00]'
>>> x = np.arange(3)
>>> np.array2string(x, formatter={'int':lambda x: hex(x)})
'[0x0 0x1 0x2]'
Nr8 z1.13zT'style' argument is deprecated and no longer functional except in 1.13 'legacy' moder' )rH r3 r
z[])rX r[ r^ r\ rT �_NoValuero rf r� r� �itemrN rO �DeprecationWarningrd r� r� )rh r� r1 r� r� r� r� r7 r/ r. r6 r0 r� r8 � overridesrV r9 r9 r= r s&
c C s\ t |�t |� |k}|dkr4| t |�t |�kr4d}|rL| |j� d 7 } |}||7 }| |fS )Nz1.13F�
)rd �rstrip)�s�line�word�
line_widthr� r8 Z
needs_wrapr9 r9 r= � _extendLine� s r� c s2 � ������fdd��z�f ||d�S d�X dS )zgformatArray is designed for two modes of operation:
1. Full output
2. Summarized output
c s� t | �}� j| }|dkr&�� | �S |d }�dkr<|}n |t d� }� j| }�o`d� |k }|rp�} �}
nd} |}
d} |dk�r��dkr�|t �j� � } n|tt �j� �t d�� } |}
x@t| �D ]4}�| |f ||�}t| |
|| |��\} }
|
�7 }
q�W |�r8t| |
�| |��\} }
�dk�r0|
d7 }
n|
�7 }
xHt|
dd
�D ]8}�| | f ||�}t| |
|| |��\} }
|
�7 }
�qFW �dk�r�|} �| d ||�}t| |
|| |��\} }
| |
7 } n�d} �j� d |d }x4t| �D ](}�| |f ||�}| || | 7 } �q�W |�r@�dk�r0| |� d
7 } n| |� | 7 } x:t|
dd�D ]*}�| | f ||�}| || | 7 } �qNW �| d ||�}| || 7 } d | t |�d � d } | S )z�
By using this local function, we don't need to recurse with all the
arguments. Since this function is not created recursively, the cost is
not significant
r
rF z1.13�]rb r� r z, r� z,
�[N���r� )r� r� r� )r� )rd re rf r� �max�ranger� )ri �hanging_indent�
curr_widthrc Z axes_leftZnext_hanging_indentZ
next_widthZa_lenZ show_summaryZ
leading_itemsZtrailing_itemsr� Z
elem_widthr� �ir� Zline_sep�nested)rh �
edge_itemsr� r8 �recurserr� r� r9 r= r� � sx
z _formatArray.<locals>.recurser)ri r� r� Nr9 )rh r� r� r� r� r� r� r8 r9 )rh r� r� r8 r� r� r� r= r� � s br� c C s& | d kr dS | dk r"t dj|���| S )Nr r
z{} must be >= 0r� )rL rB )rp �namer9 r9 r= �_none_or_positive_arg; s
r� c @ s0 e Zd ZdZd dd�dd�Zdd� Zd d
� ZdS ) rx z' Formatter for subtypes of np.floating FN)r8 c C s� t |t�r|rdnd}|| _| jdkr<|jf kr<|dkr<d}|| _|dkrRd | _n|| _t| jd�| _|| _|| _d| _ d| _
| j |� d S )NrE r- z1.13rF r@ r1 F) rP rK �_legacyrf r0 r1 r� r� r6 �
exp_formatZlarge_exponent�
fillFormat)r� ru r1 r0 r� r6 r8 r9 r9 r= �__init__D s
zFloatingFormat.__init__c s |t |� }t||dk �}t|�dkr|tj|�}tj|�}tdd��0 |dksl� j rr|dk sl|| dkrrd� _W d Q R X t|�dkr�d� _ d� _
d� _ d!� _ d� _
�n�� j�r�d"\��� jd
ksΈ jd kr�d#\��� ��fdd�|D �}tdd� |D �� \}}} tdd� |D �� \}
} tdd� | D ��d � _ d � _ tdd� | D ��� _� jd k�r`d� _ ntdd� |
D ��� _ � j d � j � _
d
� _
n�d$\��� jd
k�r�d%\��� ��fdd�|D �}tdd� |D �� \}
} � jd k�r�d tdd� |
D �� � _ ntdd� |
D ��� _ tdd� | D ��� _
d&� _ � jd'k�rL� j
� _d
� _
d � _ n d� _
d� _ � jd k�r�� jd k�r�ttj|�� �r�� j d 7 _ |j|jk�r�� jd k�p�t|t|� dk �} ttd �}
ttd �| }� j
d }t� j |
| || �� _ d S )(Nr
�ignore)Zoverg �חAg-C ��6?g @�@T�.r r? z1.13r; Fc 3 s( | ] }t |� j��� jd kd�V qdS )rE )r1 r@ �trimr6 N)r r1 r6 )r: rp )r� r� r@ r9 r= rD x s z,FloatingFormat.fillFormat.<locals>.<genexpr>c s s | ]}|j d �V qdS )�eN)� partition)r: r� r9 r9 r= rD { s c s s | ]}|j d �V qdS )r� N)�split)r: r� r9 r9 r= rD | s c s s | ]}t |�V qd S )N)rd )r: r� r9 r9 r= rD } s c s s | ]}t |�V qd S )N)rd )r: r� r9 r9 r= rD � s r' c s s | ]}t |�V qd S )N)rd )r: r� r9 r9 r= rD � s rb c 3 s* | ]"}t |� jd ��� jdkd�V qdS )TrE )r1 �
fractionalr@ r� r6 N)r r1 r6 )r: rp )r� r� r@ r9 r= rD � s c s s | ]}|j d �V qdS )r� N)r� )r: r� r9 r9 r= rD � s c s s | ]}t |jd ��V qdS )z-+N)rd �lstrip)r: r� r9 r9 r= rD � s c s s | ]}t |�V qd S )N)rd )r: r� r9 r9 r= rD � s c s s | ]}t |�V qd S )N)rd )r: r� r9 r9 r= rD � s rA rF r- r4 r5 r� )r� T)r; F)r� T)r; Fr� )r? rA )r r rd rT r� �minr r� r� �pad_left� pad_rightr� �exp_sizer@ r0 r� �zipr1 r6 r Zsignbitr� r r[ )r� ru Z finite_valsZ abs_non_zeroZmax_valZmin_val�strsZ frac_strs�_Zexp_strsZint_partZ frac_partZneginfZnanlenZinflen�offsetr9 )r� r� r@ r= r� _ sr
zFloatingFormat.fillFormatc C s� t j|�s�tdd��v t j|�r@| jdkr.dnd}|td }n*|dk rLdn| jdkrZdnd}|td }d | j| j d
t|� | S Q R X | j r�t
|| j | j | j
| jdk| j| jd �S t|| j | j d | j
| jdk| j| jd
�S d S )Nr� )�invalidrE r� r4 r
r- r5 rF r )r1 r@ r� r6 r� �
exp_digitsT)r1 r@ r� r� r6 r� r� )rT r r rU r6 r[ r� r� rd r� r r1 r@ r� r� r )r� rp r6 �retr9 r9 r= �__call__� s0
&
zFloatingFormat.__call__)F)�__name__�
__module__� __qualname__�__doc__r� r� r� r9 r9 r9 r= rx B s
Trx Tr; c C s4 t |d�}t |d�}t |d�}t| ||||||d�S )a�
Format a floating-point scalar as a decimal string in scientific notation.
Provides control over rounding, trimming and padding. Uses and assumes
IEEE unbiased rounding. Uses the "Dragon4" algorithm.
Parameters
----------
x : python float or numpy floating scalar
Value to format.
precision : non-negative integer or None, optional
Maximum number of digits to print. May be None if `unique` is
`True`, but must be an integer if unique is `False`.
unique : boolean, optional
If `True`, use a digit-generation strategy which gives the shortest
representation which uniquely identifies the floating-point number from
other values of the same type, by judicious rounding. If `precision`
was omitted, print all necessary digits, otherwise digit generation is
cut off after `precision` digits and the remaining value is rounded.
If `False`, digits are generated as if printing an infinite-precision
value and stopping after `precision` digits, rounding the remaining
value.
trim : one of 'k', '.', '0', '-', optional
Controls post-processing trimming of trailing digits, as follows:
* 'k' : keep trailing zeros, keep decimal point (no trimming)
* '.' : trim all trailing zeros, leave decimal point
* '0' : trim all but the zero before the decimal point. Insert the
zero if it is missing.
* '-' : trim trailing zeros and any trailing decimal point
sign : boolean, optional
Whether to show the sign for positive values.
pad_left : non-negative integer, optional
Pad the left side of the string with whitespace until at least that
many characters are to the left of the decimal point.
exp_digits : non-negative integer, optional
Pad the exponent with zeros until it contains at least this many digits.
If omitted, the exponent will be at least 2 digits.
Returns
-------
rep : string
The string representation of the floating point value
See Also
--------
format_float_positional
Examples
--------
>>> np.format_float_scientific(np.float32(np.pi))
'3.1415927e+00'
>>> s = np.float32(1.23e24)
>>> np.format_float_scientific(s, unique=False, precision=15)
'1.230000071797338e+24'
>>> np.format_float_scientific(s, exp_digits=4)
'1.23e+0024'
r1 r� r� )r1 r@ r� r6 r� r� )r� r )rp r1 r@ r� r6 r� r� r9 r9 r= r � s =
c
C s6 t |d�}t |d�}t |d�}t| |||||||d�S )a�
Format a floating-point scalar as a decimal string in positional notation.
Provides control over rounding, trimming and padding. Uses and assumes
IEEE unbiased rounding. Uses the "Dragon4" algorithm.
Parameters
----------
x : python float or numpy floating scalar
Value to format.
precision : non-negative integer or None, optional
Maximum number of digits to print. May be None if `unique` is
`True`, but must be an integer if unique is `False`.
unique : boolean, optional
If `True`, use a digit-generation strategy which gives the shortest
representation which uniquely identifies the floating-point number from
other values of the same type, by judicious rounding. If `precision`
was omitted, print out all necessary digits, otherwise digit generation
is cut off after `precision` digits and the remaining value is rounded.
If `False`, digits are generated as if printing an infinite-precision
value and stopping after `precision` digits, rounding the remaining
value.
fractional : boolean, optional
If `True`, the cutoff of `precision` digits refers to the total number
of digits after the decimal point, including leading zeros.
If `False`, `precision` refers to the total number of significant
digits, before or after the decimal point, ignoring leading zeros.
trim : one of 'k', '.', '0', '-', optional
Controls post-processing trimming of trailing digits, as follows:
* 'k' : keep trailing zeros, keep decimal point (no trimming)
* '.' : trim all trailing zeros, leave decimal point
* '0' : trim all but the zero before the decimal point. Insert the
zero if it is missing.
* '-' : trim trailing zeros and any trailing decimal point
sign : boolean, optional
Whether to show the sign for positive values.
pad_left : non-negative integer, optional
Pad the left side of the string with whitespace until at least that
many characters are to the left of the decimal point.
pad_right : non-negative integer, optional
Pad the right side of the string with whitespace until at least that
many characters are to the right of the decimal point.
Returns
-------
rep : string
The string representation of the floating point value
See Also
--------
format_float_scientific
Examples
--------
>>> np.format_float_positional(np.float32(np.pi))
'3.1415927'
>>> np.format_float_positional(np.float16(np.pi))
'3.14'
>>> np.format_float_positional(np.float16(0.3))
'0.3'
>>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
'0.3000488281'
r1 r� r� )r1 r@ r� r� r6 r� r� )r� r )rp r1 r@ r� r� r6 r� r� r9 r9 r= r s D
c @ s e Zd Zdd� Zdd� ZdS )rw c C sF |j dkr2ttttj|���tttj|����}nd}dj|�| _d S )Nr
z%{}d)r� r� rd rr rT r� rB )r� ru � max_str_lenr9 r9 r= r� d s
zIntegerFormat.__init__c C s
| j | S )N)rB )r� rp r9 r9 r= r� l s zIntegerFormat.__call__N)r� r� r� r� r� r9 r9 r9 r= rw c s rw c @ s e Zd Zdd� Zdd� ZdS )rt c K s |j f krdnd| _d S )Nz True�True)rf �truestr)r� ru r` r9 r9 r= r� q s zBoolFormat.__init__c C s |r
| j S dS )N�False)r� )r� rp r9 r9 r= r� v s zBoolFormat.__call__N)r� r� r� r� r� r9 r9 r9 r= rt p s rt c @ s( e Zd ZdZd dd�dd�Zdd� ZdS )
ry z. Formatter for subtypes of np.complexfloating FN)r8 c C sb t |t�r|rdnd}| }}|dkr.d}d}t|j|||||d�| _t|j|||d|d�| _d S )NrE r- z1.13rA r( )r6 r8 )rP rK rx �real� real_format�imag� imag_format) r� rp r1 r0 r� r6 r8 Zfloatmode_realZfloatmode_imagr9 r9 r= r� | s
z ComplexFloatingFormat.__init__c C sH | j |j�}| j|j�}t|j� �}|d |� d ||d � }|| S )N�j)r� r� r� r� rd r� )r� rp �rr� �spr9 r9 r= r� � s
z ComplexFloatingFormat.__call__)F)r� r� r� r� r� r� r9 r9 r9 r= ry z s ry c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�_TimelikeFormatc C s~ |t |� }t|�dkrFtt| jtj|���t| jtj|����}nd}t|�|jk rbt|d�}dj|�| _dj |�| _
d S )Nr
� z%{}sz'NaT') r rd r� �_format_non_natrT r� r� rB �_format�rjust�_nat)r� ru Znon_natr� r9 r9 r= r� � s
z_TimelikeFormat.__init__c C s t �d S )N)�NotImplementedError)r� rp r9 r9 r= r� � s z _TimelikeFormat._format_non_natc C s" t |�r| jS | j| j|� S d S )N)r r� r� r� )r� rp r9 r9 r= r� � s z_TimelikeFormat.__call__N)r� r� r� r� r� r� r9 r9 r9 r= r� � s r� c s2 e Zd Zd
� fdd� Z� fdd�Zdd � Z� ZS ) rz N� same_kindFc s` |d kr(|j jdkr$t|j �d }nd}|d kr4d}|| _|| _|| _|| _tt| �j |� d S )N�Mr
r� Znaive)
r� �kindr �timezone�unit�castingr8 �superrz r� )r� rp r� r� r� r8 )� __class__r9 r= r� � s zDatetimeFormat.__init__c s$ | j dkr| j|�S tt| �j|�S )Nz1.13)r8 r� r� rz r� )r� rp )r r9 r= r� � s
zDatetimeFormat.__call__c C s dt || j| j| jd� S )Nz'%s')r� r� r� )r r� r� r� )r� rp r9 r9 r= r� � s z DatetimeFormat._format_non_nat)NNr� F)r� r� r� r� r� r� �
__classcell__r9 r9 )r r= rz � s rz c @ s e Zd Zdd� ZdS )r{ c C s t |jd��S )N�i8)rr Zastype)r� rp r9 r9 r= r� � s z TimedeltaFormat._format_non_natN)r� r� r� r� r9 r9 r9 r= r{ � s r{ c @ s e Zd Zdd� Zdd� ZdS )�SubArrayFormatc C s
|| _ d S )N)r� )r� r� r9 r9 r= r� � s zSubArrayFormat.__init__c sJ |j dkr*ddj� fdd�|D �� d S ddj� fdd�|D �� d S )Nr r� z, c 3 s | ]}� j |�V qd S )N)r� )r: rh )r� r9 r= rD � s z*SubArrayFormat.__call__.<locals>.<genexpr>r� c 3 s | ]}� j |�V qd S )N)r� )r: rh )r� r9 r= rD � s )re rM )r� �arrr9 )r� r= r� � s
zSubArrayFormat.__call__N)r� r� r� r� r� r9 r9 r9 r= r � s r c @ s, e Zd ZdZdd� Zedd� �Zdd� ZdS ) r� z�
Formatter for structured np.void objects.
This does not work on structured alias types like np.dtype(('i4', 'i2,i2')),
as alias scalars lose their field information, and the implementation
relies upon np.void.__getitem__.
c C s
|| _ d S )N)�format_functions)r� r r9 r9 r= r� � s z StructuredVoidFormat.__init__c K sP g }xB|j jD ]6}t|| f|�}|j | jf kr:t|�}|j|� qW | |�S )z�
This is a second way to initialize StructuredVoidFormat, using the raw data
as input. Added to avoid changing the signature of __init__.
)r� r� r� rf r �append)�clsru rV r �
field_namer� r9 r9 r= r� � s z StructuredVoidFormat.from_datac C sD dd� t || j�D �}t|�dkr0dj|d �S djdj|��S d S )Nc S s g | ]\}}||��qS r9 r9 )r: �fieldr� r9 r9 r= r� � s z1StructuredVoidFormat.__call__.<locals>.<listcomp>r z({},)r
z({})z, )r� r rd rB rM )r� rp Z
str_fieldsr9 r9 r= r� � s
z StructuredVoidFormat.__call__N)r� r� r� r� r� � classmethodr� r� r9 r9 r9 r= r� � s r� c C s t jt| �ft�| �S )z�
Implements the repr for structured-void scalars. It is called from the
scalartypes.c.src code, and is placed here because it uses the elementwise
formatters defined above.
)r� r� r r[ )rp r9 r9 r= �_void_scalar_repr s r c C s< t j| �} td dkr$| jtkr$dS | jdk r2dS | jtkS )a
Determine if the given dtype is implied by the representation of its values.
Parameters
----------
dtype : dtype
Data type
Returns
-------
implied : bool
True if the dtype is implied by the representation of its values.
Examples
--------
>>> np.core.arrayprint.dtype_is_implied(int)
True
>>> np.array([1, 2, 3], int)
array([1, 2, 3])
>>> np.core.arrayprint.dtype_is_implied(np.int8)
False
>>> np.array([1, 2, 3], np.int8)
array([1, 2, 3], dtype=int8)
r8 z1.13FN)rT r� r[ rj r# r� �
_typelessdata)r� r9 r9 r= �dtype_is_implied s
r
c C sV | j dk rt| �S t| jt�r*dt| � S | j}|rR|d j� oF|j� rRt|�}|S )z�
Convert a dtype to a short form which evaluates to the same dtype.
The intent is roughly that the following holds
>>> from numpy import *
>>> dt = np.int64([1, 2]).dtype
>>> assert eval(dtype_short_repr(dt)) == dt
Nz'%s'r
) r� rr r� rj r$ r� �isalpha�isalnumro )r� �typenamer9 r9 r= �dtype_short_repr< s
r c C sf |dkrt d }t| �tk r(t| �j}nd}t| j�o>| jdk}|d }|rPdnd}t d d kr�| jf kr�| jj r�t | j
� �} n<| jdks�| jdkr�|| |||d
||d �} nd t | j�f } || | }
|r�|
S d
j t | j��} t
|
�|
jd�d } d}
t d d k�r0t| jjt��rZddt
|d � }
n*| t
| � d |k�rZddt
|d � }
|
|
| S )zEInternal version of array_repr() that allows overriding array2string.Nr3 r r
�(�)�,r8 z1.13z, )r� z [], shape=%sz dtype={})r� r rF )r
)r[ rj r r� r
r� r� rf r� ro r� rB r rd �rfindr� r$ )r r� r1 r� r �
class_nameZ skipdtyper� r� r� Zarr_strZ dtype_strZ
last_line_lenZspacerr9 r9 r= �_array_repr_implementationU s6
r c C s | fS )Nr9 )r r� r1 r� r9 r9 r= �_array_repr_dispatcher� s r c C s t | |||�S )a
Return the string representation of an array.
Parameters
----------
arr : ndarray
Input array.
max_line_width : int, optional
Inserts newlines if text is longer than `max_line_width`.
Defaults to ``numpy.get_printoptions()['linewidth']``.
precision : int, optional
Floating point precision.
Defaults to ``numpy.get_printoptions()['precision']``.
suppress_small : bool, optional
Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
Defaults to ``numpy.get_printoptions()['suppress']``.
Returns
-------
string : str
The string representation of an array.
See Also
--------
array_str, array2string, set_printoptions
Examples
--------
>>> np.array_repr(np.array([1,2]))
'array([1, 2])'
>>> np.array_repr(np.ma.array([0.]))
'MaskedArray([0.])'
>>> np.array_repr(np.array([], np.int32))
'array([], dtype=int32)'
>>> x = np.array([1e-6, 4e-7, 2, 3])
>>> np.array_repr(x, precision=6, suppress_small=True)
'array([0.000001, 0. , 2. , 3. ])'
)r )r r� r1 r� r9 r9 r= r � s -c C s t | t�rt| �S t| �S )N)rP �bytesro rr )r< r9 r9 r= �_guarded_repr_or_str� s
r c C sZ t d dkr,| jf kr,| jj r,t| j� �S | jf krHttjj | f ��S || |||dd�S )zDInternal version of array_str() that allows overriding array2string.r8 z1.13rF r� )
r[ rf r� r� rr r� r rT r � __getitem__)rh r� r1 r� r r9 r9 r= �_array_str_implementation� s
r c C s | fS )Nr9 )rh r� r1 r� r9 r9 r= �_array_str_dispatcher� s r c C s t | |||�S )aa
Return a string representation of the data in an array.
The data in the array is returned as a single string. This function is
similar to `array_repr`, the difference being that `array_repr` also
returns information on the kind of array and its data type.
Parameters
----------
a : ndarray
Input array.
max_line_width : int, optional
Inserts newlines if text is longer than `max_line_width`.
Defaults to ``numpy.get_printoptions()['linewidth']``.
precision : int, optional
Floating point precision.
Defaults to ``numpy.get_printoptions()['precision']``.
suppress_small : bool, optional
Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
Defaults to ``numpy.get_printoptions()['suppress']``.
See Also
--------
array2string, array_repr, set_printoptions
Examples
--------
>>> np.array_str(np.arange(3))
'[0 1 2]'
)r )rh r� r1 r� r9 r9 r= r � s $� __wrapped__)r c C s6 | dkr&|rt jtd�S t jtd�S n t j| |�S dS )a�
Set a Python function to be used when pretty printing arrays.
Parameters
----------
f : function or None
Function to be used to pretty print arrays. The function should expect
a single array argument and return a string of the representation of
the array. If None, the function is reset to the default NumPy function
to print arrays.
repr : bool, optional
If True (default), the function for pretty printing (``__repr__``)
is set, if False the function that returns the default string
representation (``__str__``) is set.
See Also
--------
set_printoptions, get_printoptions
Examples
--------
>>> def pprint(arr):
... return 'HA! - What are you going to do now?'
...
>>> np.set_string_function(pprint)
>>> a = np.arange(10)
>>> a
HA! - What are you going to do now?
>>> _ = a
>>> # [0 1 2 3 4 5 6 7 8 9]
We can reset the function to the default:
>>> np.set_string_function(None)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
`repr` affects either pretty printing or normal string representation.
Note that ``__repr__`` is still affected by setting ``__str__``
because the width of each array element in the returned string becomes
equal to the length of the result of ``__str__()``.
>>> x = np.arange(4)
>>> np.set_string_function(lambda x:'random', repr=False)
>>> x.__str__()
'random'
>>> x.__repr__()
'array([0, 1, 2, 3])'
Nr r
)r r �_default_array_repr�_default_array_str)r� ro r9 r9 r= r
s
3 ) NNNNNNNNNNN)
NNNNNNNNNN)r� )rF r� ) NNNNNNNNNNNN)NTr; FNN)NTTr; FNN)NNN)NNN)NNN)NNN)T)`r� �__all__Z
__docformat__r� rQ �_threadr � ImportError�
_dummy_threadrY rT r� r
r� Zumathr r r r r r r r r r r r Z fromnumericr �numericr r r r r r r! r" r# r$ r� r% r& rN �
contextlibr[ rX r r �contextmanagerr rg rn rq rs r� r� r� r� r� r� r r� r� r� rx r r rw rt ry r� rz r{ r r� r r r� r| r r
r r r r r r r r �getattrZ_array2string_impl�partialr r r r9 r9 r9 r= �<module> s� $ $
& " 3'
/v C J
!
$
$ .
0
(
;
|