Kh, Sr/SQrSrSSKrSSKrSSKrSSKJr SSK r SSK J r SSKJrJrJrJr SS K Jr SS KJrJrJrJrJrJr SS KJr SS KJrJrJ r SS K J!r!J"r"J#r#J$r$J%r%J&r& SSK'J(r(J)r) SSK*J+r+ SSK,r,SSK-r-SSK.r.SJSjr/\)"S5SKSSS.Sjj5r0SKSSS.Sjjr1\)"S5S5r2Sr3\)"S5\.RhS55r*SLSjr5Sr6Sr7Sr8Sr9Sr:SMSjr;\;"5SNS!j5r<SJSS".S#jjr=\("\=SS$9SSSSS \ R|SSSSSS 4 SS".S%jj5r?S&r@S'rAS(rBS)rC"S*S+5rD\)"S5SOS,j5rE\)"S5SPS-j5rF"S.S/5rG"S0S15rH"S2S35rI"S4S55rJ"S6S7\J5rK"S8S9\J5rL"S:S;5rM"S<S=5rNSQS>jrO\#\$\%\R/rQS?rRS@rSSSS\?4SAjrTSRSBjrU\("\USS$9SRSCj5rV\;"5SD5rWSSS\?4SEjrXSRSFjrY\("\YSS$9SRSGj5rZ\["\?SH\?5r\\R"\X\\SI9r^\R"\T\\SI9r_g!\a SSK Jr GNNf=f)SzXArray printing function $Id: arrayprint.py,v 1.9 2005/09/13 13:58:44 teoliphant Exp $ ) array2string array_str array_reprset_printoptionsget_printoptions printoptionsformat_float_positionalformat_float_scientificrestructuredtextN) get_ident) numerictypes)absoluteisinfisfiniteisnat) multiarray)arraydragon4_positionaldragon4_scientificdatetime_as_string datetime_datandarray)any) concatenateasarrayerrstate)longlongintcint_float64 complex128flexible)array_function_dispatch set_module)format_optionsc [[5R55V V s0sH upU cM X_M nn n Ub[U5US'/SQnXS/-;a$[ SSR SU55-5eUS;a [ S5eU S La[ RUS 'OU S :Xa3[R"S U <S 3[S S9 [ RUS 'OIU S:XaSUS 'O=U S:XaSUS 'O1U S:XaSUS 'O%U S:XaSUS 'OU cO[R"SS S9 UbP[U[R5(d [S5e[R "U5(a [ S5eUb["R$"U5US'U$U$s sn n f![an[S5UeSnAff=f)za Make a dictionary out of the non-None arguments, plus conversion of *legacy* and sanity checks. Nsuppress)fixeduniquemaxprec maxprec_equalz floatmode option must be one of , c3D# UHnSRU5v M g7f)z"{}"Nformat).0ms H/var/www/html/env/lib/python3.13/site-packages/numpy/_core/arrayprint.py %_make_options_dict..Cs"CU6==#3#3Us )N-+ z+sign option must be one of ' ', '+', or '-'FlegacyzPassing `legacy=z` is deprecated. stacklevel1.13q1.21y1.25}z2.1zUlegacy printing option can currently only be '1.13', '1.21', '1.25', '2.1, or `False`zthreshold must be numericzIthreshold must be non-NAN, try sys.maxsize for untruncated representation precisionzprecision must be an integer)listlocalsitemsbool ValueErrorjoinsysmaxsizewarningswarn FutureWarning isinstancenumbersNumber TypeErrornpisnanoperatorindex)rD threshold edgeitems linewidthr(nanstrinfstrsign formatter floatmoder9 override_reprkvoptionsmodeses r3_make_options_dictrf2s!%VX^^%5 6H 6!tqt 6GH"8n  ;E&;"CU"CCDE E ((FGG KK 5 vj(8 9 a  KK 6  6  6  5    '34 6)W^^4478 8 88I  JK K C#+>>)#- F99F>numpyr9r`c "[XX#UXVXxU XS9 g)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 '-') .. versionchanged:: 2.0 The sign parameter can now be an integer type, previously types were floating-point types. 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 ``'1.25'`` approximates printing of 1.25 which mainly means that numeric scalars are printed without their type information, e.g. as ``3.0`` rather than ``np.float64(3.0)``. If set to ``'2.1'``, shape information is not given when arrays are summarized (i.e., multiple elements replaced with ``...``). If set to `False`, disables legacy mode. Unrecognized strings will be ignored with a warning for forward compatibility. .. versionchanged:: 1.22.0 .. versionchanged:: 2.2 override_repr: callable, optional If set a passed function will be used for generating arrays' repr. Other options will be ignored. See Also -------- get_printoptions, printoptions, 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: >>> import numpy as np >>> 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], shape=(10,)) 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. ], shape=(10,)) rhN)_set_printoptions) rDrXrYrZr(r[r\r^r]r_r9r`s r3rrqshiI(iy#Bc  [XX#XEXhUX5 n X|S'XS'[R"5U -n U RU 5 U SS:XaSU S'[R"U 5$)Nr^r`r9r>r6r])rfr&getupdateset)rDrXrYrZr(r[r\r^r]r_r9r`new_opt updated_opts r3rjrj*sw!y!)6!*4G%K,O $$&0Kw8#! F   k **rkc[R"5R5nSSSSSS[RS0USUS'U$) 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 - sign : str - formatter : dict of callables - floatmode : str - legacy : str or False For a full description of these options, see `set_printoptions`. See Also -------- set_printoptions, printoptions Examples -------- >>> import numpy as np >>> np.get_printoptions() {'edgeitems': 3, 'threshold': 1000, ..., 'override_repr': None} >>> np.get_printoptions()['linewidth'] 75 >>> np.set_printoptions(linewidth=100) >>> np.get_printoptions()['linewidth'] 100 r>r=r@r?rBrAFr9)r&rmcopyrKrL)optss r3rr>sOT     $ $ &D VS&#vs{{E 8nDN Krkc2[R"5S$)z'Return the legacy print mode as an int.r9)r&rmrkr3_get_legacy_print_moderwos     ))rkc/# [U0UD6n[5v [R"U5 g![R"U5 f=f7f)aZContext 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 -------- >>> import numpy as np >>> 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)rjrr&reset)argskwargstokens r3rrts@8 t .v .E$  U#U#s A  2A A  A c <[U5nX0R:XaX$URUSU-:aI[[ XU[ R SU-5[ XU[ R U*S-54US9$[ XU[ R SS-5$)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_trailingrT index_exp)arYrWrs r3rrs u:D vv~xwwt}q{" aEBLL)4L,L M aEBLL)4M,M N   !ur||A/FGGrkcR[U5[LaSnOSnURU5$)z?Object arrays containing lists should be printed unambiguously z list({!r})z{!r})typerEr0)ofmts r3_object_formatrs% Aw$ ::a=rkc[U[R[R45(a[ UR 55$[ U5$N)rPrTstr_bytes_repritemxs r3 repr_formatrs5!bggryy)**AFFH~ 7Nrkc[U[R[R45(a[ UR 55$[ U5$r)rPrTrrstrrrs r3 str_formatrs5!bggryy)**1668} q6Mrkc |^^^^^^U4SjUU4SjUUUUUU4SjUUUUUU4SjUUUUUU4SjUUUUUU4SjUU4SjU4SjS S S S . nS n UbUR5V s/sH oU cM U PM n n SU ;a$UR5Hn U "US5X'M SU ;aSHn U "US5X'M SU ;aSHn U "US5X'M SU ;aSHn U "US5X'M SU ;aU "US5US'UR5Hn X;dM U "Xl5X'M U$s sn f)Nc>[T5$r) BoolFormatdatasr3!_get_formatdict..s 4(rkc>[TT5$r) IntegerFormat)rr]sr3rrs }T40rkc  >[TTTTTTS9$Nr9FloatingFormatrr_r9rDr]r(sr3rrs )Y$vGrkc  >[TTTTTTS9$rrrsr3rrs^ )Y$vGrkc  >[TTTTTTS9$rComplexFloatingFormatrsr3rrs 5 )Y$v!Grkc  >[TTTTTTS9$rrrsr3rrs$9 )Y$v%Grkc>[TTS9$r)DatetimeFormat)rr9sr3rrs N4?rkc>[T5$r)TimedeltaFormatrsr3rrs _T2rkc[$r)rrvrkr3rrs.rkc[$r)rrvrkr3rrs rkc[$r)rrvrkr3rrsKrk) rHintfloat longfloat complexfloatlongcomplexfloatdatetime timedeltaobjectvoidnumpystrc^U4Sj$)Nc>T$rrvrsr3r3_get_formatdict..indirect..sqrkrvrs`r3indirect!_get_formatdict..indirects rkallint_kind)r float_kind)rr complex_kind)rrstr_kindr)keys) rrDr_r(r]r9r^r{ formatdictrrafkeyskeys `````` r3_get_formatdictrs_)0GGGGGGGG?2("')J&%NN,I,q! ,I E>!("*9U+;"< )  "*9Z+@"A  5 -"*9\+B"C . U ";"*9^+D"E <  %-i .C%DJz "??$C|"*9>": % 'Js & D93D9c fURnURn[U40UD6nUc US"5$[U[R 5(a US"5$[U[R 5(a3[U[R5(a US"5$US"5$[U[R5(a3[U[R5(a US"5$US"5$[U[R5(a3[U[R5(a US"5$US"5$[U[R[R45(a US"5$[U[R5(a US "5$[U[R5(a US "5$[U[R 5(a.UR"b[$R&"U40UD6$US "5$US"5$) z3 find the right formatting function for the dtype_ rrHrrrrrrrrr)dtyperr issubclass_ntrHinteger timedelta64floating longdoublecomplexfloating clongdoublerr datetime64object_rnamesStructuredVoidFormat from_data)rrcdtype_dtypeobjrs r3_get_format_functionrsZZF{{H 11J*%'' Hchh ' '&!## Hckk * * h 0 0k*, ,e$& & Hcll + + h / /k*, ,g&( ( Hc11 2 2 h 0 0013 3n-/ / Hsxx4 5 5*%'' Hcnn - -*%'' Hckk * *(#%% Hchh ' ' << #'11$B'B Bf%' '*%''rkc^U4SjnU$)z 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 cb>^^[5m[R"T5UUU4Sj5nU$)Nc>[U5[54nUT;aT$TRU5 T"U/UQ70UD6TRU5 $!TRU5 f=fr)idr adddiscard)selfrzr{rf fillvalue repr_runnings r3wrapper>_recursive_guard..decorating_function..wrapper&scT(IK'Cl"    S ! *///$$S) $$S)s AA!)ro functoolswraps)rrrrs` @r3decorating_function-_recursive_guard..decorating_function#s,u   *  *rkrv)rrs` r3_recursive_guardrs rkr8c [U5nURS:XaUnURUS:aSn[XAS5nOSn[ U40UD6nSnUS[ U5-- n[ XUSXrUSXQS5nU$) NrvrX...rYrr8rZr9)rrsizerrr _formatArray) rrc separatorprefixrsummary_insertformat_functionnext_line_prefixlsts r3 _array2stringr7s 1:Dww"} vv $$ {';<+4;7;OCK' q7;+?'GK4H%x'8 :C Jrkrc U4$rrv)rmax_line_widthrDsuppress_smallrrstyler^rXrYr]r_suffixr9s r3_array2string_dispatcherrTs 4Krk)modulec  [X(U XSSXX5 n[R"5R5nUR U5 USS::aWU[ R La[nURS:Xa-URRcU"UR55$O-U[ R La[R"S[SS9 USS:aUS==[U 5-ss'UR S :Xag [#XXE5$) 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']``. .. versionchanged:: 2.0 The sign parameter can now be an integer type, previously types were floating-point types. 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. 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 -------- >>> import numpy as np >>> 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]' Nr9r>rvzT'style' argument is deprecated and no longer functional except in 1.13 'legacy' moder~r;rZr z[])rfr&rmrsrnrT_NoValuerrrrrrMrNDeprecationWarningrrr)rrrDrrrrr^rXrYr]r_rr9 overridesrcs r3rr]st#9#14#'IGI  "'')G NN9xC BKK E 77b=QWW]]2? " bkk ! 6(Q 8x3 F + vv{ Y 77rkc[U5[U5-U:nUS:a[U5[U5::aSnU(aXR5S-- nUnX- nX4$)Nr>F )rrstrip)slineword line_widthrr9 needs_wraps r3 _extendLiner s`TSY&3J | t9,- -J [[]T !!LD 7NrkcUR5n[U5S:XdUS::a [XX#XE5$[SU55n[U5U-U:a7[U5[U5:aXR 5S-- nXFS-nUnO[U5S-nXS- nUSSHnXR 5S-- nX-nM U[US5- n XS-- nX4$) zK Extends line with nicely formatted (possibly multi-line) string ``word``. r r>c38# UHn[U5v M g7frr)r1r s r3r4%_extendLine_pretty..)s6#d))rr r8N) splitlinesrr maxr) rr r r rr9wordsmax_word_lengthindent suffix_lengths r3_extendLine_prettyr!s OO E 5zQ&C-1D6FOO666O D O#j0 I,- - [[]T !!(*!T3 aac  [[]T !!}$c%)n4M# D 7NrkcL^^^^^^^UUUUUUU4SjmT"SUUS9Sm$!Smf=f)z[formatArray is designed for two modes of operation: 1. Full output 2. Summarized output c >[U5nTRU- nUS:Xa T"TU5$US-nTS::aUnOU[S5- nTRUnT=(a ST-U:nU(aTn Tn OSn Un Sn US:XGaTS::aU[TR55- n O/U[ [TR55[S55- n Un [ U 5H$nT"X4-XV5n[ XXUT5upU T- n M& U(a![XTXT5upTS::aU S- n OU T- n [ U SS 5H%nT"X*4-XV5n[ XXUT5upU T- n M' TS::aUn T"US -XV5n[ XXUT5upX- n OSn TR5S US- --n[ U 5HnT"X4-XV5nXU-U-- n M U(aTS::a XT-S -- n O XT-U-- n [ U SS 5HnT"X*4-UU5nXU-U-- n M T"US -XV5nXU-- n S U [U5S-S-n U $)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 r8r>]r~rr r-r)rrz, [N)rrrrrrangerr )rWhanging_indent curr_widthr axes_leftnext_hanging_indent next_widtha_len show_summary leading_itemstrailing_itemsr elem_widthr ir line_sepnestedr edge_itemsrr9recurserrrs r3r._formatArray..recurserEs 5zFFTM >"1U8, ,-s2 S=#J#c#h.J %>!J,*> &M'NM"N  >}'#i.>.>.@*AA '# ((*+SX+ "D=) .AN,T~vG ! * %^ZS=DLDI%D>1b1 /BO,T~vG ! 2 }' EEM+>KD(>6CGA IAA '')D)a-,@@H=)!DL"5f,x77 * S=.86AAA.88CCA>1b1!%2%-1D",.f,x772 eem-@MF &( (A !C'() )C /rkrv)rWr r!Nrv) rrr rrr-rr9r.s `` ````@r3rr<s2ffP b'7#-/4s#cNUcgUS:a[SRU55eU$)Nrr z{} must be >= 0)rIr0)rnames r3_none_or_positive_argr2s-y1u*11$788 Hrkc6\rSrSrSrS SS.SjjrSrSrSrg) riz&Formatter for subtypes of np.floating Nrc`[U[5(a U(aSOSnX`lURS::aURS:waUS:XaSnX0lUS:XaSUlOX l[ UR S5UlX@lXPlSUl SUl URU5 g) Nr7r6r>rvr8r*rDF) rPrH_legacyrr_rDr2rr] exp_formatlarge_exponent fillFormat)rrrDr_rr]r9s r3__init__FloatingFormat.__init__s dD ! !3CD <<3 zzRDCK"  !DN&N.t~~{K, # rkc^^^U[U5n[X"S:g5n[U5S:waj[R"U5n[R "U5n[ SS9 US:dTR(dUS:dXE- S:aSTlSSS5 [U5S:Xa,STl STl STl S Tl STl STlGOTR(aS ummTRS :XdTR S ::aS ummUUU4SjU5n[#SU56upxn [#SU56up[ SU 55S- Tl STl [ SU 55TlTR$TlTTl TR S ::aSTl O[ SU 55Tl TRS-TR$-Tl OS ummTRS :XaS ummUUU4SjU5n[#SU56upTR S ::aS[ SU 55-Tl O[ SU 55Tl [ SU 55Tl S Tl TTl TRS;a TR=TlTlSTl OSTl STlTR S :aITR&S:Xa9[)[R*"U55(dT=RS- sl UR,UR,:waTR&S:g=(d [)U[/U5S:5n TRS-n [0R2"5n[ TR[US 5U - [US!5U -U - 5Tl gg!,(df  GN;=f)"Nr ignore)overgחAg-C6?g@@T.r)r>Tr)r>)raFc 3l># UH)n[UTRTTTRS:HS9v M+ g7f)r7)rDr*trimr]N)rrDr]r1rrr@r*s r3r4,FloatingFormat.fillFormat..s6*('qDNN&,4dii3>NP(s14c3B# UHoRS5v M g7f)reN) partitionr1rs r3r4rBs*JT;;s+;+;Tc3B# UHoRS5v M g7fr>NsplitrEs r3r4rBs'Hi irFc38# UHn[U5v M g7frrrEs r3r4rBs91Arr rac38# UHn[U5v M g7frrrEs r3r4rB ;AQrr:c38# UHn[U5v M g7frrrEs r3r4rB#=HqCFFHrr~c 3n># UH*n[UTRSTTTRS:HS9v M, g7f)Tr7)rD fractionalr*r@r]N)rrDr]rAs r3r4rB s=*) 'qDNN26.44,0II,<>)s25c3B# UHoRS5v M g7frHrIrEs r3r4rBs'Cd drFc3V# UHn[URS55v M! g7f)z-+N)rlstriprEs r3r4rBs 'NXAHHTN(;(;Xs')c38# UHn[U5v M g7frrrEs r3r4rBrOrc38# UHn[U5v M g7frrrEs r3r4rBrMr)r)r,r8r6r[r\)rrrrTrminrrr6pad_left pad_rightr@exp_sizer* min_digitsr_r5ziprDr]rsignbitrrr&rm)rr finite_vals abs_non_zeromax_valmin_valstrs frac_strs_exp_strsint_part frac_partneginfoffsetcurrent_optionsr@r*s` @@r3r8FloatingFormat.fillFormatsN8D>*  1,< => |  !ff\*Gff\*Gx(d?4+>+> 6)W_u-D&*DO) { q DMDNDIDMDK"DO __$LD&~~(DLLC,?) f*(*D&)*JT*J%K "I("%'Hi'H"I H999A=DMDI ; ;;DN"nnDO DK||s" ! !$#=H#= = !]]Q.?DN$LD&~~() f*) *D #&'Cd'C"D H||s" !C'NX'N$N N ##=H#= =  ; ;;DNDM DK~~!;;37>>A  "# <<# yyCBJJ{,C(D(D "  99 (( (YY#%CT%+->-B)CF^^a'F,002O s?8#<=FOH-.7&@DM )I)(s &-O Oc B[R"U5(d[SS9 [R"5n[R "U5(aUR S:XaSOSnX2S-nO#US:aSOUR S:XaSOSnX2S-nS URUR-S -[U5- -U-sSSS5 $UR(aY[UURURURURUR S:HURUR S 9$[#UURURURS URUR S:HURURS 9 $!,(df  N=f)Nr<)invalidr7rr[r r6r\r8r )rDr[r*r@r]rX exp_digitsT)rDr[r*rQr@r]rXrY)rTrrr&rmrUr]rXrYrr6rrDr[r*r@rZr)rrrjr]rets r3__call__FloatingFormat.__call__1sS{{1~~(+"0"4"4"688A;;"&))s"23D!::C"#a%3DII4DS"D!::CMMDNN2Q6SA,+ ??%a0415-1[[+/99+/99+;/3}}15@ @&a0415-1[[15+/99+/99+;/3}}04@ @-,+s BF F) r5r6rZr_r7r[rXrYrDr]rr@r*F) __name__ __module__ __qualname____firstlineno____doc__r9r8rp__static_attributes__rvrkr3rrs14Tl @rkrc [US5n[US5n[US5n[US5nUS:aUS:aXq:a [S5e[XUX4UXgS9$)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 -------- >>> import numpy as np >>> 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' rDrXrnr[r 2min_digits must be less than or equal to precision)rDr*r@r]rXrnr[)r2rIr)rrDr*r@r]rXrnr[s r3r r TsnL&i=I$Xz:H&z<@J&z<@JA~)a-J,BMNN aV#'X)3 LLrkc [US5n[US5n[US5n[US5nU(dUS:Xa [S5eUS:aUS:aX:a [S5e[XUX4XVXxS9 $) 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 -------- >>> import numpy as np >>> 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' rDrXrYr[r z4precision must be greater than 0 if fractional=Falserz)rDr*rQr@r]rXrYr[)r2rIr) rrDr*rQr@r]rXrYr[s r3rrs\&i=I$Xz:H%i=I&z<@J )q.,- -A~)a-J,BMNN aV)3#'(1 JJrkc$\rSrSrSSjrSrSrg)ric>URS:a~[R"U5n[R"U5n[ [ U55nUS:XaUS:aSnUS:a US;aUS- n[U[ [ U555nOSnSUUS3Ulg)Nr r8r6z+ r z{:zd})rrTrrWrrr0)rrr]data_maxdata_mindata_max_str_len max_str_lens r3r9IntegerFormat.__init__s 99q=vvd|Hvvd|H"3x=1 s{x!|1} A% .!#h-02KKD6+c2 rkc8URRU5$rr/rrs r3rpIntegerFormat.__call__s{{!!!$$rkr/N)r6rsrtrurvr9rprxrvrkr3rrs  3%rkrc \rSrSrSrSrSrg)ric BURS:waSUlgSUlg)Nrvz TrueTrue)rtruestr)rrr{s r3r9BoolFormat.__init__s#'**"2w  rkc,U(a UR$S$)NFalserrs r3rpBoolFormat.__call__s t||-g-rkrNrrvrkr3rrs ? .rkrc2\rSrSrSrSSS.SjjrSrSrg) riz-Formatter for subtypes of np.complexfloating Nrc [U[5(a U(aSOSnU=pxUS::aSnSn[URX'UXVS9Ul[UR X(USUS9Ulg)Nr7r6r>r,r+)r]r9)rPrHrreal real_formatimag imag_format) rrrDr_rr]r9floatmode_realfloatmode_imags r3r9ComplexFloatingFormat.__init__ sm dD ! !3CD*33 S=,N&N) FFI~ * FFI~V rkcURUR5nURUR5n[ UR 55nUSUS-X4S-nX#-$)Nj)rrrrrr)rrrr*sps r3rpComplexFloatingFormat.__call__4sZ   QVV $   QVV $_ crFSL1S6 !u rk)rrrr)rsrtrurvrwr9rprxrvrkr3rrs8 '+ (rkrc&\rSrSrSrSrSrSrg)_TimelikeFormati?c U[U5)n[U5S:ae[[UR[R"U555[UR[R "U5555nOSn[U5UR :a [US5nSRU5UlSRU5Ul g)Nr z%{}sz'NaT') rrr_format_non_natrTrWrr0_formatrjust_nat)rrnon_natrs r3r9_TimelikeFormat.__init__@sd |$ wUc5URRS:Xa[UR5SnOSnUcSnX0lX lX@lXPl[TU]!U5 g)NMr rnaive) rkindrtimezoneunitcastingr9superr9)rrrrrr9 __class__s r3r9DatetimeFormat.__init__Zs` <ww||s"$QWW-a0  H     rkcd>URS::aURU5$[TU] U5$)Nr>)r9rrrp)rrrs r3rpDatetimeFormat.__call__ms0 ;;# ''* *w""rkc\S[UURURURS9-$)N'%s')rrr)rrrrrs r3rDatetimeFormat._format_non_natrs.*1)--1]],0LL:: :rk)rr9rr)NN same_kindF) rsrtrurvr9rprrx __classcell__)rs@r3rrYs""rkrvN)rsrtrurvrrxrvrkr3rrys#rkrc&\rSrSrSrSrSrSrg)SubArrayFormati~c 8XlUSUlUSUlg)NrXrY)rrXr-)rrrcs r3r9SubArrayFormat.__init__s . -!+.rkcjURUR:aSOSUlURU5$)Nrr)rrXr format_array)rrs r3rpSubArrayFormat.__call__s,'(vv'>eB  ##rkc[R"U5S:XaURU5$UR(aURSSUR -:alUSUR Vs/sHo R U5PM snUR/-XR *SVs/sHo R U5PM sn-nO UVs/sHo R U5PM nnSSRU5-S-$s snfs snfs snf)Nr r~rr-r)rTrrrrr-rrJ)rra_ formatteds r3rSubArrayFormat.format_arrays 771:?''* *   1771:$//0A#A123CDOO1DE1D2""2&1DE&&'(34oo5E5F3GH3GR$$R(3GHI  :;;2**2.I;TYYy))C//FH>*Q-0 0==:!67 7 sA3rN) rsrtrurvrwr9 classmethodrrprxrvrkr3rrs%1 % %8rkrcJ[R"5R5nUSS::a&[R"[ U540UD6"U5$URS5c0US'USR S[5 [R"[ U540UD6"U5nU(dU$[U5nURRSS5S-UR-n[R"[RUR45nUSUS U<S 3$) 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. r9rBr^rrgrTr>(z, dtype=))r&rmrsrrr setdefaultrrrtreplacersrTrr)ris_reprrcval_reprrcls_fqn void_dtypes r3_void_scalar_to_stringrs   "'')GxC#--eAhB'B1EE{{;'!  K##L#6#--eAhB'B1EH  q'Cnn$$Wd3c9CLLHG277AGG,-JYaz*q 99rkc [R"U5n[R"5SS::aUR[R :XagUR bgUR(dgUR[;$)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 -------- >>> import numpy as np >>> 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) r9r>F) rTrr&rmrrHrisnative _typelessdata)rs r3dtype_is_impliedrsc6 HHUOEH%,rww1F {{ >> :: &&rkc[U5R[RR:wa [ U5$UR b [ U5$[UR[5(aS[ U5-$URnUR(dS[ U5-$U(a8USR5(aUR5(d [ U5nU$)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 rr ) r__repr__rTrrrrrr#r1risalphaisalnum)rtypenames r3dtype_short_reprrs E{rxx000E{ {{5z EJJ ) )E ""zzH >>E ""!,,..83C3C3E3E> Orkc <[R"5nUSnUbU"U5$UcUSn[U5[La[U5RnOSnUS-nUSS::aEUR S:Xa5UR R(d[UR55n O U"XX#SUS S 9n /n URS :XaUR S :wdUSS :a1URUS:aU RSUR 35 [UR 5(aURS :Xa'U RS[UR 535 U (dX-S -$X-S-n SRU 5S -n [U 5U R!S5S-- n SnUSS::a;[#UR R[$5(aSS[U5--nO&U [U 5-S-U:aSS[U5--nX-U -$)zEInternal version of array_repr() that allows overriding array2string.r`rZrrr9r>rvr-r)rr )r rXzshape=zdtype=,rr r8)r&rmrrrsrrrrrrrrrrJrrfindrr#)arrrrDrrrjr` class_namerrextrasarr_str extra_str last_line_lenspacers r3_array_repr_implementationr!s%((*O#O4M S!!(5 Cy#Y''  # F!S( IIOCIIOO388:3 5 F A #))t+x(3.?;77 syyk*+ CII & &#((a- / :;<= |c!!lS G &!C'ILGMM$$7!$;>> import numpy as np >>> 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. ])' )rrs r3rr\s\ & Y 88rkcX[U[5(a [U5$[U5$r)rPbytesrr)rbs r3_guarded_repr_or_strrs!!UAw q6MrkcJ[R"5SS::aDURS:Xa4URR(d[ UR 55$URS:Xa)[[RRUS55$U"XX#SS5$)zDInternal version of array_str() that allows overriding array2string.r9r>rvr8r) r&rmrrrrrrrTr __getitem__)rrrDrrs r3_array_str_implementationrs{ X&#- GGrM!''--1668}  ww"}$BJJ$:$:1b$ABB 9c2 NNrkcU4$rrvrrrDrs r3_array_str_dispatcherr s 4Krkc[XX#5$)a 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 -------- >>> import numpy as np >>> np.array_str(np.arange(3)) '[0 1 2]' )rr s r3rrsJ % 9 66rk __wrapped__)r) NNNNNNNNNNNN) NNNNNNNNNN)rv)r)r8r)NTraFNNN)NTTraFNNN)T)NNN)`rw__all__ __docformat__rrQrK_threadr ImportError _dummy_threadrgrTrrrumathrrrrrrrrrrr fromnumericrnumericrrrrrr r!r"r#rr$r%rr&rVrM contextlibrfrrjrrwcontextmanagerrrrrrrrrrrrr rrr2rr rrrrrrrrrrrHrrrrrrrrr rgetattr_array2string_implpartial_default_array_str_default_array_reprrvrkr3rs  A#  (!!33EE33%%:(BFJNIM%)<~ G?C;?GKuB $4uBuBpAE<@HL+!%D+( G--`*  G $$DH(  0d&(R<:+/48.2:>   1'B#'4 $B{{dddd2r8 r8Cr8j 6zx R@R@j GADBF'+MLML` G6: