binary_operations.rst

Binary Operations on Arrays

+-----------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------+--------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | | Tensor | Einstein | Nutils | +===+================================================+================================================+================================================================================+========================================================+===============================================================================================================================+ | 1 | a ∈ ℝⁿ | b ∈ ℝⁿ | c = a ⋅ b ∈ ℝ | c = a_ib_i | c = (a*b).sum(-1) | +---+------------------------------------------------+------------------------------------------------+--------------------------------------------------------------------------------+--------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | 2 | a ∈ ℝⁿ | b ∈ ℝ^m | C = a ⊗ b ∈ ℝ^n × m | C_ij = a_ib_j | C = a[:,_]*b[_,:] | | | | | | +-------------------------------------------------------------------------------------------------------------------------------+ | | | | | | C = function.outer(a,b) | +---+------------------------------------------------+------------------------------------------------+--------------------------------------------------------------------------------+--------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | 3 | A ∈ ℝ^m × n | b ∈ ℝⁿ | c = Ab ∈ ℝ^m | c_i = A_ijb_j | c = (A[:,:]*b[_,:]).sum(-1) | +---+------------------------------------------------+------------------------------------------------+--------------------------------------------------------------------------------+--------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | 4 | A ∈ ℝ^m × n | B ∈ ℝ^n × p | C = AB ∈ ℝ^m × p | c_ij = A_ikB_kj | c = (A[:,:,_]*B[_,:,:]).sum(-2) | +---+------------------------------------------------+------------------------------------------------+--------------------------------------------------------------------------------+--------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | 5 | A ∈ ℝ^m × n | B ∈ ℝ^p × n | C = AB^T ∈ ℝ^m × p | C_ij = A_ikB_jk | C = (A[:,_,:]*B[_,:,:]).sum(-1) | | | | | | +-------------------------------------------------------------------------------------------------------------------------------+ | | | | | | C = function.outer(A,B).sum(-1) | +---+------------------------------------------------+------------------------------------------------+--------------------------------------------------------------------------------+--------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------+ | 6 | A ∈ ℝ^m × n | B ∈ ℝ^m × n | c = A : B ∈ ℝ | c = A_ijB_ij | c = (A*B).sum([-2,-1]) | +---+------------------------------------------------+------------------------------------------------+--------------------------------------------------------------------------------+--------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------+

Notes:

1. In the above table the summation axes are numbered backward. For example, sum(-1) is used to sum over the last axis of an array. Although forward numbering is possible in many situations, backward numbering is generally preferred in Nutils code.
2. When a summation over multiple axes is performed (#6), these axes are to be listed. In the case of single-axis summations listing is optional (for example sum(-1) is equivalent to sum([-1])). The shorter notation sum(-1) is preferred.
3. When the number of dimensions of the two arguments of a binary operation mismatch, singleton axes are automatically prepended to the "shorter" argument. This property can be used to shorten notation. For example, #3 can be written as (A*b).sum(-1). To avoid ambiguities, in general, such abbreviations are discouraged.