class_docstr: MathFeatures(() applies functions across multiple features returning one or more
  additional features as a result. It uses `pandas.agg()` to create the features,
  setting `axis=1`.
  
  For supported aggregation functions, see `pandas documentation
  <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.agg.html>`_.
  
  Note that if some of the variables have missing data and `missing_values='ignore'`,
  the value will be ignored in the computation. To be clear, if variables A, B and C,
  have values 10, 20 and NA, and we perform the sum, the result will be A + B = 30.
  
  More details in the :ref:`User Guide <math_features>`.
  
  Parameters
  ----------
  variables: list
      The list of input variables. Variables must be numerical and there must be at
      least 2 different variables in the list.
  
  func: function, string, list
      Functions to use for aggregating the data. Same functionality as parameter
      `func` in `pandas.agg()`. If a function, it must either work when passed a
      DataFrame or when passed to DataFrame.apply. Accepted combinations are:
  
      - function
      - string function name
      - list of functions and/or function names, e.g. [np.sum, 'mean']
  
      Each function will result in a new variable that will be added to the
      transformed dataset.
  
  new_variables_names: list, default=None
      Names of the new variables. If passing a list with names (recommended), enter
      one name per function. If None, the transformer will assign arbitrary names,
      starting with the function and followed by the variables separated by _.
  
  {missing_values}
  
  {drop_original}
  
  Attributes
  ----------
  {variables_}
  
  {feature_names_in_}
  
  {n_features_in_}
  
  Methods
  -------
  {fit}
  
  {fit_transform}
  
  {transform}
  
  Notes
  -----
  Although the transformer allows us to combine any features with any functions, we
  recommend using it to create features based on domain knowledge. Typical examples
  in finance are:
  
  - Sum debt across financial products, i.e., credit cards, to obtain the total debt.
  - Take the average payments to various financial products.
  - Find the minimum payment done at any one month.
  
  In insurance, we can sum the damage to various parts of a car to obtain the
  total damage.
  
  Examples
  --------
  
  >>> import pandas as pd
  >>> from feature_engine.creation import MathFeatures
  >>> X = pd.DataFrame(dict(x1 = [1,2,3], x2 = [4,5,6]))
  >>> mf = MathFeatures(variables = ["x1","x2"], func = "sum")
  >>> mf.fit(X)
  >>> mf.transform(X)
     x1  x2  sum_x1_x2
  0   1   4          5
  1   2   5          7
  2   3   6          9
  
  >>> mf = MathFeatures(variables = ["x1","x2"], func = "prod")
  >>> mf.fit(X)
  >>> mf.transform(X)
     x1  x2  prod_x1_x2
  0   1   4           4
  1   2   5          10
  2   3   6          18
  
  >>> mf = MathFeatures(variables = ["x1","x2"], func = "mean")
  >>> mf.fit(X)
  >>> mf.transform(X))
     x1  x2  mean_x1_x2
  0   1   4         2.5
  1   2   5         3.5
  2   3   6         4.5
docstr: Return names of the created features.
code: def _get_new_features_name(self) -> List:
      """Return names of the created features."""
  
      # create name of the new variables
      if self.new_variables_names is not None:
          feature_names = self.new_variables_names
  
      else:
          varlist = [f"{var}" for var in self.variables_]
  
          if isinstance(self.func, list):
              functions = [
                  fun if type(fun) == str else fun.__name__
                  for fun in self.func
              ]
              feature_names = [
                  f"{function}_{'_'.join(varlist)}"
                  for function in functions
              ]
          else:
              feature_names = [f"{self.func}_{'_'.join(varlist)}"]
  
      return feature_names
  
file_path: feature_engine/feature_engine/creation/math_features.py
imports: from typing import Any, List, Optional, Union
  import pandas
  from feature_engine._docstrings.fit_attributes import _feature_names_in_docstring, _n_features_in_docstring, _variables_attribute_docstring
  from feature_engine._docstrings.init_parameters import _drop_original_docstring, _missing_values_docstring
  from feature_engine._docstrings.methods import _fit_not_learn_docstring, _fit_transform_docstring, _transform_creation_docstring
  from feature_engine._docstrings.substitute import Substitution
  from feature_engine.creation.base_creation import BaseCreation
label_desc: Use image node_id 3 for calling the MathFeatures obj's underlying member method code with example usage: obj._get_new_features_name() and returns: feature_names