code: def andrews_curves(
      frame,
      class_column,
      ax=None,
      samples=200,
      color=None,
      colormap=None,
      **kwds,
  ):
      """
      Generates a matplotlib plot of Andrews curves, for visualising clusters of
      multivariate data.
  
      Andrews curves have the functional form:
  
      f(t) = x_1/sqrt(2) + x_2 sin(t) + x_3 cos(t) +
             x_4 sin(2t) + x_5 cos(2t) + ...
  
      Where x coefficients correspond to the values of each dimension and t is
      linearly spaced between -pi and +pi. Each row of frame then corresponds to
      a single curve.
  
      Parameters
      ----------
      frame : DataFrame
          Data to be plotted, preferably normalized to (0.0, 1.0)
      class_column : Name of the column containing class names
      ax : matplotlib axes object, default None
      samples : Number of points to plot in each curve
      color : list or tuple, optional
          Colors to use for the different classes
      colormap : str or matplotlib colormap object, default None
          Colormap to select colors from. If string, load colormap with that name
          from matplotlib.
      kwds : keywords
          Options to pass to matplotlib plotting method
  
      Returns
      -------
      ax : Matplotlib axis object
  
      """
      from math import sqrt, pi
      import matplotlib.pyplot as plt
  
      def function(amplitudes):
          def f(t):
              x1 = amplitudes[0]
              result = x1 / sqrt(2.0)
  
              # Take the rest of the coefficients and resize them
              # appropriately. Take a copy of amplitudes as otherwise numpy
              # deletes the element from amplitudes itself.
              coeffs = np.delete(np.copy(amplitudes), 0)
              coeffs.resize(int((coeffs.size + 1) / 2), 2)
  
              # Generate the harmonics and arguments for the sin and cos
              # functions.
              harmonics = np.arange(0, coeffs.shape[0]) + 1
              trig_args = np.outer(harmonics, t)
  
              result += np.sum(
                  coeffs[:, 0, np.newaxis] * np.sin(trig_args)
                  + coeffs[:, 1, np.newaxis] * np.cos(trig_args),
                  axis=0,
              )
              return result
  
          return f
  
      n = len(frame)
      class_col = frame[class_column]
      classes = frame[class_column].drop_duplicates()
      df = frame.drop(class_column, axis=1)
      t = np.linspace(-pi, pi, samples)
      used_legends = set()
  
      color_values = _get_standard_colors(
          num_colors=len(classes),
          colormap=colormap,
          color_type="random",
          color=color,
      )
      colors = dict(zip(classes, color_values))
      if ax is None:
          ax = plt.gca(xlim=(-pi, pi))
      for i in range(n):
          row = df.iloc[i].values
          f = function(row)
          y = f(t)
          kls = class_col.iat[i]
          label = pprint_thing(kls)
          if label not in used_legends:
              used_legends.add(label)
              ax.plot(t, y, color=colors[kls], label=label, **kwds)
          else:
              ax.plot(t, y, color=colors[kls], **kwds)
  
      ax.legend(loc="upper right")
      ax.grid()
      return ax
  
file_path: catboost/contrib/python/pandas/py2/pandas/plotting/_misc.py
imports: from __future__ import division
  import numpy
  from pandas.compat import lmap, lrange, range, zip
  from pandas.util._decorators import deprecate_kwarg
  from pandas.core.dtypes.missing import notna
  from pandas.io.formats.printing import pprint_thing
  from pandas.plotting._style import _get_standard_colors
  from pandas.plotting._tools import _set_ticks_props, _subplots
label_desc: Use image node_id 4 for calling a global function with example usage: andrews_curves(frame, class_column, ax, samples, color, colormap) and returns: ax, f, result