code: def legval3d(x, y, z, c):
      """
      Evaluate a 3-D Legendre series at points (x, y, z).
  
      This function returns the values:
  
      .. math:: p(x,y,z) = \\sum_{i,j,k} c_{i,j,k} * L_i(x) * L_j(y) * L_k(z)
  
      The parameters `x`, `y`, and `z` are converted to arrays only if
      they are tuples or a lists, otherwise they are treated as a scalars and
      they must have the same shape after conversion. In either case, either
      `x`, `y`, and `z` or their elements must support multiplication and
      addition both with themselves and with the elements of `c`.
  
      If `c` has fewer than 3 dimensions, ones are implicitly appended to its
      shape to make it 3-D. The shape of the result will be c.shape[3:] +
      x.shape.
  
      Parameters
      ----------
      x, y, z : array_like, compatible object
          The three dimensional series is evaluated at the points
          `(x, y, z)`, where `x`, `y`, and `z` must have the same shape.  If
          any of `x`, `y`, or `z` is a list or tuple, it is first converted
          to an ndarray, otherwise it is left unchanged and if it isn't an
          ndarray it is  treated as a scalar.
      c : array_like
          Array of coefficients ordered so that the coefficient of the term of
          multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension
          greater than 3 the remaining indices enumerate multiple sets of
          coefficients.
  
      Returns
      -------
      values : ndarray, compatible object
          The values of the multidimensional polynomial on points formed with
          triples of corresponding values from `x`, `y`, and `z`.
  
      See Also
      --------
      legval, legval2d, leggrid2d, leggrid3d
  
      Notes
      -----
  
      .. versionadded:: 1.7.0
  
      """
      try:
          x, y, z = np.array((x, y, z), copy=0)
      except Exception:
          raise ValueError("x, y, z are incompatible")
  
      c = legval(x, c)
      c = legval(y, c, tensor=False)
      c = legval(z, c, tensor=False)
      return c
  
imports: from __future__ import division, absolute_import, print_function
  import warnings
  import numpy
  import numpy.linalg
  from numpy.core.multiarray import normalize_axis_index
  from .None import polyutils
  from ._polybase import ABCPolyBase
label_desc: Use image node_id 16 for calling a global function with example usage: legval3d(x, y, z, c) and returns: c