File: //opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyc
�
��]c @` s� d Z d d l m Z m Z m Z d d l m Z d d l m Z m Z m
Z
d d g Z d Z e
e � Z d � Z d � Z d
� Z d � Z d � Z d
� Z d � Z d S( s&
Implementation of optimized einsum.
i ( t divisiont absolute_importt print_function( t c_einsum( t asarrayt
asanyarrayt result_typet einsumt einsum_patht4 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZc C` s) d } x | D] } | | | 9} q
W| S( s�
Computes the product of the elements in indices based on the dictionary
idx_dict.
Parameters
----------
indices : iterable
Indices to base the product on.
idx_dict : dictionary
Dictionary of index sizes
Returns
-------
ret : int
The resulting product.
Examples
--------
>>> _compute_size_by_dict('abbc', {'a': 2, 'b':3, 'c':5})
90
i ( ( t indicest idx_dictt rett i( ( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyt _compute_size_by_dict s
c
C` s� t � } | j � } g } xJ t | � D]< \ } } | | k rM | | O} q( | j | � | | O} q( W| | @} | | } | j | � | | | | f S( s
Finds the contraction for a given set of input and output sets.
Parameters
----------
positions : iterable
Integer positions of terms used in the contraction.
input_sets : list
List of sets that represent the lhs side of the einsum subscript
output_set : set
Set that represents the rhs side of the overall einsum subscript
Returns
-------
new_result : set
The indices of the resulting contraction
remaining : list
List of sets that have not been contracted, the new set is appended to
the end of this list
idx_removed : set
Indices removed from the entire contraction
idx_contraction : set
The indices used in the current contraction
Examples
--------
# A simple dot product test case
>>> pos = (0, 1)
>>> isets = [set('ab'), set('bc')]
>>> oset = set('ac')
>>> _find_contraction(pos, isets, oset)
({'a', 'c'}, [{'a', 'c'}], {'b'}, {'a', 'b', 'c'})
# A more complex case with additional terms in the contraction
>>> pos = (0, 2)
>>> isets = [set('abd'), set('ac'), set('bdc')]
>>> oset = set('ac')
>>> _find_contraction(pos, isets, oset)
({'a', 'c'}, [{'a', 'c'}, {'a', 'c'}], {'b', 'd'}, {'a', 'b', 'c', 'd'})
( t sett copyt enumeratet append(
t positionst
input_setst
output_sett idx_contractt
idx_remaint remainingt indt valuet
new_resultt idx_removed( ( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyt _find_contraction- s +
c C` s� d g | f g } xQt t | � d � D]9} g } g } xY t t | � | � D]A } x8 t | d t | � | � D] } | j | | f � qv WqR Wx� | D]� }
|
\ } } }
x� | D]� } t | |
| � } | \ } } } } t | | � } | | k rq� n t | | � } | r'| d 9} n | | 7} | | g } | j | | | f � q� Wq� W| } q) Wt | � d k r�t t t | � � � g St | d d � �d } | S( s�
Computes all possible pair contractions, sieves the results based
on ``memory_limit`` and returns the lowest cost path. This algorithm
scales factorial with respect to the elements in the list ``input_sets``.
Parameters
----------
input_sets : list
List of sets that represent the lhs side of the einsum subscript
output_set : set
Set that represents the rhs side of the overall einsum subscript
idx_dict : dictionary
Dictionary of index sizes
memory_limit : int
The maximum number of elements in a temporary array
Returns
-------
path : list
The optimal contraction order within the memory limit constraint.
Examples
--------
>>> isets = [set('abd'), set('ac'), set('bdc')]
>>> oset = set('')
>>> idx_sizes = {'a': 1, 'b':2, 'c':3, 'd':4}
>>> _path__optimal_path(isets, oset, idx_sizes, 5000)
[(0, 2), (0, 1)]
i i i t keyc S` s | d S( Ni ( ( t x( ( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyt <lambda>� t ( t ranget lenR R R t tuplet min( R R R t memory_limitt full_resultst iterationt iter_resultst comb_iterR t yt currt costR R t cont contR t new_input_setsR R t new_sizet new_costt new_post path( ( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyt
_optimal_pathi s4 $
c C` s� t | � d k r d g Sg } xtt t | � d � D]\} g } g } xQ t t | � � D]= } x4 t | d t | � � D] } | j | | f � q{ Wq[ Wx� | D]� }
t |
| | � } | \ } }
} } t | | � | k r� q� n t | | � } t | | � } | | f } | j | |
|
g � q� Wt | � d k rb| j t t t | � � � � Pn t | d d � �} | j | d � | d } q6 W| S( s�
Finds the path by contracting the best pair until the input list is
exhausted. The best pair is found by minimizing the tuple
``(-prod(indices_removed), cost)``. What this amounts to is prioritizing
matrix multiplication or inner product operations, then Hadamard like
operations, and finally outer operations. Outer products are limited by
``memory_limit``. This algorithm scales cubically with respect to the
number of elements in the list ``input_sets``.
Parameters
----------
input_sets : list
List of sets that represent the lhs side of the einsum subscript
output_set : set
Set that represents the rhs side of the overall einsum subscript
idx_dict : dictionary
Dictionary of index sizes
memory_limit_limit : int
The maximum number of elements in a temporary array
Returns
-------
path : list
The greedy contraction order within the memory limit constraint.
Examples
--------
>>> isets = [set('abd'), set('ac'), set('bdc')]
>>> oset = set('')
>>> idx_sizes = {'a': 1, 'b':2, 'c':3, 'd':4}
>>> _path__greedy_path(isets, oset, idx_sizes, 5000)
[(0, 2), (0, 1)]
i i R c S` s | d S( Ni ( ( R ( ( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyR � R! i ( i ( R# R" R R R R$ R% ( R R R R& R4 R( t iteration_resultsR* R R+ R t contractt
idx_resultR0 R R t removed_sizeR- t sortt best( ( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyt _greedy_path� s2 #
c C` s� t | � d k r! t d � � n t | d t � r� | d j d d � } g | d D] } t | � ^ qU } x�| D]7 } | d k r� qt n | t k rt t d | � � qt qt Wn�t | � } g } g } xJ t t | � d � D]2 } | j | j
d � � | j | j
d � � q� Wt | � r-| d n d } g | D] } t | � ^ q:} d } t | � d } x� t | � D]{ \ }
} xS | D]K } | t
k r�| d
7} q�t | t � r�| t | 7} q�t d � � q�W|
| k ru| d 7} ququW| d k rc| d
7} xV | D]K } | t
k r0| d
7} qt | t � rP| t | 7} qt d � � qWn d | k s{d | k r�| j d � d k p�| j d � d k } | s�| j d
� d k r�t d � � q�n d | k r�| j d d � j d d � j d
d � }
t t t |
� � } d j | � } d } d
| k rl| j d
� \ } } | j d � } t } n | j d � } t } x t | � D]\ }
} d | k r�| j d � d k s�| j d
� d k r�t d � � n | |
j d k r�d } n* t | |
j d � } | t | � d 8} | | k r:| } n | d k rUt d � � q�| d k rz| j d
d � | |
<q�| | } | j d
| � | |
<q�q�Wd j | � } | d k r�d } n | | } | r�| d
| j d
| � 7} q�d } | j d d � } x[ t t | � � D]G } | t k rDt d | � � n | j | � d k r | | 7} q q Wd j t t | � t | � � � } | d
| | 7} n d
| k r�| j d
� \ } } n| | } | j d d � } d } x[ t t | � � D]G } | t k r t d | � � n | j | � d k r�| | 7} q�q�Wx- | D]% } | | k rKt d | � � qKqKWt | j d � � t | � k r�t d � � n | | | f S( sj
A reproduction of einsum c side einsum parsing in python.
Returns
-------
input_strings : str
Parsed input strings
output_string : str
Parsed output string
operands : list of array_like
The operands to use in the numpy contraction
Examples
--------
The operand list is simplified to reduce printing:
>>> a = np.random.rand(4, 4)
>>> b = np.random.rand(4, 4, 4)
>>> __parse_einsum_input(('...a,...a->...', a, b))
('za,xza', 'xz', [a, b])
>>> __parse_einsum_input((a, [Ellipsis, 0], b, [Ellipsis, 0]))
('za,xza', 'xz', [a, b])
i s No input operandst R! i s .,->s# Character %s is not a valid symbol.i i����s ...s= For this input type lists must contain either int or Ellipsist ,s ->t -t >s% Subscripts can only contain one '->'.t .i s Invalid Ellipses.s Ellipses lengths do not match.s/ Output character %s did not appear in the inputsD Number of einsum subscripts must be equal to the number of operands.N( ( R# t
ValueErrort
isinstancet strt replaceR t einsum_symbolst listR" R t popt NoneR t Ellipsist intt TypeErrort countt einsum_symbols_setR t joint splitt Truet Falset shapet maxt ndimt sorted( t operandst
subscriptst vt st tmp_operandst operand_listt subscript_listt pt output_listt lastt numt subt invalidt usedt unusedt ellipse_indst longestt input_tmpt
output_subt split_subscriptst out_subt
ellipse_countt rep_indst out_ellipset output_subscriptt tmp_subscriptst normal_indst input_subscriptst char( ( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyt _parse_einsum_input s� #
* * *
!c : O` sF d d g } g | j � D] \ } } | | k r | ^ q } t | � r\ t d | � � n | j d t � } | t k r� d } n | d" k r� t } n d" } | t k sLt | t � r� n� t | � r� | d d k r� nq t | � d k r6t | d t � r6t | d t t
f � r6t | d � } | d } n t d t | � � � | j d t � } t | � \ } }
} | d
|
} | j d � } g | D] }
t
|
� ^ q�} t
|
� } t
| j d d � � } i } x� t | � D]� \ } } | | j } t | � t | � k r0t d
| | | � � n xh t | � D]Z \ } } | | } | | j � k r�| | | k r�t d | | � � q�q=| | | <q=Wq�Wg } x+ | |
g D] } | j t | | � � q�Wt | � } | d" k r�| } n | } t | | � } | j d d � } t t | � d d � } t | � t t
| � � r]| d 9} n | | 9} | t k s�t | � d# k s�| | k r�t t t | � � � g } n� | d k r�t | | � } t | | | | � } nP | d k rt | | | | � } n, | d d k r#| d } n t d | � � g g g g f \ } } } }! x�t | � D]�\ } }" t t t |" � d t �� }" t |" | | � }# |# \ }$ } }% }& t |& | � }' |% r�|' d 9}' n | j |' � | j t |& � � | j t |$ | � � g }( x$ |" D] }
|( j | j |
� � qW| t | � d k rO|
}) nO g |$ D] }* | |* |* f ^ qV}+ d j g t |+ � D] }
|
d ^ q�� }) | j |) � d j |( � d
|) }, |" |% |, | f }- |! j |- � q]Wt | � d }. | r| |! f S| d
|
}/ d$ }0 | |. }1 t | � }2 d |/ }3 |3 d t | � 7}3 |3 d t | � 7}3 |3 d | 7}3 |3 d |. 7}3 |3 d |1 7}3 |3 d |2 7}3 |3 d d d 7}3 |3 d |0 7}3 |3 d d 7}3 xd t |! � D]V \ }4 }- |- \ }5 }6 }, }7 d j |7 � d
|
}8 | |4 |, |8 f }9 |3 d! |9 7}3 q�Wd g | } | |3 f S(% s�
einsum_path(subscripts, *operands, optimize='greedy')
Evaluates the lowest cost contraction order for an einsum expression by
considering the creation of intermediate arrays.
Parameters
----------
subscripts : str
Specifies the subscripts for summation.
*operands : list of array_like
These are the arrays for the operation.
optimize : {bool, list, tuple, 'greedy', 'optimal'}
Choose the type of path. If a tuple is provided, the second argument is
assumed to be the maximum intermediate size created. If only a single
argument is provided the largest input or output array size is used
as a maximum intermediate size.
* if a list is given that starts with ``einsum_path``, uses this as the
contraction path
* if False no optimization is taken
* if True defaults to the 'greedy' algorithm
* 'optimal' An algorithm that combinatorially explores all possible
ways of contracting the listed tensors and choosest the least costly
path. Scales exponentially with the number of terms in the
contraction.
* 'greedy' An algorithm that chooses the best pair contraction
at each step. Effectively, this algorithm searches the largest inner,
Hadamard, and then outer products at each step. Scales cubically with
the number of terms in the contraction. Equivalent to the 'optimal'
path for most contractions.
Default is 'greedy'.
Returns
-------
path : list of tuples
A list representation of the einsum path.
string_repr : str
A printable representation of the einsum path.
Notes
-----
The resulting path indicates which terms of the input contraction should be
contracted first, the result of this contraction is then appended to the
end of the contraction list. This list can then be iterated over until all
intermediate contractions are complete.
See Also
--------
einsum, linalg.multi_dot
Examples
--------
We can begin with a chain dot example. In this case, it is optimal to
contract the ``b`` and ``c`` tensors first as reprsented by the first
element of the path ``(1, 2)``. The resulting tensor is added to the end
of the contraction and the remaining contraction ``(0, 1)`` is then
completed.
>>> a = np.random.rand(2, 2)
>>> b = np.random.rand(2, 5)
>>> c = np.random.rand(5, 2)
>>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy')
>>> print(path_info[0])
['einsum_path', (1, 2), (0, 1)]
>>> print(path_info[1])
Complete contraction: ij,jk,kl->il
Naive scaling: 4
Optimized scaling: 3
Naive FLOP count: 1.600e+02
Optimized FLOP count: 5.600e+01
Theoretical speedup: 2.857
Largest intermediate: 4.000e+00 elements
-------------------------------------------------------------------------
scaling current remaining
-------------------------------------------------------------------------
3 kl,jk->jl ij,jl->il
3 jl,ij->il il->il
A more complex index transformation example.
>>> I = np.random.rand(10, 10, 10, 10)
>>> C = np.random.rand(10, 10)
>>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,
optimize='greedy')
>>> print(path_info[0])
['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]
>>> print(path_info[1])
Complete contraction: ea,fb,abcd,gc,hd->efgh
Naive scaling: 8
Optimized scaling: 5
Naive FLOP count: 8.000e+08
Optimized FLOP count: 8.000e+05
Theoretical speedup: 1000.000
Largest intermediate: 1.000e+04 elements
--------------------------------------------------------------------------
scaling current remaining
--------------------------------------------------------------------------
5 abcd,ea->bcde fb,gc,hd,bcde->efgh
5 bcde,fb->cdef gc,hd,cdef->efgh
5 cdef,gc->defg hd,defg->efgh
5 defg,hd->efgh efgh->efgh
t optimizet einsum_calls+ Did not understand the following kwargs: %st greedyi R i i s Did not understand the path: %ss ->R> R! sX Einstein sum subscript %s does not contain the correct number of indices for operand %d.s@ Size of label '%s' for operand %d does not match previous terms.t optimals Path name %s not foundt reversei����t scalingt currentR s Complete contraction: %s
s Naive scaling: %d
s Optimized scaling: %d
s Naive FLOP count: %.3e
s Optimized FLOP count: %.3e
s Theoretical speedup: %3.3f
s' Largest intermediate: %.3e elements
R? iJ s
s %6s %24s %40s
s
%4d %24s %40sN( i i ( Rz R{ R (! t itemsR# RL RH RR RQ RI RC RD RK t floatRt RP R RE R RS RB t keysR R RT R$ R" R% R< R5 t KeyErrorRV RG R RO t sum(: RW t kwargst valid_contract_kwargst kRY t unknown_kwargst path_typeR& t einsum_call_argRr Ro RX t
input_listR R R R
t dimension_dictt tnumt termt sht cnumRs t dimt size_listt max_sizet
memory_argt
naive_costt indices_in_inputt multR4 t cost_listt
scale_listt contraction_listt
contract_indsR7 t out_indsR R R- t
tmp_inputsR8 R t sort_resultt
einsum_strt contractiont opt_costt overall_contractiont headert speedupt max_it
path_printt nt indst idx_rmR t
remaining_strt path_run( ( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyR � s� n
%
*
#,
c ` s� | j d t � } | t k r+ t | | � Sd d d d g � � f d � | j � D� } d g � } g | j � D] \ } } | | k rs | ^ qs } t | � r� t d | � � n t } | j d d � } | d k r� t } n t d | d t | � \ } }
x� t |
� D]� \ } } | \ }
} } } g } x$ |
D] } | j
| j | � � q9W| r�| d t |
� k r�| | d <n t | | | � } | j
| � ~ ~ qW| r�| S| d
Sd S( sM!
einsum(subscripts, *operands, out=None, dtype=None, order='K',
casting='safe', optimize=False)
Evaluates the Einstein summation convention on the operands.
Using the Einstein summation convention, many common multi-dimensional
array operations can be represented in a simple fashion. This function
provides a way to compute such summations. The best way to understand this
function is to try the examples below, which show how many common NumPy
functions can be implemented as calls to `einsum`.
Parameters
----------
subscripts : str
Specifies the subscripts for summation.
operands : list of array_like
These are the arrays for the operation.
out : {ndarray, None}, optional
If provided, the calculation is done into this array.
dtype : {data-type, None}, optional
If provided, forces the calculation to use the data type specified.
Note that you may have to also give a more liberal `casting`
parameter to allow the conversions. Default is None.
order : {'C', 'F', 'A', 'K'}, optional
Controls the memory layout of the output. 'C' means it should
be C contiguous. 'F' means it should be Fortran contiguous,
'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.
'K' means it should be as close to the layout as the inputs as
is possible, including arbitrarily permuted axes.
Default is 'K'.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
Controls what kind of data casting may occur. Setting this to
'unsafe' is not recommended, as it can adversely affect accumulations.
* 'no' means the data types should not be cast at all.
* 'equiv' means only byte-order changes are allowed.
* 'safe' means only casts which can preserve values are allowed.
* 'same_kind' means only safe casts or casts within a kind,
like float64 to float32, are allowed.
* 'unsafe' means any data conversions may be done.
Default is 'safe'.
optimize : {False, True, 'greedy', 'optimal'}, optional
Controls if intermediate optimization should occur. No optimization
will occur if False and True will default to the 'greedy' algorithm.
Also accepts an explicit contraction list from the ``np.einsum_path``
function. See ``np.einsum_path`` for more details. Default is False.
Returns
-------
output : ndarray
The calculation based on the Einstein summation convention.
See Also
--------
einsum_path, dot, inner, outer, tensordot, linalg.multi_dot
Notes
-----
.. versionadded:: 1.6.0
The subscripts string is a comma-separated list of subscript labels,
where each label refers to a dimension of the corresponding operand.
Repeated subscripts labels in one operand take the diagonal. For example,
``np.einsum('ii', a)`` is equivalent to ``np.trace(a)``.
Whenever a label is repeated, it is summed, so ``np.einsum('i,i', a, b)``
is equivalent to ``np.inner(a,b)``. If a label appears only once,
it is not summed, so ``np.einsum('i', a)`` produces a view of ``a``
with no changes.
The order of labels in the output is by default alphabetical. This
means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while
``np.einsum('ji', a)`` takes its transpose.
The output can be controlled by specifying output subscript labels
as well. This specifies the label order, and allows summing to
be disallowed or forced when desired. The call ``np.einsum('i->', a)``
is like ``np.sum(a, axis=-1)``, and ``np.einsum('ii->i', a)``
is like ``np.diag(a)``. The difference is that `einsum` does not
allow broadcasting by default.
To enable and control broadcasting, use an ellipsis. Default
NumPy-style broadcasting is done by adding an ellipsis
to the left of each term, like ``np.einsum('...ii->...i', a)``.
To take the trace along the first and last axes,
you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix
product with the left-most indices instead of rightmost, you can do
``np.einsum('ij...,jk...->ik...', a, b)``.
When there is only one operand, no axes are summed, and no output
parameter is provided, a view into the operand is returned instead
of a new array. Thus, taking the diagonal as ``np.einsum('ii->i', a)``
produces a view.
An alternative way to provide the subscripts and operands is as
``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``. The examples
below have corresponding `einsum` calls with the two parameter methods.
.. versionadded:: 1.10.0
Views returned from einsum are now writeable whenever the input array
is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now
have the same effect as ``np.swapaxes(a, 0, 2)`` and
``np.einsum('ii->i', a)`` will return a writeable view of the diagonal
of a 2D array.
.. versionadded:: 1.12.0
Added the ``optimize`` argument which will optimize the contraction order
of an einsum expression. For a contraction with three or more operands this
can greatly increase the computational efficiency at the cost of a larger
memory footprint during computation.
See ``np.einsum_path`` for more details.
Examples
--------
>>> a = np.arange(25).reshape(5,5)
>>> b = np.arange(5)
>>> c = np.arange(6).reshape(2,3)
>>> np.einsum('ii', a)
60
>>> np.einsum(a, [0,0])
60
>>> np.trace(a)
60
>>> np.einsum('ii->i', a)
array([ 0, 6, 12, 18, 24])
>>> np.einsum(a, [0,0], [0])
array([ 0, 6, 12, 18, 24])
>>> np.diag(a)
array([ 0, 6, 12, 18, 24])
>>> np.einsum('ij,j', a, b)
array([ 30, 80, 130, 180, 230])
>>> np.einsum(a, [0,1], b, [1])
array([ 30, 80, 130, 180, 230])
>>> np.dot(a, b)
array([ 30, 80, 130, 180, 230])
>>> np.einsum('...j,j', a, b)
array([ 30, 80, 130, 180, 230])
>>> np.einsum('ji', c)
array([[0, 3],
[1, 4],
[2, 5]])
>>> np.einsum(c, [1,0])
array([[0, 3],
[1, 4],
[2, 5]])
>>> c.T
array([[0, 3],
[1, 4],
[2, 5]])
>>> np.einsum('..., ...', 3, c)
array([[ 0, 3, 6],
[ 9, 12, 15]])
>>> np.einsum(',ij', 3, C)
array([[ 0, 3, 6],
[ 9, 12, 15]])
>>> np.einsum(3, [Ellipsis], c, [Ellipsis])
array([[ 0, 3, 6],
[ 9, 12, 15]])
>>> np.multiply(3, c)
array([[ 0, 3, 6],
[ 9, 12, 15]])
>>> np.einsum('i,i', b, b)
30
>>> np.einsum(b, [0], b, [0])
30
>>> np.inner(b,b)
30
>>> np.einsum('i,j', np.arange(2)+1, b)
array([[0, 1, 2, 3, 4],
[0, 2, 4, 6, 8]])
>>> np.einsum(np.arange(2)+1, [0], b, [1])
array([[0, 1, 2, 3, 4],
[0, 2, 4, 6, 8]])
>>> np.outer(np.arange(2)+1, b)
array([[0, 1, 2, 3, 4],
[0, 2, 4, 6, 8]])
>>> np.einsum('i...->...', a)
array([50, 55, 60, 65, 70])
>>> np.einsum(a, [0,Ellipsis], [Ellipsis])
array([50, 55, 60, 65, 70])
>>> np.sum(a, axis=0)
array([50, 55, 60, 65, 70])
>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> np.einsum('ijk,jil->kl', a, b)
array([[ 4400., 4730.],
[ 4532., 4874.],
[ 4664., 5018.],
[ 4796., 5162.],
[ 4928., 5306.]])
>>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
array([[ 4400., 4730.],
[ 4532., 4874.],
[ 4664., 5018.],
[ 4796., 5162.],
[ 4928., 5306.]])
>>> np.tensordot(a,b, axes=([1,0],[0,1]))
array([[ 4400., 4730.],
[ 4532., 4874.],
[ 4664., 5018.],
[ 4796., 5162.],
[ 4928., 5306.]])
>>> a = np.arange(6).reshape((3,2))
>>> b = np.arange(12).reshape((4,3))
>>> np.einsum('ki,jk->ij', a, b)
array([[10, 28, 46, 64],
[13, 40, 67, 94]])
>>> np.einsum('ki,...k->i...', a, b)
array([[10, 28, 46, 64],
[13, 40, 67, 94]])
>>> np.einsum('k...,jk', a, b)
array([[10, 28, 46, 64],
[13, 40, 67, 94]])
>>> # since version 1.10.0
>>> a = np.zeros((3, 3))
>>> np.einsum('ii->i', a)[:] = 1
>>> a
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
Ru t outt dtypet ordert castingc ` s+ i | ]! \ } } | � k r | | � q S( ( ( t .0R� RY ( t valid_einsum_kwargs( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pys
<dictcomp>� s s+ Did not understand the following kwargs: %sRv i i N( RH RR R R| R# RL RI RQ R R R ( RW R� t optimize_argt
einsum_kwargsR� R� RY R� t
specified_outt out_arrayR� Ra R� R� R� R� R R[ R t new_view( ( R� sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyR � s< �
N( t __doc__t
__future__R R R t numpy.core.multiarrayR t numpy.core.numericR R R t __all__RF R RN R R R5 R< Rt R R ( ( ( sH /opt/alt/python27/lib64/python2.7/site-packages/numpy/core/einsumfunc.pyt <module> s < K O � �