# trace function

(Shortest import: `from brian2 import trace)`

brian2.units.unitsafefunctions.trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)

  Return the sum along diagonals of the array.

  If `a` is 2-D, the sum along its diagonal with the given offset is returned, i.e., the sum of elements `a[i,i+offset]` for all i.

  If `a` has more than two dimensions, then the axes specified by axis1 and axis2 are used to determine the 2-D sub-arrays whose traces are returned. The shape of the resulting array is the same as that of `a` with `axis1` and `axis2` removed.

  Parameters:

    a : array_like

    > Input array, from which the diagonals are taken.

    offset : int, optional

    > Offset of the diagonal from the main diagonal. Can be both positive and negative. Defaults to 0.

    axis1, axis2 : int, optional

    > Axes to be used as the first and second axis of the 2-D sub-arrays from which the diagonals should be taken. Defaults are the first two axes of `a`.

    dtype : dtype, optional

    > Determines the data-type of the returned array and of the accumulator where the elements are summed. If dtype has the value None and `a` is of integer type of precision less than the default integer precision, then the default integer precision is used. Otherwise, the precision is the same as that of `a`.

    out : ndarray, optional

    > Array into which the output is placed. Its type is preserved and it must be of the right shape to hold the output.

  Returns:

    sum_along_diagonals : ndarray

    > If `a` is 2-D, the sum along the diagonal is returned. If `a` has larger dimensions, then an array of sums along diagonals is returned.

  See also

  `diag`, `diagonal()`, `diagflat`

  Examples

      >>> import numpy as np
      >>> np.trace(np.eye(3))
      3.0
      >>> a = np.arange(8).reshape((2,2,2))
      >>> np.trace(a)
      array([6, 8])

      >>> a = np.arange(24).reshape((2,2,2,3))
      >>> np.trace(a).shape
      (2, 3)