/ lib / numpy / core / arrayprint.pyc
arrayprint.pyc
  1  o

  2  [��c���
@s�dZgd�ZdZddlZddlZddlZzddlmZWney+ddl	mZYnwddl
  3  Zddlm
ZddlmZmZmZmZdd	lmZdd
  4  lmZmZmZmZmZmZmZddlmZddlmZm 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			dvdd�Z1e+d�			dwdd�dd��Z2e+d�dd ��Z3d!d"�Z4e+d�e.j5d#d$���Z6dxd&d'�Z7d(d)�Z8d*d+�Z9d,d-�Z:d.d/�Z;d0d1�Z<dyd3d4�Z=e=�dzd7d8��Z>				d{dd�d9d:�Z?e*e?dd;�dddd5d6ej@dddddd6fdd�d<d=��ZAd>d?�ZBd@dA�ZCdBdC�ZDdDdE�ZEGdFdG�dG�ZFe+d�	I		d|dJdK��ZGe+d�	H		d}dLdM��ZHGdNdO�dO�ZIGdPdQ�dQ�ZJGdRdS�dS�ZKGdTdU�dU�ZLGdVdW�dWeL�ZMGdXdY�dYeL�ZNGdZd[�d[�ZOGd\d]�d]�ZPd^d_�ZQe$e%e&e'gZRd`da�ZSdbdc�ZTdddeAfddde�ZU	d~dfdg�ZVe*eVdd;�d~dhdi��ZWe=�djdk��ZXdddeAfdldm�ZY	d~dndo�ZZe*eZdd;�d~dpdq��Z[e\eAdreA�Z]ej^eYe]ds�Z_ej^eUe]ds�Z`ddtdu�ZadS)�zXArray printing function
  5  
  6  $Id: arrayprint.py,v 1.9 2005/09/13 13:58:44 teoliphant Exp $
  7  
  8  )	�array2string�	array_str�
  9  array_repr�set_string_function�set_printoptions�get_printoptions�printoptions�format_float_positional�format_float_scientific�restructuredtext�N)�	get_ident�)�numerictypes)�absolute�isinf�isfinite�isnat)�
 10  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�
 11  set_module�i��maxprec�F�K�nan�inf�-)�	edgeitems�	threshold�	floatmode�	precision�suppress�	linewidth�nanstr�infstr�sign�	formatter�legacyc
 12  Cs,dd�t���D�}|durt|�|d<gd�}|	|dgvr-tdd�dd	�|D����|d
 13  vr5td��|
 14  dkr?tj|d
<n|
 15  dkrHd|d
<n|
 16  dkrQd|d
<n|
 17  durVntjddd�|durtt	|t
 18  j�sktd��t
�|�rttd��|dur�z
 19  t�|�|d<W|Sty�}
ztd�|
�d}
~
ww|S)zm
 20      Make a dictionary out of the non-None arguments, plus conversion of
 21      *legacy* and sanity checks.
 22      cSsi|]\}}|dur||�qS�N�)�.0�k�vr;r;��C:\Users\Jacks.GUTTSPC\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.10_qbz5n2kfra8p0\LocalCache\local-packages\Python310\site-packages\numpy\core\arrayprint.py�
 23  <dictcomp>Hsz&_make_options_dict.<locals>.<dictcomp>Nr3)�fixed�uniquer)�
maxprec_equalz floatmode option must be one of �, css�|]}d�|�VqdS)z"{}"N��format)r<�mr;r;r?�	<genexpr>P��z%_make_options_dict.<locals>.<genexpr>)Nr.�+� z+sign option must be one of ' ', '+', or '-'Fr9�1.13�q�1.21�yzGlegacy printing option can currently only be '1.13', '1.21', or `False`r(��
 24  stacklevelzthreshold must be numericzIthreshold must be non-NAN, try sys.maxsize for untruncated representationr2zprecision must be an integer)�locals�items�bool�
 25  ValueError�join�sys�maxsize�warnings�warn�
 26  isinstance�numbers�Number�	TypeError�np�isnan�operator�index)r2r0r/r4r3r5r6r7r8r1r9�options�modes�er;r;r?�_make_options_dict@sH�
 27  
 28  �
 29  �
 30  ��rf�numpy�r9c
 31  Cs�t||||||||||	|
 32  �}||d<t�|�tddkr'td�dtd<dStddkr3td�dStdtjkr@td�dSdS)	a
 33      Set printing options.
 34  
 35      These options determine the way floating point numbers, arrays and
 36      other NumPy objects are displayed.
 37  
 38      Parameters
 39      ----------
 40      precision : int or None, optional
 41          Number of digits of precision for floating point output (default 8).
 42          May be None if `floatmode` is not `fixed`, to print as many digits as
 43          necessary to uniquely specify the value.
 44      threshold : int, optional
 45          Total number of array elements which trigger summarization
 46          rather than full repr (default 1000).
 47          To always use the full repr without summarization, pass `sys.maxsize`.
 48      edgeitems : int, optional
 49          Number of array items in summary at beginning and end of
 50          each dimension (default 3).
 51      linewidth : int, optional
 52          The number of characters per line for the purpose of inserting
 53          line breaks (default 75).
 54      suppress : bool, optional
 55          If True, always print floating point numbers using fixed point
 56          notation, in which case numbers equal to zero in the current precision
 57          will print as zero.  If False, then scientific notation is used when
 58          absolute value of the smallest number is < 1e-4 or the ratio of the
 59          maximum absolute value to the minimum is > 1e3. The default is False.
 60      nanstr : str, optional
 61          String representation of floating point not-a-number (default nan).
 62      infstr : str, optional
 63          String representation of floating point infinity (default inf).
 64      sign : string, either '-', '+', or ' ', optional
 65          Controls printing of the sign of floating-point types. If '+', always
 66          print the sign of positive values. If ' ', always prints a space
 67          (whitespace character) in the sign position of positive values.  If
 68          '-', omit the sign character of positive values. (default '-')
 69      formatter : dict of callables, optional
 70          If not None, the keys should indicate the type(s) that the respective
 71          formatting function applies to.  Callables should return a string.
 72          Types that are not specified (by their corresponding keys) are handled
 73          by the default formatters.  Individual types for which a formatter
 74          can be set are:
 75  
 76          - 'bool'
 77          - 'int'
 78          - 'timedelta' : a `numpy.timedelta64`
 79          - 'datetime' : a `numpy.datetime64`
 80          - 'float'
 81          - 'longfloat' : 128-bit floats
 82          - 'complexfloat'
 83          - 'longcomplexfloat' : composed of two 128-bit floats
 84          - 'numpystr' : types `numpy.string_` and `numpy.unicode_`
 85          - 'object' : `np.object_` arrays
 86  
 87          Other keys that can be used to set a group of types at once are:
 88  
 89          - 'all' : sets all types
 90          - 'int_kind' : sets 'int'
 91          - 'float_kind' : sets 'float' and 'longfloat'
 92          - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
 93          - 'str_kind' : sets 'numpystr'
 94      floatmode : str, optional
 95          Controls the interpretation of the `precision` option for
 96          floating-point types. Can take the following values
 97          (default maxprec_equal):
 98  
 99          * 'fixed': Always print exactly `precision` fractional digits,
100                  even if this would print more or fewer digits than
101                  necessary to specify the value uniquely.
102          * 'unique': Print the minimum number of fractional digits necessary
103                  to represent each value uniquely. Different elements may
104                  have a different number of digits. The value of the
105                  `precision` option is ignored.
106          * 'maxprec': Print at most `precision` fractional digits, but if
107                  an element can be uniquely represented with fewer digits
108                  only print it with that many.
109          * 'maxprec_equal': Print at most `precision` fractional digits,
110                  but if every element in the array can be uniquely
111                  represented with an equal number of fewer digits, use that
112                  many digits for all elements.
113      legacy : string or `False`, optional
114          If set to the string `'1.13'` enables 1.13 legacy printing mode. This
115          approximates numpy 1.13 print output by including a space in the sign
116          position of floats and different behavior for 0d arrays. This also
117          enables 1.21 legacy printing mode (described below).
118  
119          If set to the string `'1.21'` enables 1.21 legacy printing mode. This
120          approximates numpy 1.21 print output of complex structured dtypes
121          by not inserting spaces after commas that separate fields and after
122          colons.
123  
124          If set to `False`, disables legacy mode.
125  
126          Unrecognized strings will be ignored with a warning for forward
127          compatibility.
128  
129          .. versionadded:: 1.14.0
130          .. versionchanged:: 1.22.0
131  
132      See Also
133      --------
134      get_printoptions, printoptions, set_string_function, array2string
135  
136      Notes
137      -----
138      `formatter` is always reset with a call to `set_printoptions`.
139  
140      Use `printoptions` as a context manager to set the values temporarily.
141  
142      Examples
143      --------
144      Floating point precision can be set:
145  
146      >>> np.set_printoptions(precision=4)
147      >>> np.array([1.123456789])
148      [1.1235]
149  
150      Long arrays can be summarised:
151  
152      >>> np.set_printoptions(threshold=5)
153      >>> np.arange(10)
154      array([0, 1, 2, ..., 7, 8, 9])
155  
156      Small results can be suppressed:
157  
158      >>> eps = np.finfo(float).eps
159      >>> x = np.arange(4.)
160      >>> x**2 - (x + eps)**2
161      array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])
162      >>> np.set_printoptions(suppress=True)
163      >>> x**2 - (x + eps)**2
164      array([-0., -0.,  0.,  0.])
165  
166      A custom formatter can be used to display array elements as desired:
167  
168      >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
169      >>> x = np.arange(3)
170      >>> x
171      array([int: 0, int: -1, int: -2])
172      >>> np.set_printoptions()  # formatter gets reset
173      >>> x
174      array([0, 1, 2])
175  
176      To put back the default options, you can use:
177  
178      >>> np.set_printoptions(edgeitems=3, infstr='inf',
179      ... linewidth=75, nanstr='nan', precision=8,
180      ... suppress=False, threshold=1000, formatter=None)
181  
182      Also to temporarily override options, use `printoptions` as a context manager:
183  
184      >>> with np.printoptions(precision=2, suppress=True, threshold=5):
185      ...     np.linspace(0, 10, 10)
186      array([ 0.  ,  1.11,  2.22, ...,  7.78,  8.89, 10.  ])
187  
188      r8r9rMr.r7rOrN)rf�_format_options�updaterrWrX)r2r0r/r4r3r5r6r8r7r1r9�optr;r;r?rts
189  "
190  �
191  �rcCs*t��}ddddtjdi|d|d<|S)a.
192      Return the current print options.
193  
194      Returns
195      -------
196      print_opts : dict
197          Dictionary of current print options with keys
198  
199            - precision : int
200            - threshold : int
201            - edgeitems : int
202            - linewidth : int
203            - suppress : bool
204            - nanstr : str
205            - infstr : str
206            - formatter : dict of callables
207            - sign : str
208  
209          For a full description of these options, see `set_printoptions`.
210  
211      See Also
212      --------
213      set_printoptions, printoptions, set_string_function
214  
215      rMrLrOrNFr9)ri�copyrWrX)�optsr;r;r?r's��rcCstdS)z'Return the legacy print mode as an int.r9)rir;r;r;r?�_get_legacy_print_modeIsrnc
216  osN�t��}ztj|i|��t��VWtjdi|��dStjdi|��w)a�Context manager for setting print options.
217  
218      Set print options for the scope of the `with` block, and restore the old
219      options at the end. See `set_printoptions` for the full description of
220      available options.
221  
222      Examples
223      --------
224  
225      >>> from numpy.testing import assert_equal
226      >>> with np.printoptions(precision=2):
227      ...     np.array([2.0]) / 3
228      array([0.67])
229  
230      The `as`-clause of the `with`-statement gives the current print options:
231  
232      >>> with np.printoptions(precision=2) as opts:
233      ...      assert_equal(opts, np.get_printoptions())
234  
235      See Also
236      --------
237      set_printoptions, get_printoptions
238  
239      Nr;)r_rr)�args�kwargsrmr;r;r?rNs�&rr;c	Cs�t|�}||jkr
||S|j|d|kr5tt|||tjd|��t|||tj|d��f|d�St|||tjdd��S)z�
240      Keep only the N-D corners (leading and trailing edges) of an array.
241  
242      Should be passed a base-class ndarray, since it makes no guarantees about
243      preserving subclasses.
244      �N)�axis)�len�ndim�shaper�_leading_trailingr_�	index_exp)�ar/rbrrr;r;r?rvqs
245  ��rvcCs t|�tur	d}nd}|�|�S)z@ Object arrays containing lists should be printed unambiguously z
246  list({!r})z{!r})�type�listrF)�o�fmtr;r;r?�_object_format�s
247  r}cC�t|�Sr:)�repr��xr;r;r?�repr_format��r�cCr~r:)�strr�r;r;r?�
248  str_format�r�r�cs��fdd��fdd�������fdd�������fdd�������fdd�������fdd���fdd��fd	d�d
249  d�dd�dd�d
�}dd�}	�dur��fdd����D�}
250  d|
251  vro|��D]
252  }|	�d�||<qdd|
253  vr�dD]
254  }|	�d�||<qud|
255  vr�dD]
256  }|	�d�||<q�d|
257  vr�dD]
258  }|	�d�||<q�d|
259  vr�|	�d�|d<|��D]}||
260  vr�|	�|�||<q�|S)Nc�t��Sr:)�
261  BoolFormatr;��datar;r?�<lambda>��z!_get_formatdict.<locals>.<lambda>cr�r:)�
IntegerFormatr;r�r;r?r��r�c�t������d�S�Nrh��FloatingFormatr;�r�r1r9r2r7r3r;r?r����cr�r�r�r;r�r;r?r��r�cr�r���ComplexFloatingFormatr;r�r;r?r��r�cr�r�r�r;r�r;r?r��r�cst��d�Sr�)�DatetimeFormatr;)r�r9r;r?r��scr�r:)�TimedeltaFormatr;r�r;r?r��r�cS�tSr:)r}r;r;r;r?r���cSr�r:)r�r;r;r;r?r��r�cSr�r:)r�r;r;r;r?r��r�)rT�int�float�	longfloat�complexfloat�longcomplexfloat�datetime�	timedelta�object�void�numpystrcs�fdd�S)Ncs�Sr:r;r;r�r;r?r��r�z3_get_formatdict.<locals>.indirect.<locals>.<lambda>r;r�r;r�r?�indirect�sz!_get_formatdict.<locals>.indirectcsg|]
262  }�|dur|�qSr:r;)r<r=)r8r;r?�
263  <listcomp>�sz#_get_formatdict.<locals>.<listcomp>�all�int_kind)r��
264  float_kind)r�r�Zcomplex_kind)r�r�Zstr_kindr�)�keys)r�r2r1r3r7r9r8rp�
265  formatdictr��fkeys�keyr;)r�r1r8r9r2r7r3r?�_get_formatdict�sD
266  
267  
268  ��r�cKsL|j}|j}t|fi|��}|dur|d�St|tj�r"|d�St|tj�r8t|tj�r3|d�S|d�St|tj�rNt|tj	�rI|d�S|d�St|tj
269  �rdt|tj�r_|d�S|d	�St|tjtj
f�rr|d�St|tj�r}|d
270  �St|tj�r�|d�St|tj�r�|jdur�tj|fi|��S|d�S|d�S)
z;
271      find the right formatting function for the dtype_
272      Nr�rTr�r�r�r�r�r�r�r�r�)�dtyperyr��
273  issubclass�_ntr$�integer�timedelta64�floatingr��complexfloating�
274  clongfloat�unicode_�string_�
275  datetime64�object_r��names�StructuredVoidFormat�	from_data)r�rcZdtype_Zdtypeobjr�r;r;r?�_get_format_function�s<
276  
277  
278  
279  
280  
281  
282  
283  
284  
285  
286  
287  
288  
289  r��...cs�fdd�}|S)a
290      Like the python 3.2 reprlib.recursive_repr, but forwards *args and **kwargs
291  
292      Decorates a function such that if it calls itself with the same first
293      argument, it returns `fillvalue` instead of recursing.
294  
295      Largely copied from reprlib.recursive_repr
296      cs$t��t������fdd��}|S)Nc	sTt|�t�f}|�vr
�S��|�z�|g|�Ri|��W��|�S��|�wr:)�idr�add�discard)�selfrorpr�)�f�	fillvalue�repr_runningr;r?�wrapper�s
297  z>_recursive_guard.<locals>.decorating_function.<locals>.wrapper)�set�	functools�wraps)r�r��r�)r�r�r?�decorating_function�s
298  z-_recursive_guard.<locals>.decorating_functionr;)r�r�r;r�r?�_recursive_guard�s
299  r�rK�c	
300  Cs�t|�}|jdkr|}|j|dkrd}t||d�}nd}t|fi|��}d}|dt|�7}t|||d|||d||d�}|S)	Nr;r0r�r/r�rKr4r9)rru�sizervr�rs�_formatArray)	rxrc�	separator�prefixr��summary_insert�format_function�next_line_prefix�lstr;r;r?�
_array2strings
301  
302  �r�c
C�|fSr:r;)rx�max_line_widthr2�suppress_smallr�r��styler8r0r/r7r1�suffixr9r;r;r?�_array2string_dispatcher(sr�)�modulec
Cs�t|||	||dd|
303  |||
�}t��}|�|�|ddkr6|tjur$t}|jdkr5|jj	dur5||�
304  ��Sn
|tjurCtjdt
dd�|ddkrS|dt|�8<|jd	krZd
305  St||||�S)a�
306      Return a string representation of an array.
307  
308      Parameters
309      ----------
310      a : ndarray
311          Input array.
312      max_line_width : int, optional
313          Inserts newlines if text is longer than `max_line_width`.
314          Defaults to ``numpy.get_printoptions()['linewidth']``.
315      precision : int or None, optional
316          Floating point precision.
317          Defaults to ``numpy.get_printoptions()['precision']``.
318      suppress_small : bool, optional
319          Represent numbers "very close" to zero as zero; default is False.
320          Very close is defined by precision: if the precision is 8, e.g.,
321          numbers smaller (in absolute value) than 5e-9 are represented as
322          zero.
323          Defaults to ``numpy.get_printoptions()['suppress']``.
324      separator : str, optional
325          Inserted between elements.
326      prefix : str, optional
327      suffix : str, optional
328          The length of the prefix and suffix strings are used to respectively
329          align and wrap the output. An array is typically printed as::
330  
331            prefix + array2string(a) + suffix
332  
333          The output is left-padded by the length of the prefix string, and
334          wrapping is forced at the column ``max_line_width - len(suffix)``.
335          It should be noted that the content of prefix and suffix strings are
336          not included in the output.
337      style : _NoValue, optional
338          Has no effect, do not use.
339  
340          .. deprecated:: 1.14.0
341      formatter : dict of callables, optional
342          If not None, the keys should indicate the type(s) that the respective
343          formatting function applies to.  Callables should return a string.
344          Types that are not specified (by their corresponding keys) are handled
345          by the default formatters.  Individual types for which a formatter
346          can be set are:
347  
348          - 'bool'
349          - 'int'
350          - 'timedelta' : a `numpy.timedelta64`
351          - 'datetime' : a `numpy.datetime64`
352          - 'float'
353          - 'longfloat' : 128-bit floats
354          - 'complexfloat'
355          - 'longcomplexfloat' : composed of two 128-bit floats
356          - 'void' : type `numpy.void`
357          - 'numpystr' : types `numpy.string_` and `numpy.unicode_`
358  
359          Other keys that can be used to set a group of types at once are:
360  
361          - 'all' : sets all types
362          - 'int_kind' : sets 'int'
363          - 'float_kind' : sets 'float' and 'longfloat'
364          - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
365          - 'str_kind' : sets 'numpystr'
366      threshold : int, optional
367          Total number of array elements which trigger summarization
368          rather than full repr.
369          Defaults to ``numpy.get_printoptions()['threshold']``.
370      edgeitems : int, optional
371          Number of array items in summary at beginning and end of
372          each dimension.
373          Defaults to ``numpy.get_printoptions()['edgeitems']``.
374      sign : string, either '-', '+', or ' ', optional
375          Controls printing of the sign of floating-point types. If '+', always
376          print the sign of positive values. If ' ', always prints a space
377          (whitespace character) in the sign position of positive values.  If
378          '-', omit the sign character of positive values.
379          Defaults to ``numpy.get_printoptions()['sign']``.
380      floatmode : str, optional
381          Controls the interpretation of the `precision` option for
382          floating-point types.
383          Defaults to ``numpy.get_printoptions()['floatmode']``.
384          Can take the following values:
385  
386          - 'fixed': Always print exactly `precision` fractional digits,
387            even if this would print more or fewer digits than
388            necessary to specify the value uniquely.
389          - 'unique': Print the minimum number of fractional digits necessary
390            to represent each value uniquely. Different elements may
391            have a different number of digits.  The value of the
392            `precision` option is ignored.
393          - 'maxprec': Print at most `precision` fractional digits, but if
394            an element can be uniquely represented with fewer digits
395            only print it with that many.
396          - 'maxprec_equal': Print at most `precision` fractional digits,
397            but if every element in the array can be uniquely
398            represented with an equal number of fewer digits, use that
399            many digits for all elements.
400      legacy : string or `False`, optional
401          If set to the string `'1.13'` enables 1.13 legacy printing mode. This
402          approximates numpy 1.13 print output by including a space in the sign
403          position of floats and different behavior for 0d arrays. If set to
404          `False`, disables legacy mode. Unrecognized strings will be ignored
405          with a warning for forward compatibility.
406  
407          .. versionadded:: 1.14.0
408  
409      Returns
410      -------
411      array_str : str
412          String representation of the array.
413  
414      Raises
415      ------
416      TypeError
417          if a callable in `formatter` does not return a string.
418  
419      See Also
420      --------
421      array_str, array_repr, set_printoptions, get_printoptions
422  
423      Notes
424      -----
425      If a formatter is specified for a certain type, the `precision` keyword is
426      ignored for that type.
427  
428      This is a very flexible function; `array_repr` and `array_str` are using
429      `array2string` internally so keywords with the same name should work
430      identically in all three functions.
431  
432      Examples
433      --------
434      >>> x = np.array([1e-16,1,2,3])
435      >>> np.array2string(x, precision=2, separator=',',
436      ...                       suppress_small=True)
437      '[0.,1.,2.,3.]'
438  
439      >>> x  = np.arange(3.)
440      >>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x})
441      '[0.00 1.00 2.00]'
442  
443      >>> x  = np.arange(3)
444      >>> np.array2string(x, formatter={'int':lambda x: hex(x)})
445      '[0x0 0x1 0x2]'
446  
447      Nr9rMr;zT'style' argument is deprecated and no longer functional except in 1.13 'legacy' moder(rPr4rz[])rfrirlrjr_�_NoValuerrur�r��itemrYrZ�DeprecationWarningrsr�r�)rxr�r2r�r�r�r�r8r0r/r7r1r�r9�	overridesrcr;r;r?r1s,�
448  
449  �
450  �
451  rcCsXt|�t|�|k}|dkrt|�t|�krd}|r$||��d7}|}||7}||fS)NrMF�
452  )rs�rstrip)�s�line�word�
453  line_widthr�r9Z
454  needs_wrapr;r;r?�_extendLine�sr�c
455  Cs�|��}t|�dks|dkrt||||||�Stdd�|D��}t|�||krAt|�t|�krA||��d7}||d}|}nt|�d}||d7}|dd�D]}||��d7}||}qS|t|d	�}	||	d7}||fS)
456  zS
457      Extends line with nicely formatted (possibly multi-line) string ``word``.
458      r
rMcs��|]}t|�VqdSr:�rs)r<r�r;r;r?rH���z%_extendLine_pretty.<locals>.<genexpr>r�rrKN�����)�
459  splitlinesrsr��maxr�)
460  r�r�r�r�r�r9�wordsZmax_word_length�indentZ
suffix_lengthr;r;r?�_extendLine_pretty�s"
461  r�cs4�������fdd��z
462  �d||d�Wd�Sd�w)zgformatArray is designed for two modes of operation:
463  
464      1. Full output
465  
466      2. Summarized output
467  
468      cs�t|�}�j|}|dkr��|�S|d}�dkr|}n|td�}�j|}�o0d�|k}|r8�}	�}
469  nd}	|}
470  d}|dkr׈dkrO|t����}n
|tt����td��}|}
t|	�D]}�||f||�}t||
|||��\}}
|
�7}
qb|r�t||
�||��\}}
�dkr�|
d7}
n|
�7}
t|
471  dd	�D]}�||f||�}t||
|||��\}}
|
�7}
q��dkr�|}�|d
472  ||�}t||
|||��\}}
||
7}ngd}���d|d}t|	�D]}�||f||�}||||7}q�|�r�dk�r||�d7}n||�|7}t|
473  dd	�D]}�||f||�}||||7}�q�|d
474  ||�}|||7}d
|t|�d�d}|S)z�
475          By using this local function, we don't need to recurse with all the
476          arguments. Since this function is not created recursively, the cost is
477          not significant
478          rrKrM�]rqr�r
rDr�)r�r�z, 
479  �[N)rsrtrur�r��ranger�r�)rb�hanging_indent�
480  curr_widthrrZ	axes_leftZnext_hanging_indentZ
481  next_widthZa_lenZshow_summaryZ
leading_itemsZtrailing_itemsr�Z
482  elem_widthr��ir��line_sep�nested�rx�
483  edge_itemsr�r9�recurserr�r�r;r?r�s�
484  
485  �
486  �
487  �
488  �
489  
490  �z_formatArray.<locals>.recurserr;)rbr�r�Nr;)rxr�r�r�r�r�r�r9r;r�r?r�s	b�r�cCs&|durdS|dkrtd�|���|S)Nr�rz{} must be >= 0)rUrF)r��namer;r;r?�_none_or_positive_arg�s
491  r�c@s0eZdZdZddd�dd�Zdd�Zd	d
492  �ZdS)r�z' Formatter for subtypes of np.floating FNrhcCs�t|t�r|r	dnd}||_|jdkr|jdkr|dkrd}||_|dkr)d|_n||_t|jd�|_||_||_d|_	d|_
493  |�|�dS)	NrJr.rMr;rKrBr2F)r[rT�_legacyrur1r2r�r�r7�
494  exp_formatZlarge_exponent�
495  fillFormat)r�r�r2r1r�r7r9r;r;r?�__init__�s 
496  
497  zFloatingFormat.__init__cs |t|�}t||dk�}t|�dkrGt�|�}t�|�}tdd��|dks5�js8|dks5||dkr8d�_Wd�n1sBwYt|�dkr`d�_	d�_
498  d�_d	�_d�_
d�_nۈjr�d
499  \���jdksq�jdkrud
\�����fdd�|D�}tdd�|D��\}}}	tdd�|D��\}
500  }tdd�|	D��d�_d�_tdd�|D���_�j�_��_
�jdkr�d�_	n
501  tdd�|
502  D���_	�jd�j�_
503  ngd
504  \���jdkr�d
\�����fdd�|D�}tdd�|D��\}
505  }�jdk�r
506  dtdd�|
507  D���_	n
508  tdd�|
509  D���_	tdd�|D���_
510  d	�_��_
�jdv�r5�j
511  �_�_d�_nd�_d�_�jdk�rV�jdk�rVtt�|���sV�j	d7_	|j|jk�r��jd k�plt|t|�dk�}ttd!�}
ttd"�|}�j
512  d}t�j	|
|||��_	dSdS)#Nr�ignore)�overg�חAg-C��6?g@�@T�.r�)rTrArM)r=Fc3s*�|]}t|�j���jdkd�VqdS)rJ)r2rB�trimr7N)rr2r7�r<r��r�rrBr;r?rH�s���z,FloatingFormat.fillFormat.<locals>.<genexpr>cs��|]}|�d�VqdS)reN)�	partition�r<r�r;r;r?rH�rIcsr�rN��splitr
513  r;r;r?rH�rIcsr�r:r�r
514  r;r;r?rH�r�r
r=csr�r:r�r
515  r;r;r?rH�r�r(csr�r:r�r
516  r;r;r?rH�r�rqc	3s,�|]}t|�jd���jdkd�VqdS)TrJ)r2�
517  fractionalrBrr7N)rr2r7rrr;r?rH�s���csrrrr
518  r;r;r?rH�rIcss�|]
519  }t|�d��VqdS)z-+N)rs�lstripr
520  r;r;r?rH�s�csr�r:r�r
521  r;r;r?rH�r�csr�r:r�r
522  r;r;r?rH�r�)rArCrKr.r5r6)rrrsr_r��minrr�r��pad_left�	pad_rightr�exp_sizerB�
523  min_digitsr1r��zipr2r7r�signbitr�rri)r�r�Zfinite_valsZabs_non_zero�max_val�min_val�strsZ	frac_strs�_Zexp_strsZint_partZ	frac_part�neginfZnanlenZinflen�offsetr;rr?r�s�
524  
525  ���
526  
527  � 
528  �zFloatingFormat.fillFormatcCst�|�sTtdd��Bt�|�r |jdkrdnd}|td}n|dkr&dn|jdkr-dnd}|td}d	|j|jd
529  t|�|Wd�S1sOwY|j	rlt
530  ||j|j|j
|j|jdk|j|jd�St||j|j|j
d|j|jdk|j|jd
�	S)Nr)�invalidrJr�r5rr.r6rKr
)r2rrBrr7r�
531  exp_digitsT)r2rrBrrr7rr)r_rrr`r7rirrrsr�rr2rrBrrr)r�r�r7�retr;r;r?�__call__�s:
532  
533   �	�	�zFloatingFormat.__call__�F)�__name__�
534  __module__�__qualname__�__doc__rrr r;r;r;r?r��s�Tr�Tr=c
535  Cs`t|d�}t|d�}t|d�}t|d�}|dkr$|dkr$||kr$td��t||||||||d�S)a�
536  
537      Format a floating-point scalar as a decimal string in scientific notation.
538  
539      Provides control over rounding, trimming and padding. Uses and assumes
540      IEEE unbiased rounding. Uses the "Dragon4" algorithm.
541  
542      Parameters
543      ----------
544      x : python float or numpy floating scalar
545          Value to format.
546      precision : non-negative integer or None, optional
547          Maximum number of digits to print. May be None if `unique` is
548          `True`, but must be an integer if unique is `False`.
549      unique : boolean, optional
550          If `True`, use a digit-generation strategy which gives the shortest
551          representation which uniquely identifies the floating-point number from
552          other values of the same type, by judicious rounding. If `precision`
553          is given fewer digits than necessary can be printed. If `min_digits`
554          is given more can be printed, in which cases the last digit is rounded
555          with unbiased rounding.
556          If `False`, digits are generated as if printing an infinite-precision
557          value and stopping after `precision` digits, rounding the remaining
558          value with unbiased rounding
559      trim : one of 'k', '.', '0', '-', optional
560          Controls post-processing trimming of trailing digits, as follows:
561  
562          * 'k' : keep trailing zeros, keep decimal point (no trimming)
563          * '.' : trim all trailing zeros, leave decimal point
564          * '0' : trim all but the zero before the decimal point. Insert the
565            zero if it is missing.
566          * '-' : trim trailing zeros and any trailing decimal point
567      sign : boolean, optional
568          Whether to show the sign for positive values.
569      pad_left : non-negative integer, optional
570          Pad the left side of the string with whitespace until at least that
571          many characters are to the left of the decimal point.
572      exp_digits : non-negative integer, optional
573          Pad the exponent with zeros until it contains at least this many digits.
574          If omitted, the exponent will be at least 2 digits.
575      min_digits : non-negative integer or None, optional
576          Minimum number of digits to print. This only has an effect for
577          `unique=True`. In that case more digits than necessary to uniquely
578          identify the value may be printed and rounded unbiased.
579  
580          -- versionadded:: 1.21.0
581          
582      Returns
583      -------
584      rep : string
585          The string representation of the floating point value
586  
587      See Also
588      --------
589      format_float_positional
590  
591      Examples
592      --------
593      >>> np.format_float_scientific(np.float32(np.pi))
594      '3.1415927e+00'
595      >>> s = np.float32(1.23e24)
596      >>> np.format_float_scientific(s, unique=False, precision=15)
597      '1.230000071797338e+24'
598      >>> np.format_float_scientific(s, exp_digits=4)
599      '1.23e+0024'
600      r2rrrr�2min_digits must be less than or equal to precision)r2rBrr7rrr)r�rUr)r�r2rBrr7rrrr;r;r?r	s
601  E
602  
603  
604  �r	c		Csvt|d�}t|d�}t|d�}t|d�}|s|dkrtd��|dkr.|dkr.||kr.td��t|||||||||d�	S)	a�
605      Format a floating-point scalar as a decimal string in positional notation.
606  
607      Provides control over rounding, trimming and padding. Uses and assumes
608      IEEE unbiased rounding. Uses the "Dragon4" algorithm.
609  
610      Parameters
611      ----------
612      x : python float or numpy floating scalar
613          Value to format.
614      precision : non-negative integer or None, optional
615          Maximum number of digits to print. May be None if `unique` is
616          `True`, but must be an integer if unique is `False`.
617      unique : boolean, optional
618          If `True`, use a digit-generation strategy which gives the shortest
619          representation which uniquely identifies the floating-point number from
620          other values of the same type, by judicious rounding. If `precision`
621          is given fewer digits than necessary can be printed, or if `min_digits`
622          is given more can be printed, in which cases the last digit is rounded
623          with unbiased rounding.
624          If `False`, digits are generated as if printing an infinite-precision
625          value and stopping after `precision` digits, rounding the remaining
626          value with unbiased rounding
627      fractional : boolean, optional
628          If `True`, the cutoffs of `precision` and `min_digits` refer to the
629          total number of digits after the decimal point, including leading
630          zeros.
631          If `False`, `precision` and `min_digits` refer to the total number of
632          significant digits, before or after the decimal point, ignoring leading
633          zeros.
634      trim : one of 'k', '.', '0', '-', optional
635          Controls post-processing trimming of trailing digits, as follows:
636  
637          * 'k' : keep trailing zeros, keep decimal point (no trimming)
638          * '.' : trim all trailing zeros, leave decimal point
639          * '0' : trim all but the zero before the decimal point. Insert the
640            zero if it is missing.
641          * '-' : trim trailing zeros and any trailing decimal point
642      sign : boolean, optional
643          Whether to show the sign for positive values.
644      pad_left : non-negative integer, optional
645          Pad the left side of the string with whitespace until at least that
646          many characters are to the left of the decimal point.
647      pad_right : non-negative integer, optional
648          Pad the right side of the string with whitespace until at least that
649          many characters are to the right of the decimal point.
650      min_digits : non-negative integer or None, optional
651          Minimum number of digits to print. Only has an effect if `unique=True`
652          in which case additional digits past those necessary to uniquely
653          identify the value may be printed, rounding the last additional digit.
654          
655          -- versionadded:: 1.21.0
656  
657      Returns
658      -------
659      rep : string
660          The string representation of the floating point value
661  
662      See Also
663      --------
664      format_float_scientific
665  
666      Examples
667      --------
668      >>> np.format_float_positional(np.float32(np.pi))
669      '3.1415927'
670      >>> np.format_float_positional(np.float16(np.pi))
671      '3.14'
672      >>> np.format_float_positional(np.float16(0.3))
673      '0.3'
674      >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
675      '0.3000488281'
676      r2rrrrz4precision must be greater than 0 if fractional=Falser&)r2rBrrr7rrr)r�rUr)	r�r2rBrrr7rrrr;r;r?rjs
677  M
678  
679  
680  �rc@�eZdZdd�Zdd�ZdS)r�cCsF|jdkrtttt�|���ttt�|����}nd}d�|�|_dS)Nrz%{}d)r�r�rsr�r_rrF)r�r��max_str_lenr;r;r?r�s
681  �zIntegerFormat.__init__cCs
682  |j|Sr:rE�r�r�r;r;r?r ��
683  zIntegerFormat.__call__N�r"r#r$rr r;r;r;r?r��sr�c@r')r�cKs|jdkr
684  d|_dSd|_dS)Nr;z True�True)ru�truestr)r�r�rpr;r;r?r�szBoolFormat.__init__cCs|r|jSdS)N�False)r-r)r;r;r?r ��zBoolFormat.__call__Nr+r;r;r;r?r��sr�c@s*eZdZdZ	d	dd�dd�Zdd�ZdS)
685  r�z. Formatter for subtypes of np.complexfloating FNrhc	Csbt|t�r|r	dnd}|}}|dkrd}d}t|j|||||d�|_t|j|||d|d�|_dS)NrJr.rMrCr))r7r9)r[rTr��real�real_format�imag�imag_format)	r�r�r2r1r�r7r9Zfloatmode_realZfloatmode_imagr;r;r?r�s
686  
687  �
688  �zComplexFloatingFormat.__init__cCsH|�|j�}|�|j�}t|���}|d|�d||d�}||S)N�j)r1r0r3r2rsr�)r�r��rr��spr;r;r?r �s
689  zComplexFloatingFormat.__call__r!)r"r#r$r%rr r;r;r;r?r��s��r�c@s$eZdZdd�Zdd�Zdd�ZdS)�_TimelikeFormatcCs~|t|�}t|�dkr#tt|�t�|���t|�t�|����}nd}t|�|jkr1t|d�}d�|�|_d�	|�|_
690  dS)Nr�z%{}sz'NaT')rrsr��_format_non_natr_rr�rF�_format�rjust�_nat)r�r�Znon_natr(r;r;r?r�s�
691  z_TimelikeFormat.__init__cCst�r:)�NotImplementedErrorr)r;r;r?r9
sz_TimelikeFormat._format_non_natcCst|�r|jS|j|�|�Sr:)rr<r:r9r)r;r;r?r sz_TimelikeFormat.__call__N)r"r#r$rr9r r;r;r;r?r7�sr7cs6eZdZ		d
692  �fdd�	Z�fdd�Zdd	�Z�ZS)r�N�	same_kindFcs\|dur|jjdkrt|j�d}nd}|durd}||_||_||_||_t��|�dS)N�Mrr��naive)	r��kindr�timezone�unit�castingr9�superr)r�r�rCrBrDr9��	__class__r;r?rszDatetimeFormat.__init__cs |jdkr
693  |�|�St��|�S)NrM)r9r9rEr r)rFr;r?r ,s
694  
695  zDatetimeFormat.__call__cCsdt||j|j|jd�S)N�'%s')rCrBrD)rrCrBrDr)r;r;r?r91s
696  �zDatetimeFormat._format_non_nat)NNr>F)r"r#r$rr r9�
__classcell__r;r;rFr?r�s�r�c@seZdZdd�ZdS)r�cCst|�d��S)N�i8)r��astyper)r;r;r?r99r/zTimedeltaFormat._format_non_natN)r"r#r$r9r;r;r;r?r�8sr�c@r')�SubArrayFormatcC�
697  ||_dSr:�r�)r�r�r;r;r?r>r*zSubArrayFormat.__init__csJ|jdkrdd��fdd�|D��dSdd��fdd�|D��dS)Nr
r�rDc3��|]}��|�VqdSr:rN�r<rx�r�r;r?rHCrIz*SubArrayFormat.__call__.<locals>.<genexpr>r�c3rOr:)r rPrQr;r?rHDrI)rtrV)r��arrr;rQr?r As
698    zSubArrayFormat.__call__Nr+r;r;r;r?rL=srLc@s,eZdZdZdd�Zedd��Zdd�ZdS)	r�z�
699      Formatter for structured np.void objects.
700  
701      This does not work on structured alias types like np.dtype(('i4', 'i2,i2')),
702      as alias scalars lose their field information, and the implementation
703      relies upon np.void.__getitem__.
704      cCrMr:)�format_functions)r�rSr;r;r?rOr*zStructuredVoidFormat.__init__cKsPg}|jjD]}t||fi|��}|j|jdkrt|�}|�|�q||�S)z�
705          This is a second way to initialize StructuredVoidFormat, using the raw data
706          as input. Added to avoid changing the signature of __init__.
707          r;)r�r�r�rurL�append)�clsr�rcrS�
708  field_namer�r;r;r?r�RszStructuredVoidFormat.from_datacCs@dd�t||j�D�}t|�dkrd�|d�Sd�d�|��S)NcSsg|]\}}||��qSr;r;)r<�fieldr�r;r;r?r�as��z1StructuredVoidFormat.__call__.<locals>.<listcomp>r
z({},)rz({})rD)rrSrsrFrV)r�r�Z
709  str_fieldsr;r;r?r `s
710  �zStructuredVoidFormat.__call__N)r"r#r$r%r�classmethodr�r r;r;r;r?r�Gs
711  
r�cCstjt|�fit��|�S)z�
712      Implements the repr for structured-void scalars. It is called from the
713      scalartypes.c.src code, and is placed here because it uses the elementwise
714      formatters defined above.
715      )r�r�rrir�r;r;r?�_void_scalar_reprksrYcCs<t�|�}tddkr|jtkrdS|jdurdS|jtvS)a
716      Determine if the given dtype is implied by the representation of its values.
717  
718      Parameters
719      ----------
720      dtype : dtype
721          Data type
722  
723      Returns
724      -------
725      implied : bool
726          True if the dtype is implied by the representation of its values.
727  
728      Examples
729      --------
730      >>> np.core.arrayprint.dtype_is_implied(int)
731      True
732      >>> np.array([1, 2, 3], int)
733      array([1, 2, 3])
734      >>> np.core.arrayprint.dtype_is_implied(np.int8)
735      False
736      >>> np.array([1, 2, 3], np.int8)
737      array([1, 2, 3], dtype=int8)
738      r9rMFN)r_r�riryr$r��
_typelessdata)r�r;r;r?�dtype_is_impliedws
739  
740  
741  r[cCsnt|�jtjjkr
t|�S|jdurt|�St|jt�r"dt|�S|j	}|r5|d�
742  �r1|��s5t|�}|S)z�
743      Convert a dtype to a short form which evaluates to the same dtype.
744  
745      The intent is roughly that the following holds
746  
747      >>> from numpy import *
748      >>> dt = np.int64([1, 2]).dtype
749      >>> assert eval(dtype_short_repr(dt)) == dt
750      NrHr)ry�__repr__r_r�rr�r�r�r%r��isalpha�isalnum)r��typenamer;r;r?�dtype_short_repr�s
751  
752  r`c	Cs^|durtd}t|�turt|�j}nd}t|j�o|jdk}|d}|r(dnd}tdd	kr@|jd
753  kr@|jjs@t	|�
754  ��}	n|jdksJ|jdkrV|||||d||d
�}	ndt	|j�f}	||	|}
755  |rh|
756  Sd�t|j��}t
|
757  �|
758  �d�d}d}
tdd	kr�t|jjt�r�ddt
|d�}
n|t
|�d|kr�ddt
|d�}
|
759  |
|S)zEInternal version of array_repr() that allows overriding array2string.Nr4rr�(�)�,r9rMr;)rrD)r�z[], shape=%sz	dtype={})r�r
rK)riryrr"r[r�r�rur�rr�rFr`rs�rfindr�r%)rRr�r2r�r�
760  class_nameZ	skipdtyper�r�r�Zarr_str�	dtype_strZ
last_line_len�spacerr;r;r?�_array_repr_implementation�s:
761  ��rhcCr�r:r;�rRr�r2r�r;r;r?�_array_repr_dispatcher��rjcC�t||||�S)a

762      Return the string representation of an array.
763  
764      Parameters
765      ----------
766      arr : ndarray
767          Input array.
768      max_line_width : int, optional
769          Inserts newlines if text is longer than `max_line_width`.
770          Defaults to ``numpy.get_printoptions()['linewidth']``.
771      precision : int, optional
772          Floating point precision.
773          Defaults to ``numpy.get_printoptions()['precision']``.
774      suppress_small : bool, optional
775          Represent numbers "very close" to zero as zero; default is False.
776          Very close is defined by precision: if the precision is 8, e.g.,
777          numbers smaller (in absolute value) than 5e-9 are represented as
778          zero.
779          Defaults to ``numpy.get_printoptions()['suppress']``.
780  
781      Returns
782      -------
783      string : str
784        The string representation of an array.
785  
786      See Also
787      --------
788      array_str, array2string, set_printoptions
789  
790      Examples
791      --------
792      >>> np.array_repr(np.array([1,2]))
793      'array([1, 2])'
794      >>> np.array_repr(np.ma.array([0.]))
795      'MaskedArray([0.])'
796      >>> np.array_repr(np.array([], np.int32))
797      'array([], dtype=int32)'
798  
799      >>> x = np.array([1e-6, 4e-7, 2, 3])
800      >>> np.array_repr(x, precision=6, suppress_small=True)
801      'array([0.000001,  0.      ,  2.      ,  3.      ])'
802  
803      )rhrir;r;r?r�s-�rcCst|t�r	t|�St|�Sr:)r[�bytesrr�)r>r;r;r?�_guarded_repr_or_strs
804  rncCsXtddkr|jdkr|jjst|���S|jdkr#ttj�	|d��S|||||dd�S)zDInternal version of array_str() that allows overriding array2string.r9rMr;rKr�)
805  rirur�r�r�r�rnr_r�__getitem__)rxr�r2r�rr;r;r?�_array_str_implementation#s
806  rpcCr�r:r;�rxr�r2r�r;r;r?�_array_str_dispatcher7rkrrcCrl)aa
807      Return a string representation of the data in an array.
808  
809      The data in the array is returned as a single string.  This function is
810      similar to `array_repr`, the difference being that `array_repr` also
811      returns information on the kind of array and its data type.
812  
813      Parameters
814      ----------
815      a : ndarray
816          Input array.
817      max_line_width : int, optional
818          Inserts newlines if text is longer than `max_line_width`.
819          Defaults to ``numpy.get_printoptions()['linewidth']``.
820      precision : int, optional
821          Floating point precision.
822          Defaults to ``numpy.get_printoptions()['precision']``.
823      suppress_small : bool, optional
824          Represent numbers "very close" to zero as zero; default is False.
825          Very close is defined by precision: if the precision is 8, e.g.,
826          numbers smaller (in absolute value) than 5e-9 are represented as
827          zero.
828          Defaults to ``numpy.get_printoptions()['suppress']``.
829  
830      See Also
831      --------
832      array2string, array_repr, set_printoptions
833  
834      Examples
835      --------
836      >>> np.array_str(np.arange(3))
837      '[0 1 2]'
838  
839      )rprqr;r;r?r<s$�r�__wrapped__)rcCs0|dur|rt�td�St�td�St�||�S)a�
840      Set a Python function to be used when pretty printing arrays.
841  
842      Parameters
843      ----------
844      f : function or None
845          Function to be used to pretty print arrays. The function should expect
846          a single array argument and return a string of the representation of
847          the array. If None, the function is reset to the default NumPy function
848          to print arrays.
849      repr : bool, optional
850          If True (default), the function for pretty printing (``__repr__``)
851          is set, if False the function that returns the default string
852          representation (``__str__``) is set.
853  
854      See Also
855      --------
856      set_printoptions, get_printoptions
857  
858      Examples
859      --------
860      >>> def pprint(arr):
861      ...     return 'HA! - What are you going to do now?'
862      ...
863      >>> np.set_string_function(pprint)
864      >>> a = np.arange(10)
865      >>> a
866      HA! - What are you going to do now?
867      >>> _ = a
868      >>> # [0 1 2 3 4 5 6 7 8 9]
869  
870      We can reset the function to the default:
871  
872      >>> np.set_string_function(None)
873      >>> a
874      array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
875  
876      `repr` affects either pretty printing or normal string representation.
877      Note that ``__repr__`` is still affected by setting ``__str__``
878      because the width of each array element in the returned string becomes
879      equal to the length of the result of ``__str__()``.
880  
881      >>> x = np.arange(4)
882      >>> np.set_string_function(lambda x:'random', repr=False)
883      >>> x.__str__()
884      'random'
885      >>> x.__repr__()
886      'array([0, 1, 2, 3])'
887  
888      Nr
r)rr�_default_array_repr�_default_array_str)r�rr;r;r?rls
889  3r)NNNNNNNNNNN)
890  NNNNNNNNNN)r;)r�)rKr�)NNNNNNNNNNNN)NTr=FNNN)NTTr=FNNN)NNN)T)br%�__all__�
__docformat__r�r\rW�_threadr�ImportError�
_dummy_threadrgr_r�rr��umathrrrrrrrrrrrr�fromnumericr�numericrrrrr r!r"r#r$r%r�r&r'rarY�
891  contextlibrXrirfrrrn�contextmanagerrrvr}r�r�r�r�r�r�r�r�rr�r�r�r�r�r	rr�r�r�r7r�r�rLr�rYrZr[r`rhrjrrnrprrr�getattr�_array2string_impl�partialrurtrr;r;r;r?�<module>s�$$�
892  �4��3
893  !
894  !1
895  )��
896  	��2v�O�[

897  ! 
898  $	$
899  �0
900901  0
902  
903  �
904905  (��