LK
h d Z g dZdZddlZddlZddlZ ddlmZ n# e$ r ddl mZ Y nw xY wddl
Z ddl m
Z ddlmZmZmZmZ dd l mZ dd
lmZmZmZmZmZmZmZ dd l m Z dd l m Z m Z m!Z! dd
l
m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( ddl)m*Z*m+Z+ ddl,Z,ddl-Z-ddl.Z.ddddddddddej/ d Z0 dVdZ1 e+d dWddd Z2 e+d d Z3d Z4 e+d e.j5 d Z6dXd!Z7d" Z8d# Z9d$ Z:d% Z;d& Z d[ddd,Z? e*e?d- dddd)d*e j@ dddddd*f ddd. ZAd/ ZBd0 ZCd1 ZDd2 ZE G d3 d4 ZF e+d d\d7 ZG e+d d]d8 ZH G d9 d: ZI G d; d< ZJ G d= d> ZK G d? d@ ZL G dA dBeL ZM G dC dDeL ZN G dE dF ZO G dG dH ZPdI ZQe$e%e&e'gZRdJ ZSdK ZTdddeAfdLZU d^dMZV e*eVd- d^dN ZW e= dO ZXdddeAfdPZY d^dQZZ e*eZd- d^dR Z[ e\eAdSeA Z] ej^ eYe]T Z_ ej^ eUe]T Z`d_dUZadS )`zXArray printing function
$Id: arrayprint.py,v 1.9 2005/09/13 13:58:44 teoliphant Exp $
) array2string array_str
array_reprset_string_functionset_printoptionsget_printoptions printoptionsformat_float_positionalformat_float_scientificrestructuredtext N) get_ident ) numerictypes)absoluteisinfisfiniteisnat)
multiarray)arraydragon4_positionaldragon4_scientificdatetime_as_string
datetime_datandarrayset_legacy_print_mode)any) concatenateasarrayerrstate)longlongintcint_float_complex_bool_flexible)array_function_dispatch
set_module i maxprec FK naninf-) edgeitems threshold floatmode precisionsuppress linewidthnanstrinfstrsign formatterlegacyc d t D } |t | | d< g d} | | dgz vr/t dd d | D z |dvrt d |
d
k rt
j | d < n1|
d k rd
| d < n%|
dk rd| d < n|
nt j dd |Lt |t j st d t j | rt d | ; t j | | d< n"# t $ r}
t d |
d}
~
ww xY w| S )zm
Make a dictionary out of the non-None arguments, plus conversion of
*legacy* and sanity checks.
c i | ]
\ }}||| S N ).0kvs i/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib64/python3.11/site-packages/numpy/core/arrayprint.py
z&_make_options_dict..H s BBB1AMq!MMM Nr4 )fixeduniquer*
maxprec_equalz floatmode option must be one of , c 3 @ K | ]}d | V dS )z"{}"Nformat)r? ms rB z%_make_options_dict..P s. "C"C6==#3#3"C"C"C"C"C"CrD )Nr/ + z+sign option must be one of ' ', '+', or '-'Fr: 1.13q 1.21y zGlegacy printing option can currently only be '1.13', '1.21', or `False`r)
stacklevelzthreshold must be numericzIthreshold must be non-NAN, try sys.maxsize for untruncated representationr3 z precision must be an integer)localsitemsbool
ValueErrorjoinsysmaxsizewarningswarn
isinstancenumbersNumber TypeErrornpisnanoperatorindex)r3 r1 r0 r5 r4 r6 r7 r8 r9 r2 r: optionsmodeses rB _make_options_dictrj @ s CB 0 0BBBG "8nn
; ; ;E&&; "C"CU"C"C"CCCD E E E (((FGGG
K 6 6
"# % % % % )W^44 9 788 8
8I K J K K
K C#+>)#<# 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.bytes_` and `numpy.str_`
- 'object' : `np.object_` arrays
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 '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. This also
enables 1.21 legacy printing mode (described below).
If set to the string `'1.21'` enables 1.21 legacy printing mode. This
approximates numpy 1.21 print output of complex structured dtypes
by not inserting spaces after commas that separate fields and after
colons.
If set to `False`, disables legacy mode.
Unrecognized strings will be ignored with a warning for forward
compatibility.
.. versionadded:: 1.14.0
.. versionchanged:: 1.22.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. ])
r9 r: rQ r/ r8 rS r N)rj _format_optionsupdater r[ r\ ) r3 r1 r0 r5 r4 r6 r7 r9 r8 r2 r: opts rB r r t s B Y 9i %vvtY & 0 0C !C 3 x C'' c""""% "c ) ) c""""" "ck 1 1 a
2 1rD c z t } ddddt j di| d | d< | 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
rQ rP rS rR Fr: )rn copyr[ r\ )optss rB r r ' sB 6 ! !D VS&#+u
8nDN KrD c t d S )z'Return the legacy print mode as an int.r: )rn r> rD rB _get_legacy_print_moderu I s
8 $$rD c / K t j } t j | i | t j V t j di | dS # t j di | w xY w)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
Nr> )rc r r )argskwargsrs s rB r r N s 6 D$
T,V,,,!#####
##d#######d####s &A A#r> c r t | }|| j k r| | S | j | d|z k r\t t | ||t
j d| z t | ||t
j | d z f| S t | ||t
j dd z S )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)lenndimshaper _leading_trailingrc index_exp)ar0 rf r{ s rB r r q s u::D qv~~xwt}q{"" aEBL*9*4M,M N N aEBL)4M,M N N
!Iur|AAA/FGGGrD c b t | t u rd}nd}| | S )z@ Object arrays containing lists should be printed unambiguously z
list({!r})z{!r})typelistrK )ofmts rB _object_formatr s- Aww$ ::a==rD c t | S r= )reprxs rB repr_formatr s
77NrD c t | S r= )strr s rB
str_formatr s
q66MrD c t fd fd fd fd fd fd fd fdd d
d d }d
} fd D }
d|
v r+| D ]} | d || < d|
v rdD ]} | d || < d|
v rdD ]} | d || < d|
v rdD ]} | d || < d|
v r | d |d< | D ]} | |
v r | | || < |S )Nc " t S r= )
BoolFormatdatas rB z!_get_formatdict.. s
4(( rD c " t S r= )
IntegerFormatr s rB r z!_get_formatdict.. s }T** rD c . t S Nrl FloatingFormatr r2 r: r3 r8 r4 s rB r z!_get_formatdict.. s& )Y$vG G G rD c . t S r r r s rB r z!_get_formatdict.. s& ^ )Y$v G G G rD c . t S r ComplexFloatingFormatr s rB r z!_get_formatdict.. s' 5 )Y$v!G !G !G rD c . t S r r r s rB r z!_get_formatdict.. s' $9 )Y$v%G %G %G rD c & t S r )DatetimeFormat)r r: s rB r z!_get_formatdict.. s N4 ? ? ? rD c " t S r= )TimedeltaFormatr s rB r z!_get_formatdict.. s _T 2 2 rD c t S r= )r r> rD rB r z!_get_formatdict.. s . rD c t S r= )r r> rD rB r z!_get_formatdict.. s
rD c t S r= )r r> rD rB r z!_get_formatdict.. s K rD ) rX intfloat longfloat complexfloatlongcomplexfloatdatetime timedeltaobjectvoidnumpystrc fdS )Nc S r= r> r s rB r z3_get_formatdict..indirect.. s q rD r> r s `rB indirectz!_get_formatdict..indirect s yyyrD c $ g | ] }|
|
S r= r> )r? r@ r9 s rB
z#_get_formatdict.. s" IIIq ! 0H0H0H0HrD allint_kind)r
float_kind)r r complex_kind)r r str_kindr )keys) r r3 r2 r4 r8 r: r9 rx
formatdictr fkeyskeys ``````` rB _get_formatdictr s )(((****G G G G G G G G GG G G G G G G G GG G G G G G G G G G G G G G G G G G?????2222((""'' ) )J& IIIIINN , ,III E>>!((
=
="*(9U+;"<"<
3
B
B"*(9Z+@"A"A
3 5 -
D
D"*(9\+B"C"C
3 U " ";
F
F"*(9^+D"E"E
3 %-Xi
.C%D%DJz " ??$$ ; ;Ce||"*(9S>":":
3 rD c b | j }|j }t | fi |}| |d S t |t j r |d S t |t j r:t |t j r |d S |d S t |t j r:t |t j r |d S |d S t |t j
r:t |t j r |d S |d S t |t j t j
f r |d S t |t j r |d
S t |t j r |d S t |t j r)|j t% j | fi |S |d S |d S )
z;
find the right formatting function for the dtype_
Nr rX r r r r r r r r r )dtyper r
issubclass_ntr% integer timedelta64floatingr complexfloating
clongfloatstr_bytes_
datetime64object_r namesStructuredVoidFormat from_data)r rg dtype_dtypeobjr s rB _get_format_functionr s* ZF{H 1111J%z*%''' Hci ( ( (!z&!### Hck * * ( h 0 0 '*:k*,, ,$:e$&& & Hcl + + ( h
. . )*:k*,, ,&:g&(( ( Hc 1 2 2 ( h / / 01: 0133 3-:n-// / Hsx 4 5 5 (%z*%''' Hcn - -
(%z*%''' Hck * * (#z(#%%% Hch ' ' ( < #'1$BB'BB B%:f%'' '%z*%'''rD ...c fd}|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 j t t j fd }|S )Nc t | t f}|v rS | | g|R i | | S # | w xY wr= )idr
adddiscard)selfrw rx r f fillvalue repr_runnings rB wrapperz>_recursive_guard..decorating_function..wrapper s T((IKK'Cl"" S ! ! !
*q////// $$S)))) $$S))))s A A3)set functoolswraps)r r r r s ` @rB decorating_functionz-_recursive_guard..decorating_function sM uu * * * * * *
* rD r> )r r s ` rB _recursive_guardr s$ rD rO c . t | }| j dk r|} | j |d k rd}t ||d }nd}t |fi |}d}|dt | z z
}t
| ||d |||d ||d }|S ) Nr> r1 r r0 r rO r5 r: )r r~ sizer r r| _formatArray) r rg separatorprefixr summary_insertformat_functionnext_line_prefixlsts rB
_array2stringr s
1::Dw"}} v $$$ w{';<< +4;;7;;O CKK'
q/7;+?'GK4H%wx'8 : :C JrD c
| fS r= r> )r max_line_widthr3 suppress_smallr r styler9 r1 r0 r8 r2 suffixr: s rB _array2string_dispatcherr ( s
4KrD )modulec
t ||| ||dd|
|| |
}t }| | |d dk rJ|t j u rt }| j dk r)| j j ||
S n*|t j ur t j dt d |d dk r |dxx t | z cc< | j d k rd
S t! | ||| S ) a
Return a string representation of an array.
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 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.bytes_` and `numpy.str_`
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 '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]'
Nr: rQ r> zT'style' argument is deprecated and no longer functional except in 1.13 'legacy' moderz rT r5 r z[])rj rn rr ro rc _NoValuer r~ r r itemr] r^ DeprecationWarningr| r r )r r r3 r r r r r9 r1 r0 r8 r2 r r: overridesrg s rB r r 1 s* l #9i#1>4#'IvG GI ""$$G NN9 xC BK E 7b==QW] 25?? " bk ! !
6(Q 8 8 8 8 x3 F + v{{t GY 7 77rD c t | t | z |k }|dk r"t | t | k rd}|r | | dz z
} |}||z
}| |fS )NrQ F
)r| rstrip)slineword
line_widthr r:
needs_wraps rB _extendLiner s{ TSYY&3J
|| t99 ,-- - - J T[[]]T
!! DLD d7NrD c L | }t | dk s|dk rt | ||||| S t d |D }t | |z |k rHt | t | k r(| | dz z
} ||d z }|}n t | dz }||d z
}|dd D ]!}| | dz z
} ||z }"|t |d z
} || dz z
}| |fS ) zS
Extends line with nicely formatted (possibly multi-line) string ``word``.
r rQ c 3 4 K | ]}t | V d S r= r| )r? r s rB rM z%_extendLine_pretty.. s( 66#d))666666rD r r rO N)
splitlinesr| r maxr )
r r r r r r: wordsmax_word_lengthindent
suffix_lengths
rB _extendLine_prettyr s=
OO E
5zzQ&C--1dD*6FOOO6666666O D O#j00 II ,-- - - T[[]]T
!! %(*!T3 aacc
T[[]]T
!!}#c%)nn4MM# D d7NrD c V fd d|| dS # dw xY w)zgformatArray is designed for two modes of operation:
1. Full output
2. Summarized output
c < t | }j |z
}|dk r | S |dz }dk r|}n|t d z
}j | }odz |k }|r} }
nd} |}
d} |dk rLdk r%|t z
} n?|t t t d z
} |}
t | D ]/} | |fz || }t
| |
|| | \ } }
|
z
}
0|r(t | |
| | \ } }
dk r|
dz
}
n|
z
}
t |
dd D ]0} | | fz || }t
| |
|| | \ } }
|
z
}
1dk r|} | d
z || }t
| |
|| | \ } }
| |
z
} nd} d |dz
z z }t | D ] } | |fz || }| ||z |z z
} |r dk r | |z d z z
} n | |z |z z
} t |
dd D ] } | | fz || }| ||z |z z
} | d
z || }| ||z z
} d
| t | d z dz } | 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 rO rQ ]rz r r rH r )r r z,
[N)r| r} r~ r r ranger r )rf hanging_indent
curr_widthr{ axes_leftnext_hanging_indent
next_widtha_len show_summary
leading_itemstrailing_itemsr
elem_widthr ir line_sepnestedr
edge_itemsr r: recurserr r s rB r$ z _formatArray..recurser s 5zzFTM >>"?1U8,, , -s 2 S==#JJ#c#hh.J
%>!J,*> # &M 'NN M "N
>>}} '#i.>.>.@.@*A*A A
'#c)2B2B2D2D.E.Es3xx*P*P P
!D=))
"
" x .A:NN,tT:~vG G4 !
&%t^Z Q Q4S==DLDDI%D>1b11
"
" x!
/BJOO,tT:~vG G4 !}} '
8EEM+>
KKD(4z>6C CGAt
IAA A ''))D)a-,@@H=))
8
8!%1$,0CZPP^f,x77
DS== .86AAAA .88CCA>1b11
8
8!%A2%-1D",. .^f,x77 Xeem-@*MMF
&( (A
!C''(() )C /rD r> )rf r r Nr> ) r r r r r r# r r: r$ s `` ````@rB r r s ` ` ` ` ` ` ` ` ` ` `D xb'7#-/ / / 4s
$ (c ^ | dS | dk r"t d | | S )Nr r z{} must be >= 0)rY rK )r names rB _none_or_positive_argr' s7 yr1uu*11$77888 HrD c , e Zd ZdZddddZd Zd ZdS ) r z' Formatter for subtypes of np.floating FNrl c T t |t r|rdnd}|| _ | j dk r|j dk r|dk rd}|| _ |dk rd | _ n|| _ t
| j d | _ || _ || _ d| _ d| _
| | d S ) NrN r/ rQ r> rO rF r3 F) r_ rX _legacyr~ r2 r3 r' r r8
exp_formatlarge_exponent
fillFormat)r r r3 r2 r r8 r: s rB __init__zFloatingFormat.__init__ s dD ! ! ( '33CD <3 zR DCKK" !DNN &DN.t~{KK , # rD c |t | }t ||dk }t | dk rst j | }t j | }t
d 5 |dk s j s|dk s ||z dk rd _ d d d n # 1 swxY w Y t | dk r,d _ d _
d _ d _ d _
d _ n j rd
\ j d k s j d k rd
\ fd|D }t# d |D \ }}} t# d |D \ }
} t d | D dz
_ d _ t d | D _ j _ _
j d k rd _ n t d |
D _ j dz j z _
nd
\ j d k rd
\ fd|D }t# d |D \ }
} j d k r"dt d |
D z _ n t d |
D _ t d | D _
d _ _
j d v r j
x _ _ d _ nd _ d _ j d k r< j d k r1t) t j | s xj dz
c_ |j |j k r j d k p%t) |t/ | dk } t t0 d }
t t0 d! | z } j
dz }t j |
|z
||z
_ d S d S )"Nr ignore)overg חAg-C 6?g @@T.r )r2 TrE rQ )r@ Fc 3 \ K | ]&}t |j j d k V 'dS )rN )r3 rF trimr8 N)r r3 r8 r? r r r4 rF s rB rM z,FloatingFormat.fillFormat.. s] * * 'qDN&,4di3>NP P P * * * * * *rD c 3 @ K | ]}| d V dS )ri N) partitionr? r s rB rM z,FloatingFormat.fillFormat.. s. *J*J1;;s+;+;*J*J*J*J*J*JrD c 3 @ K | ]}| d V dS r2 Nsplitr8 s rB rM z,FloatingFormat.fillFormat.. s, 'H'H 'H'H'H'H'H'HrD c 3 4 K | ]}t | V d S r= r r8 s rB rM z,FloatingFormat.fillFormat.. s( 9 91A 9 9 9 9 9 9rD r r@ c 3 4 K | ]}t | V d S r= r r8 s rB rM z,FloatingFormat.fillFormat.. ( ; ;AQ ; ; ; ; ; ;rD r) c 3 4 K | ]}t | V d S r= r r8 s rB rM z,FloatingFormat.fillFormat.. ( #=#=qCFF#=#=#=#=#=#=rD rz c
3 ^ K | ]'}t |j d j dk V (dS )TrN )r3
fractionalrF r4 r8 N)r r3 r8 r5 s rB rM z,FloatingFormat.fillFormat.. s` * * 'qDN26.44,0I,<> > > * * * * * *rD c 3 @ K | ]}| d V dS r: r; r8 s rB rM z,FloatingFormat.fillFormat.. s, 'C'C 'C'C'C'C'C'CrD c 3 Z K | ]&}t | d V 'dS )z-+N)r| lstripr8 s rB rM z,FloatingFormat.fillFormat.. s4 'N'NAHHTNN(;(;'N'N'N'N'N'NrD c 3 4 K | ]}t | V d S r= r r8 s rB rM z,FloatingFormat.fillFormat.. rA rD c 3 4 K | ]}t | V d S r= r r8 s rB rM z,FloatingFormat.fillFormat.. r? rD )rE rG rO r/ r6 r7 )r r r| rc r minr r r+ pad_left pad_rightr4 exp_sizerF
min_digitsr2 r* zipr3 r8 r signbitr r rn )r r finite_vals abs_non_zeromax_valmin_valstrs frac_strs_exp_strsint_part frac_partneginfnanleninflenoffsetr4 rF s ` @@rB r- zFloatingFormat.fillFormat s 8D>>* K1,< =>> | ! !f\**Gf\**Gx(((
+
+d??4+>? 6))WW_u-D-D&*DO
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ { q DM DNDI DM DK "DOO
_ / $$LD&~((DLC,?,? ) f* * * * * * (* * *D &)*J*JT*J*J*J%K "Iq("%'H'Hi'H'H'H"I Hi 9 9 9 9 9 9 9A =DMDI ; ; ; ; ; ; ;DN "nDO DK |s"" !
!$#=#=H#=#=#= = =
!]Q . ?DNN$LD&~(( ) f* * * * * * ) * * *D
#&'C'Cd'C'C'C"D Hi|s"" !C'N'NX'N'N'N$N$N N
##=#=H#=#=#= = =
; ; ; ; ; ; ;DN DM DK~!;;;37>A "# <# yC BJ{,C,C(D(D
"
9 ( ( (Y#%CT%++->-B)C)CF 233F 233ft || j | j | j
| j | j dk | j | j S t! || j | j | j
d | j | j dk | j | j
S )Nr0 )invalidrN r r6 r r/ r7 rO r )r3 rM rF r4 r8 rJ
exp_digitsT)r3 rM rF rC r4 r8 rJ rK )rc r r rd r8 rn rJ rK r| r+ r r3 rM rF r4 rL r )r r r8 rets rB __call__zFloatingFormat.__call__ s {1~~ Q(+++
Q
Q8A;; ;"&)s"2"233D !::CC"#a%%33DI4D4DSS"D !::CDMDN :Q >S IJSP
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q ? @%a0415 -1[+/9+/9+;/3}15 @ @ @
@ &a0415 -1[15+/9+/9+;/3}04@ @ @
@s BB55B9<B9F)__name__
__module__ __qualname____doc__r. r- rb r> rD rB r r se 11 6RQ RQ RQh @ @ @ @ @rD r Tr@ c
t |d }t |d }t |d }t |d }|dk r|dk r||k rt d t | ||||||| 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`
is given fewer digits than necessary can be printed. If `min_digits`
is given more can be printed, in which cases the last digit is rounded
with unbiased rounding.
If `False`, digits are generated as if printing an infinite-precision
value and stopping after `precision` digits, rounding the remaining
value with unbiased rounding
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.
min_digits : non-negative integer or None, optional
Minimum number of digits to print. This only has an effect for
`unique=True`. In that case more digits than necessary to uniquely
identify the value may be printed and rounded unbiased.
-- versionadded:: 1.21.0
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'
r3 rJ r` rM r 2min_digits must be less than or equal to precision)r3 rF r4 r8 rJ r` rM )r' rY r )r r3 rF r4 r8 rJ r` rM s rB r
r
s J &i==I$Xz::H&z<@@J&z<@@JA~~)a--J,B,BMNNN a9V#'dX)3
L L L LrD c " t |d }t |d }t |d }t |d }|s|dk rt d |dk r|dk r||k rt d t | |||||||| 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`
is given fewer digits than necessary can be printed, or if `min_digits`
is given more can be printed, in which cases the last digit is rounded
with unbiased rounding.
If `False`, digits are generated as if printing an infinite-precision
value and stopping after `precision` digits, rounding the remaining
value with unbiased rounding
fractional : boolean, optional
If `True`, the cutoffs of `precision` and `min_digits` refer to the
total number of digits after the decimal point, including leading
zeros.
If `False`, `precision` and `min_digits` refer 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.
min_digits : non-negative integer or None, optional
Minimum number of digits to print. Only has an effect if `unique=True`
in which case additional digits past those necessary to uniquely
identify the value may be printed, rounding the last additional digit.
-- versionadded:: 1.21.0
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'
r3 rJ rK rM r z4precision must be greater than 0 if fractional=Falseri )r3 rF rC r4 r8 rJ rK rM )r' rY r ) r r3 rF rC r4 r8 rJ rK rM s rB r r j s Z &i==I$Xz::H%i==I&z<@@J -)q.. , - - -A~~)a--J,B,BMNNN a9V)3$#'((1j J J J JrD c e Zd Zd Zd ZdS )r c
& |j dk rit t t t j | t t t j | }nd}d | | _ d S )Nr z%{}d)r r r| r rc rI rK )r r max_str_lens rB r. zIntegerFormat.__init__ sq 9q== c#bfTll"3"3 4 4 !#bfTll"3"3 4 46 6KK K mmK00 rD c | j |z S r= rJ r r s rB rb zIntegerFormat.__call__ s {Q rD Nrd re rf r. rb r> rD rB r r s2 1 1 1 rD r c e Zd Zd Zd ZdS )r c . |j dk rdnd| _ d S )Nr> z TrueTrue)r~ truestr)r r rx s rB r. zBoolFormat.__init__ s #'*"2"2ww rD c |r| j ndS )NFalse)rt ro s rB rb zBoolFormat.__call__ s -t||g-rD Nrp r> rD rB r r s2 ? ? ?
. . . . .rD r c ( e Zd ZdZ ddddZd ZdS )r z. Formatter for subtypes of np.complexfloating FNrl c t |t r|rdnd}|x}}|dk rd}d}t |j ||||| | _ t |j |||d| | _ d S )NrN r/ rQ rG r* )r8 r: )r_ rX r real real_formatimag imag_format) r r r3 r2 r r8 r: floatmode_realfloatmode_imags rB r. z ComplexFloatingFormat.__init__ s dD ! ! ( '33CD*33 S== ,N &N)
FI~~f
*
FI~~V
rD c | |j }| |j }t | }|d | dz ||d z }||z S )Nj)rz ry r| r{ r| r )r r rr sps rB rb z ComplexFloatingFormat.__call__ sh QV $ $ QV $ $ __
crcFSL1RSS6 !1u rD rc )rd re rf rg r. rb r> rD rB r r sM 88
'+
( rD r c e Zd Zd Zd Zd ZdS )_TimelikeFormatc
|t | }t | dk rut t | t j | t | t j | }nd}t | |j k rt |d }d | | _ d | | _
d S )Nr z%{}sz'NaT') r r| r _format_non_natrc rI r rK _formatrjust_nat)r r non_natrm s rB r. z_TimelikeFormat.__init__ s d |$ w< rD rB r r sA / / / " " ": : : : :rD r c 4 e Zd Z d fd Z fdZd Z xZS )r N same_kindFc |-|j j dk rt |j d }nd}|d}|| _ || _ || _ || _ t | d S )NMr r naive) r kindr timezoneunitcastingr: superr. )r r r r r r: __class__s rB r. zDatetimeFormat.__init__ s{ <w|s""$QW--a0 H
rD c | j dk r| | S t | S )NrQ )r: r r rb )r r r s rB rb zDatetimeFormat.__call__, s< ;# ''** *ww """rD c L dt || j | j | j z S )N'%s')r r r )r r r r ro s rB r z DatetimeFormat._format_non_nat1 s2 *1)--1],0L: : : : :rD )NNr F)rd re rf r. rb r
__classcell__)r s @rB r r sk >"""rD N)rd re rf r r> rD rB r r 8 s# # # # # #rD r c e Zd Zd Zd Zd ZdS )SubArrayFormatc H || _ |d | _ |d | _ d S )Nr1 r0 )r r1 r# )r r rg s rB r. zSubArrayFormat.__init__> s& . -!+.rD c ^ |j | j k rdnd| _ | | S )Nr r )r r1 r format_array)r r s rB rb zSubArrayFormat.__call__C s0 '(v'>'>eeB ###rD c t t j | dk r | S j r[|j d d j z k rB fd|d j D j gz fd| j d D z }n fd|D }dd | z dz S ) Nr rz c : g | ]} | S r> r r? a_r s rB r z/SubArrayFormat.format_array..M s' EEE2""2&&EEErD c : g | ]} | S r> r r s rB r z/SubArrayFormat.format_array..O s' HHHR4$$R((HHHrD c : g | ]} | S r> r r s rB r z/SubArrayFormat.format_array..R s' ;;;2**2..;;;rD r rH r )rc r} r r r~ r# rZ )r r formatteds ` rB r zSubArrayFormat.format_arrayG s
71::??''** * <171:$/0A#A#AEEEE3CDO3C1DEEE&'(HHHH1do5E5F5F3GHHHI
I <;;;;;;ITYYy)))C//rD N)rd re rf r. rb r r> rD rB r r = sA / / /
$ $ $
0
0
0
0
0rD r c 4 e Zd ZdZd Zed Zd 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 || _ d S r= )format_functions)r r s rB r. z StructuredVoidFormat.__init___ s 0 rD c g }|j j D ]M}t || fi |}|j | j dk r
t |fi |}| | N | | 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 r r~ r append)clsr rg r
field_namer s rB r z StructuredVoidFormat.from_datab s ** 5 5J 24
3C O Ow O OOz*%+r11"0 "L"LG"L"L # #O 4 4 4 4s#$$$rD c d t || j D }t | dk rd |d S d d | S )Nc * g | ]\ }} || S r> r> )r? fieldr s rB r z1StructuredVoidFormat.__call__..q s6
&
OE " "
rD r z({},)r z({})rH )rN r r| rK rZ )r r
str_fieldss rB rb z StructuredVoidFormat.__call__p st
*-a1F*G*G
z??a >>*Q-00 0==:!6!677 7rD N)rd re rf rg r. classmethodr rb r> rD rB r r W sW 1 1 1 % % [ %8 8 8 8 8rD r c \ t j t | fi t | 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 rn r s rB _void_scalar_reprr { s/ G )%(( F Fo F Fq I IIrD c t j | } t d dk r| j t k rdS | j dS | j sdS | j t v S )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)
r: rQ F)rc r rn r r% r isnative
_typelessdata)r s rB dtype_is_impliedr s_ 2
HUOOEx C''EJ%,?,?u
{ u > u : &&rD c t | j t j j k rt | S | j t
| S t | j t rdt
| z S | j }| j
sdt
| z S |r=|d r| st | }|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
Nr r )
r __repr__rc r r r r r r& r& r isalphaisalnum)r typenames rB dtype_short_reprr s E{{rx 000E{{ { 5zz EJ ) ) #E
""zH > # E
"" "!,,.. "83C3C3E3E ">> OrD c |
t d }t | t urt | j }nd}t | j o
| j dk }|dz }|rdnd}t d d k r9| j d
k r.| j j s"t |
} n@| j dk s | j d k r || |||d ||
} ndt | j } || z |z }
|r|
S d t | j } t |
|
d dz z
} d}
t d d k r8t | j j t rddt |dz z z }
n1| t | z dz |k rddt |dz z z }
|
|
z | z S )zEInternal version of array_repr() that allows overriding array2string.Nr5 r r (),r: rQ r> )r rH )r z
[], shape=z dtype={})r r rO )rn r r rd r r r r~ r r r rK r r| rfindr r& )arrr r3 r r
class_name skipdtyper r r arr_str dtype_str
last_line_lenspacers rB _array_repr_implementationr s (5 Cyy #YY'
++<1 I
#
F
&SS3F!S(( IOOCIOO388:: A d**l3 > 8 8 8 + !%SY1slV#G ""#3CI#>#>??I
LLGMM$$7$7!$; r r r3 r s rB _array_repr_dispatcherr s 6MrD c & 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 s rB r r s Z & ^Y 8 8 8rD c h t | t rt | S t | S r= )r_ bytesr r )rA s rB _guarded_repr_or_strr 4 s* !U Aww q66MrD c $ t d dk r8| j dk r-| j j s!t | S | j dk r-t
t j | d S || |||dd S )zDInternal version of array_str() that allows overriding array2string.r: rQ r> rO r )
rn r~ r r r r r rc r __getitem__)r r r3 r r s rB _array_str_implementationr ; s !S((
GrMM!'-M16688}}
w"}} $BJ$:$:1b$A$ABBB <>9nc2 N NNrD c | fS r= r> r r r3 r s rB _array_str_dispatcherr O s
4KrD c & 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 r s rB r r T s H % >9n 6 6 6rD __wrapped__)r c | 6|rt j t d S t j t d S t j | | S )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 r s rB r r sN f y I 12EqII I 12DaHH H-a666rD ) NNNNNNNNNNN)
NNNNNNNNNN)r> )r )rO r ) NNNNNNNNNNNN)NTr@ FNNN)NTTr@ FNNN)NNN)T)brg __all__
__docformat__r r` r[ _threadr
ImportError
_dummy_threadrk rc r r r umathr r r r r r r r r r r r fromnumericr numericr r r r r! r" r# r$ r% r& r r' r( re r]
contextlibr\ rn rj r r ru contextmanagerr r r r r r r r r r r r r r r r' r r
r r r r r r r r r r r r r r r r r r r r getattr_array2string_implpartialr r r r> rD rB r sJ
A A A #
(!!!!!!! ( ( (''''''''( ! ! ! ! ! ! 3 3 3 3 3 3 3 3 3 3 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 3 3 3 3 3 3 3 3 3% % % % % % % % % % % % % % % % % % : : : : : : : : k
BFJNIM1 1 1 1h G?CHL:>o!JNo! o! o! o! o!d G B% % %
G $ $ $BH H H H( / / /b&( &( &(R < : +/48.2:>
1'BBB#'4 $B{dd dd2n8 n8 n8 n8 n8 CBn8b 6t t tl
N@ N@ N@ N@ N@ N@ N@ N@b GADBF'+LL LL LL LL^ G6: