code: def _expm_multiply_simple(A, B, t=1.0, balance=False):
      """
      Compute the action of the matrix exponential at a single time point.
  
      Parameters
      ----------
      A : transposable linear operator
          The operator whose exponential is of interest.
      B : ndarray
          The matrix to be multiplied by the matrix exponential of A.
      t : float
          A time point.
      balance : bool
          Indicates whether or not to apply balancing.
  
      Returns
      -------
      F : ndarray
          :math:`e^{t A} B`
  
      Notes
      -----
      This is algorithm (3.2) in Al-Mohy and Higham (2011).
  
      """
      if balance:
          raise NotImplementedError
      if len(A.shape) != 2 or A.shape[0] != A.shape[1]:
          raise ValueError("expected A to be like a square matrix")
      if A.shape[1] != B.shape[0]:
          raise ValueError(
              "the matrices A and B have incompatible shapes"
          )
      ident = _ident_like(A)
      n = A.shape[0]
      if len(B.shape) == 1:
          n0 = 1
      elif len(B.shape) == 2:
          n0 = B.shape[1]
      else:
          raise ValueError("expected B to be like a matrix or a vector")
      u_d = 2**-53
      tol = u_d
      mu = _trace(A) / float(n)
      A = A - mu * ident
      A_1_norm = _exact_1_norm(A)
      if t * A_1_norm == 0:
          m_star, s = 0, 1
      else:
          ell = 2
          norm_info = LazyOperatorNormInfo(
              t * A, A_1_norm=t * A_1_norm, ell=ell
          )
          m_star, s = _fragment_3_1(norm_info, n0, tol, ell=ell)
      return _expm_multiply_simple_core(
          A, B, t, mu, m_star, s, tol, balance
      )
  
imports: from __future__ import division, print_function, absolute_import
  import numpy
  import scipy.linalg
  import scipy.sparse.linalg
  from scipy.sparse.linalg import aslinearoperator
label_desc: Use image node_id 6 for calling a global function with example usage: _expm_multiply_simple(A, B, t, balance) and returns: _expm_multiply_simple_core