code: def bisplrep(
      x,
      y,
      z,
      w=None,
      xb=None,
      xe=None,
      yb=None,
      ye=None,
      kx=3,
      ky=3,
      task=0,
      s=None,
      eps=1e-16,
      tx=None,
      ty=None,
      full_output=0,
      nxest=None,
      nyest=None,
      quiet=1,
  ):
      """
      Find a bivariate B-spline representation of a surface.
  
      Given a set of data points (x[i], y[i], z[i]) representing a surface
      z=f(x,y), compute a B-spline representation of the surface. Based on
      the routine SURFIT from FITPACK.
  
      Parameters
      ----------
      x, y, z : ndarray
          Rank-1 arrays of data points.
      w : ndarray, optional
          Rank-1 array of weights. By default ``w=np.ones(len(x))``.
      xb, xe : float, optional
          End points of approximation interval in `x`.
          By default ``xb = x.min(), xe=x.max()``.
      yb, ye : float, optional
          End points of approximation interval in `y`.
          By default ``yb=y.min(), ye = y.max()``.
      kx, ky : int, optional
          The degrees of the spline (1 <= kx, ky <= 5).
          Third order (kx=ky=3) is recommended.
      task : int, optional
          If task=0, find knots in x and y and coefficients for a given
          smoothing factor, s.
          If task=1, find knots and coefficients for another value of the
          smoothing factor, s.  bisplrep must have been previously called
          with task=0 or task=1.
          If task=-1, find coefficients for a given set of knots tx, ty.
      s : float, optional
          A non-negative smoothing factor. If weights correspond
          to the inverse of the standard-deviation of the errors in z,
          then a good s-value should be found in the range
          ``(m-sqrt(2*m),m+sqrt(2*m))`` where m=len(x).
      eps : float, optional
          A threshold for determining the effective rank of an
          over-determined linear system of equations (0 < eps < 1).
          `eps` is not likely to need changing.
      tx, ty : ndarray, optional
          Rank-1 arrays of the knots of the spline for task=-1
      full_output : int, optional
          Non-zero to return optional outputs.
      nxest, nyest : int, optional
          Over-estimates of the total number of knots. If None then
          ``nxest = max(kx+sqrt(m/2),2*kx+3)``,
          ``nyest = max(ky+sqrt(m/2),2*ky+3)``.
      quiet : int, optional
          Non-zero to suppress printing of messages.
  
      Returns
      -------
      tck : array_like
          A list [tx, ty, c, kx, ky] containing the knots (tx, ty) and
          coefficients (c) of the bivariate B-spline representation of the
          surface along with the degree of the spline.
      fp : ndarray
          The weighted sum of squared residuals of the spline approximation.
      ier : int
          An integer flag about splrep success. Success is indicated if
          ier<=0. If ier in [1,2,3] an error occurred but was not raised.
          Otherwise an error is raised.
      msg : str
          A message corresponding to the integer flag, ier.
  
      See Also
      --------
      splprep, splrep, splint, sproot, splev
      UnivariateSpline, BivariateSpline
  
      Notes
      -----
      See `bisplev` to evaluate the value of the B-spline given its tck
      representation.
  
      If the input data is such that input dimensions have incommensurate
      units and differ by many orders of magnitude, the interpolant may have
      numerical artifacts. Consider rescaling the data before interpolation.
  
      References
      ----------
      .. [1] Dierckx P.:An algorithm for surface fitting with spline functions
         Ima J. Numer. Anal. 1 (1981) 267-283.
      .. [2] Dierckx P.:An algorithm for surface fitting with spline functions
         report tw50, Dept. Computer Science,K.U.Leuven, 1980.
      .. [3] Dierckx P.:Curve and surface fitting with splines, Monographs on
         Numerical Analysis, Oxford University Press, 1993.
  
      Examples
      --------
      Examples are given :ref:`in the tutorial <tutorial-interpolate_2d_spline>`.
  
      """
      x, y, z = map(ravel, [x, y, z])  # ensure 1-d arrays.
      m = len(x)
      if not (m == len(y) == len(z)):
          raise TypeError("len(x)==len(y)==len(z) must hold.")
      if w is None:
          w = ones(m, float)
      else:
          w = atleast_1d(w)
      if not len(w) == m:
          raise TypeError(
              "len(w)=%d is not equal to m=%d" % (len(w), m)
          )
      if xb is None:
          xb = x.min()
      if xe is None:
          xe = x.max()
      if yb is None:
          yb = y.min()
      if ye is None:
          ye = y.max()
      if not (-1 <= task <= 1):
          raise TypeError("task must be -1, 0 or 1")
      if s is None:
          s = m - sqrt(2 * m)
      if tx is None and task == -1:
          raise TypeError("Knots_x must be given for task=-1")
      if tx is not None:
          _surfit_cache["tx"] = atleast_1d(tx)
      nx = len(_surfit_cache["tx"])
      if ty is None and task == -1:
          raise TypeError("Knots_y must be given for task=-1")
      if ty is not None:
          _surfit_cache["ty"] = atleast_1d(ty)
      ny = len(_surfit_cache["ty"])
      if task == -1 and nx < 2 * kx + 2:
          raise TypeError(
              "There must be at least 2*kx+2 knots_x for task=-1"
          )
      if task == -1 and ny < 2 * ky + 2:
          raise TypeError(
              "There must be at least 2*ky+2 knots_x for task=-1"
          )
      if not ((1 <= kx <= 5) and (1 <= ky <= 5)):
          raise TypeError(
              "Given degree of the spline (kx,ky=%d,%d) is not "
              "supported. (1<=k<=5)" % (kx, ky)
          )
      if m < (kx + 1) * (ky + 1):
          raise TypeError("m >= (kx+1)(ky+1) must hold")
      if nxest is None:
          nxest = int(kx + sqrt(m / 2))
      if nyest is None:
          nyest = int(ky + sqrt(m / 2))
      nxest, nyest = max(nxest, 2 * kx + 3), max(nyest, 2 * ky + 3)
      if task >= 0 and s == 0:
          nxest = int(kx + sqrt(3 * m))
          nyest = int(ky + sqrt(3 * m))
      if task == -1:
          _surfit_cache["tx"] = atleast_1d(tx)
          _surfit_cache["ty"] = atleast_1d(ty)
      tx, ty = _surfit_cache["tx"], _surfit_cache["ty"]
      wrk = _surfit_cache["wrk"]
      u = nxest - kx - 1
      v = nyest - ky - 1
      km = max(kx, ky) + 1
      ne = max(nxest, nyest)
      bx, by = kx * v + ky + 1, ky * u + kx + 1
      b1, b2 = bx, bx + v - ky
      if bx > by:
          b1, b2 = by, by + u - kx
      msg = "Too many data points to interpolate"
      lwrk1 = _int_overflow(
          u * v * (2 + b1 + b2)
          + 2 * (u + v + km * (m + ne) + ne - kx - ky)
          + b2
          + 1,
          OverflowError,
          msg=msg,
      )
      lwrk2 = _int_overflow(
          u * v * (b2 + 1) + b2, OverflowError, msg=msg
      )
      tx, ty, c, o = _fitpack._surfit(
          x,
          y,
          z,
          w,
          xb,
          xe,
          yb,
          ye,
          kx,
          ky,
          task,
          s,
          eps,
          tx,
          ty,
          nxest,
          nyest,
          wrk,
          lwrk1,
          lwrk2,
      )
      _curfit_cache["tx"] = tx
      _curfit_cache["ty"] = ty
      _curfit_cache["wrk"] = o["wrk"]
      ier, fp = o["ier"], o["fp"]
      tck = [tx, ty, c, kx, ky]
  
      ierm = min(11, max(-3, ier))
      if ierm <= 0 and not quiet:
          _mess = _iermess2[ierm][
              0
          ] + "\tkx,ky=%d,%d nx,ny=%d,%d m=%d fp=%f s=%f" % (
              kx,
              ky,
              len(tx),
              len(ty),
              m,
              fp,
              s,
          )
          warnings.warn(RuntimeWarning(_mess), stacklevel=2)
      if ierm > 0 and not full_output:
          if ier in [1, 2, 3, 4, 5]:
              _mess = "\n\tkx,ky=%d,%d nx,ny=%d,%d m=%d fp=%f s=%f" % (
                  kx,
                  ky,
                  len(tx),
                  len(ty),
                  m,
                  fp,
                  s,
              )
              warnings.warn(
                  RuntimeWarning(_iermess2[ierm][0] + _mess),
                  stacklevel=2,
              )
          else:
              try:
                  raise _iermess2[ierm][1](_iermess2[ierm][0])
              except KeyError as e:
                  raise _iermess2["unknown"][1](
                      _iermess2["unknown"][0]
                  ) from e
      if full_output:
          try:
              return tck, fp, ier, _iermess2[ierm][0]
          except KeyError:
              return tck, fp, ier, _iermess2["unknown"][0]
      else:
          return tck
  
file_path: scipy/scipy/interpolate/_fitpack_impl.py
imports: import warnings
  import numpy
  from .None import _fitpack
  from numpy import atleast_1d, array, ones, zeros, sqrt, ravel, transpose, empty, iinfo, asarray
  from .None import dfitpack
label_desc: Use image node_id 8 for calling a global function with example usage: bisplrep(x, y, z, w, xb, xe, yb, ye, kx, ky, task, s, eps, tx, ty, full_output, nxest, nyest, quiet) and returns: tck, tck,  fp,  ier,  _iermess2, tck,  fp,  ier,  _iermess2