Repository: GAA-UAM/scikit-fda

Issue:
Rename interpolator to interpolation, or extrapolation to extrapolator
The naming should be consistent between these properties.

Discussion:

Patch:
diff --git a/docs/modules/representation.rst b/docs/modules/representation.rst
index f5c8719a..50d25b35 100644
--- a/docs/modules/representation.rst
+++ b/docs/modules/representation.rst
@@ -30,7 +30,7 @@ following class allows interpolation with different splines.
 .. autosummary::
    :toctree: autosummary
 
-   skfda.representation.interpolation.SplineInterpolator
+   skfda.representation.interpolation.SplineInterpolation
 
 
 Basis representation
diff --git a/examples/plot_composition.py b/examples/plot_composition.py
index b390bfc7..9fdac453 100644
--- a/examples/plot_composition.py
+++ b/examples/plot_composition.py
@@ -10,10 +10,11 @@ This example shows the composition of multidimensional FDataGrids.
 
 # sphinx_gallery_thumbnail_number = 3
 
+import skfda
+
 from mpl_toolkits.mplot3d import axes3d
 
 import numpy as np
-import skfda
 
 
 ##############################################################################
@@ -42,7 +43,7 @@ sample_points = [X[0, :], Y[:, 0]]
 g = skfda.FDataGrid(data_matrix, sample_points)
 
 # Sets cubic interpolation
-g.interpolator = skfda.representation.interpolation.SplineInterpolator(
+g.interpolation = skfda.representation.interpolation.SplineInterpolation(
     interpolation_order=3)
 
 # Plots the surface
diff --git a/examples/plot_elastic_registration.py b/examples/plot_elastic_registration.py
index 4678ee6d..7c9bc898 100644
--- a/examples/plot_elastic_registration.py
+++ b/examples/plot_elastic_registration.py
@@ -10,13 +10,13 @@ Shows the usage of the elastic registration to perform a groupwise alignment.
 
 # sphinx_gallery_thumbnail_number = 5
 
-import numpy as np
 import skfda
-
 from skfda.datasets import make_multimodal_samples, fetch_growth
 from skfda.preprocessing.registration import ElasticRegistration
 from skfda.preprocessing.registration.elastic import elastic_mean
 
+import numpy as np
+
 
 ##############################################################################
 # In the example of pairwise alignment was shown the usage of
@@ -46,7 +46,6 @@ fd.plot()
 # deformations of the curves.
 
 
-
 fig = fd.mean().plot(label="L2 mean")
 elastic_mean(fd).plot(fig=fig, label="Elastic mean")
 fig.legend()
@@ -78,7 +77,7 @@ growth = fetch_growth()
 fd = growth['data'][growth['target'] == 0]
 
 # Obtain velocity curves
-fd.interpolator = skfda.representation.interpolation.SplineInterpolator(3)
+fd.interpolation = skfda.representation.interpolation.SplineInterpolation(3)
 fd = fd.to_grid(np.linspace(*fd.domain_range[0], 200)).derivative()
 fd = fd.to_grid(np.linspace(*fd.domain_range[0], 50))
 fd.plot()
diff --git a/examples/plot_interpolation.py b/examples/plot_interpolation.py
index 686c3f62..ef3155e2 100644
--- a/examples/plot_interpolation.py
+++ b/examples/plot_interpolation.py
@@ -11,12 +11,13 @@ FDataGrids.
 
 # sphinx_gallery_thumbnail_number = 3
 
+import skfda
+from skfda.representation.interpolation import SplineInterpolation
+
 from mpl_toolkits.mplot3d import axes3d
 
 import matplotlib.pyplot as plt
 import numpy as np
-import skfda
-from skfda.representation.interpolation import SplineInterpolator
 
 
 ##############################################################################
@@ -44,14 +45,14 @@ fd.scatter(fig=fig)
 
 ##############################################################################
 # The interpolation method of the FDataGrid could be changed setting the
-# attribute ``interpolator``. Once we have set an interpolator it is used for
+# attribute ``interpolation``. Once we have set an interpolation it is used for
 # the evaluation of the object.
 #
-# Polynomial spline interpolation could be performed using the interpolator
-# :class:`~skfda.representation.interpolation.SplineInterpolator`. In the
-# following example a cubic interpolator is set.
+# Polynomial spline interpolation could be performed using the interpolation
+# :class:`~skfda.representation.interpolation.SplineInterpolation. In the
+# following example a cubic interpolation is set.
 
-fd.interpolator = SplineInterpolator(interpolation_order=3)
+fd.interpolation = SplineInterpolation(interpolation_order=3)
 
 fig = fd.plot()
 fd.scatter(fig=fig)
@@ -59,21 +60,21 @@ fd.scatter(fig=fig)
 
 ##############################################################################
 # Smooth interpolation could be performed with the attribute
-# ``smoothness_parameter`` of the spline interpolator.
+# ``smoothness_parameter`` of the spline interpolation.
 #
 
 # Sample with noise
 fd_smooth = skfda.datasets.make_sinusoidal_process(n_samples=1, n_features=30,
                                                    random_state=1, error_std=.3)
 
-# Cubic interpolator
-fd_smooth.interpolator = SplineInterpolator(interpolation_order=3)
+# Cubic interpolation
+fd_smooth.interpolation = SplineInterpolation(interpolation_order=3)
 
 fig = fd_smooth.plot(label="Cubic")
 
 # Smooth interpolation
-fd_smooth.interpolator = SplineInterpolator(interpolation_order=3,
-                                            smoothness_parameter=1.5)
+fd_smooth.interpolation = SplineInterpolation(interpolation_order=3,
+                                              smoothness_parameter=1.5)
 
 fd_smooth.plot(fig=fig, label="Cubic smoothed")
 
@@ -95,7 +96,7 @@ fig = plt.figure()
 fig.add_subplot(1, 1, 1)
 
 for i in range(1, 4):
-    fd.interpolator = SplineInterpolator(interpolation_order=i)
+    fd.interpolation = SplineInterpolation(interpolation_order=i)
     fd.plot(fig=fig, derivative=1, label=f"Degree {i}")
 
 fig.legend()
@@ -130,15 +131,15 @@ fd_monotone = fd.copy(data_matrix=np.sort(fd.data_matrix, axis=1))
 fig = fd_monotone.plot(linestyle='--', label="cubic")
 
 
-fd_monotone.interpolator = SplineInterpolator(interpolation_order=3,
-                                              monotone=True)
+fd_monotone.interpolation = SplineInterpolation(interpolation_order=3,
+                                                monotone=True)
 fd_monotone.plot(fig=fig, label="PCHIP")
 
 fd_monotone.scatter(fig=fig, c='C1')
 fig.legend()
 
 ##############################################################################
-# All the interpolators will work regardless of the dimension of the image, but
+# All the interpolations will work regardless of the dimension of the image, but
 # depending on the domain dimension some methods will not be available.
 #
 # For the next examples it is constructed a surface, :math:`x_i: \mathbb{R}^2
@@ -160,14 +161,14 @@ fd.scatter(fig=fig)
 # In the following figure it is shown the result of the cubic interpolation
 # applied to the surface.
 #
-# The degree of the interpolator polynomial does not have to coincide in both
+# The degree of the interpolation polynomial does not have to coincide in both
 # directions, for example, cubic interpolation in the first
 # component and quadratic in the second one could be defined  using a tuple with
 # the values (3,2).
 #
 
 
-fd.interpolator = SplineInterpolator(interpolation_order=3)
+fd.interpolation = SplineInterpolation(interpolation_order=3)
 
 fig = fd.plot()
 fd.scatter(fig=fig)
@@ -183,7 +184,7 @@ fd.plot(derivative=(0, 1))
 
 ##############################################################################
 # The following table shows the interpolation methods available by the class
-# :class:`SplineInterpolator` depending on the domain dimension.
+# :class:`SplineInterpolation` depending on the domain dimension.
 #
 # +------------------+--------+----------------+----------+-------------+-------------+
 # | Domain dimension | Linear | Up to degree 5 | Monotone | Derivatives |  Smoothing  |
diff --git a/examples/plot_representation.py b/examples/plot_representation.py
index bdeccc7f..1763c488 100644
--- a/examples/plot_representation.py
+++ b/examples/plot_representation.py
@@ -9,8 +9,9 @@ Explores the different representations of functional data.
 # License: MIT
 
 import skfda
+from skfda.representation.interpolation import SplineInterpolation
+
 import skfda.representation.basis as basis
-from skfda.representation.interpolation import SplineInterpolator
 
 
 ##############################################################################
@@ -21,7 +22,6 @@ from skfda.representation.interpolation import SplineInterpolator
 # Growth Study. This dataset correspond to the height of several boys and
 # girls measured until the 18 years of age. The number and times of the
 # measurements are the same for each individual.
-
 dataset = skfda.datasets.fetch_growth()
 fd = dataset['data']
 y = dataset['target']
@@ -51,7 +51,7 @@ first_curve.plot()
 ##############################################################################
 # The interpolation used can however be changed. Here, we will use an
 # interpolation with degree 3 splines.
-first_curve.interpolator = SplineInterpolator(3)
+first_curve.interpolation = SplineInterpolation(3)
 first_curve.plot()
 
 ##############################################################################
diff --git a/skfda/datasets/_samples_generators.py b/skfda/datasets/_samples_generators.py
index 69c7260d..059cc348 100644
--- a/skfda/datasets/_samples_generators.py
+++ b/skfda/datasets/_samples_generators.py
@@ -7,7 +7,7 @@ import numpy as np
 from .. import FDataGrid
 from ..misc import covariances
 from ..preprocessing.registration import normalize_warping
-from ..representation.interpolation import SplineInterpolator
+from ..representation.interpolation import SplineInterpolation
 
 
 def make_gaussian_process(n_samples: int = 100, n_features: int = 100, *,
@@ -348,7 +348,7 @@ def make_random_warping(n_samples: int = 15, n_features: int = 100, *,
                                            axis=0)
     warping = FDataGrid(data_matrix.T, sample_points=time[:, 0])
     warping = normalize_warping(warping, domain_range=(start, stop))
-    warping.interpolator = SplineInterpolator(interpolation_order=3,
-                                              monotone=True)
+    warping.interpolation = SplineInterpolation(interpolation_order=3,
+                                                monotone=True)
 
     return warping
diff --git a/skfda/exploratory/visualization/_boxplot.py b/skfda/exploratory/visualization/_boxplot.py
index 67bf5260..b81b3c8a 100644
--- a/skfda/exploratory/visualization/_boxplot.py
+++ b/skfda/exploratory/visualization/_boxplot.py
@@ -160,10 +160,7 @@ class Boxplot(FDataBoxplot):
                 domain_range=array([[ 0, 10]]),
                 dataset_label='dataset',
                 axes_labels=['x_label', 'y_label'],
-                extrapolation=None,
-                interpolator=SplineInterpolator(interpolation_order=1,
-                smoothness_parameter=0.0, monotone=False),
-                keepdims=False),
+                ...),
             median=array([[ 0.5],
                           [ 0.5],
                           [ 1. ],
@@ -468,9 +465,7 @@ class SurfaceBoxplot(FDataBoxplot):
                 dataset_label='dataset',
                 axes_labels=['x1_label', 'x2_label', 'y_label'],
                 extrapolation=None,
-                interpolator=SplineInterpolator(interpolation_order=1,
-                smoothness_parameter=0.0, monotone=False),
-                keepdims=False),
+                ...),
             median=array([[[ 1. ],
                            [ 0.7],
                            [ 1. ]],
diff --git a/skfda/exploratory/visualization/_magnitude_shape_plot.py b/skfda/exploratory/visualization/_magnitude_shape_plot.py
index 345e6457..752f041f 100644
--- a/skfda/exploratory/visualization/_magnitude_shape_plot.py
+++ b/skfda/exploratory/visualization/_magnitude_shape_plot.py
@@ -105,9 +105,7 @@ class MagnitudeShapePlot:
                 dataset_label=None,
                 axes_labels=None,
                 extrapolation=None,
-                interpolator=SplineInterpolator(interpolation_order=1,
-                smoothness_parameter=0.0, monotone=False),
-                keepdims=False),
+                ...),
             depth_method=projection_depth,
             pointwise_weights=None,
             alpha=0.993,
diff --git a/skfda/preprocessing/registration/_landmark_registration.py b/skfda/preprocessing/registration/_landmark_registration.py
index 2036569f..5e8a9620 100644
--- a/skfda/preprocessing/registration/_landmark_registration.py
+++ b/skfda/preprocessing/registration/_landmark_registration.py
@@ -6,7 +6,7 @@ This module contains methods to perform the landmark registration.
 import numpy as np
 
 from ... import FDataGrid
-from ...representation.interpolation import SplineInterpolator
+from ...representation.interpolation import SplineInterpolation
 
 __author__ = "Pablo Marcos Manchón"
 __email__ = "pablo.marcosm@estudiante.uam.es"
@@ -251,11 +251,11 @@ def landmark_registration_warping(fd, landmarks, *, location=None,
         sample_points[-1] = fd.domain_range[0][1]
         sample_points[1:-1] = location
 
-    interpolator = SplineInterpolator(interpolation_order=3, monotone=True)
+    interpolation = SplineInterpolation(interpolation_order=3, monotone=True)
 
     warping = FDataGrid(data_matrix=data_matrix,
                         sample_points=sample_points,
-                        interpolator=interpolator,
+                        interpolation=interpolation,
                         extrapolation='bounds')
 
     try:
diff --git a/skfda/preprocessing/registration/elastic.py b/skfda/preprocessing/registration/elastic.py
index 4ef2533e..1bb6fec6 100644
--- a/skfda/preprocessing/registration/elastic.py
+++ b/skfda/preprocessing/registration/elastic.py
@@ -10,7 +10,7 @@ import numpy as np
 from . import invert_warping
 from ... import FDataGrid
 from ..._utils import check_is_univariate
-from ...representation.interpolation import SplineInterpolator
+from ...representation.interpolation import SplineInterpolation
 from ._warping import _normalize_scale
 from .base import RegistrationTransformer
 
@@ -450,11 +450,12 @@ class ElasticRegistration(RegistrationTransformer):
         gamma = _normalize_scale(
             gamma, a=output_points[0], b=output_points[-1])
 
-        # Interpolator
-        interpolator = SplineInterpolator(interpolation_order=3, monotone=True)
+        # Interpolation
+        interpolation = SplineInterpolation(
+            interpolation_order=3, monotone=True)
 
         self.warping_ = FDataGrid(gamma, output_points,
-                                  interpolator=interpolator)
+                                  interpolation=interpolation)
 
         return X.compose(self.warping_, eval_points=output_points)
 
@@ -626,11 +627,11 @@ def warping_mean(warping, *, max_iter=100, tol=1e-6, step_size=.3):
                                     a=original_eval_points[0],
                                     b=original_eval_points[-1])
 
-    monotone_interpolator = SplineInterpolator(interpolation_order=3,
-                                               monotone=True)
+    monotone_interpolation = SplineInterpolation(interpolation_order=3,
+                                                 monotone=True)
 
     mean = FDataGrid([warping_mean], sample_points=original_eval_points,
-                     interpolator=monotone_interpolator)
+                     interpolation=monotone_interpolation)
 
     return mean
 
@@ -699,7 +700,7 @@ def elastic_mean(fdatagrid, *, penalty=0., center=True, max_iter=20, tol=1e-3,
     eval_points_normalized = _normalize_scale(eval_points)
     y_scale = eval_points[-1] - eval_points[0]
 
-    interpolator = SplineInterpolator(interpolation_order=3, monotone=True)
+    interpolation = SplineInterpolation(interpolation_order=3, monotone=True)
 
     # Discretisation points
     fdatagrid_normalized = FDataGrid(fdatagrid(eval_points) / y_scale,
@@ -724,7 +725,7 @@ def elastic_mean(fdatagrid, *, penalty=0., center=True, max_iter=20, tol=1e-3,
         gammas = _elastic_alignment_array(
             mu, srsf, eval_points_normalized, penalty, grid_dim)
         gammas = FDataGrid(gammas, sample_points=eval_points_normalized,
-                           interpolator=interpolator)
+                           interpolation=interpolation)
 
         fdatagrid_normalized = fdatagrid_normalized.compose(gammas)
         srsf = srsf_transformer.transform(
diff --git a/skfda/representation/evaluator.py b/skfda/representation/evaluator.py
index 896a1714..4cf7c842 100644
--- a/skfda/representation/evaluator.py
+++ b/skfda/representation/evaluator.py
@@ -41,7 +41,7 @@ class Evaluator(ABC):
 
     An evaluator defines how to evaluate points of a functional object, it
     can be used as extrapolator to evaluate points outside the domain range or
-    as interpolator in a :class:`FDataGrid`. The corresponding examples of
+    as interpolation in a :class:`FDataGrid`. The corresponding examples of
     Interpolation and Extrapolation shows the basic usage of this class.
 
     The evaluator is called internally by :func:`evaluate`.
diff --git a/skfda/representation/grid.py b/skfda/representation/grid.py
index 0bf4b2b1..6fb7440a 100644
--- a/skfda/representation/grid.py
+++ b/skfda/representation/grid.py
@@ -18,7 +18,7 @@ import numpy as np
 from . import basis as fdbasis
 from .._utils import _list_of_arrays, constants
 from ._functional_data import FData
-from .interpolation import SplineInterpolator
+from .interpolation import SplineInterpolation
 
 
 __author__ = "Miguel Carbajo Berrocal"
@@ -47,7 +47,7 @@ class FDataGrid(FData):
             extrapolation. By default None, which does not apply any type of
             extrapolation. See `Extrapolation` for detailled information of the
             types of extrapolation.
-        interpolator (GridInterpolator): Defines the type of interpolation
+        interpolation (GridInterpolation): Defines the type of interpolation
             applied in `evaluate`.
         keepdims (bool):
 
@@ -129,7 +129,7 @@ class FDataGrid(FData):
     def __init__(self, data_matrix, sample_points=None,
                  domain_range=None, dataset_label=None,
                  axes_labels=None, extrapolation=None,
-                 interpolator=None, keepdims=False):
+                 interpolation=None, keepdims=False):
         """Construct a FDataGrid object.
 
         Args:
@@ -200,7 +200,7 @@ class FDataGrid(FData):
         if self.data_matrix.ndim == 1 + self.dim_domain:
             self.data_matrix = self.data_matrix[..., np.newaxis]
 
-        self.interpolator = interpolator
+        self.interpolation = interpolation
 
         super().__init__(extrapolation, dataset_label, axes_labels, keepdims)
 
@@ -348,27 +348,27 @@ class FDataGrid(FData):
         return self._domain_range
 
     @property
-    def interpolator(self):
+    def interpolation(self):
         """Defines the type of interpolation applied in `evaluate`."""
-        return self._interpolator
+        return self._interpolation
 
-    @interpolator.setter
-    def interpolator(self, new_interpolator):
-        """Sets the interpolator of the FDataGrid."""
-        if new_interpolator is None:
-            new_interpolator = SplineInterpolator()
+    @interpolation.setter
+    def interpolation(self, new_interpolation):
+        """Sets the interpolation of the FDataGrid."""
+        if new_interpolation is None:
+            new_interpolation = SplineInterpolation()
 
-        self._interpolator = new_interpolator
-        self._interpolator_evaluator = None
+        self._interpolation = new_interpolation
+        self._interpolation_evaluator = None
 
     @property
     def _evaluator(self):
-        """Return the evaluator constructed by the interpolator."""
+        """Return the evaluator constructed by the interpolation."""
 
-        if self._interpolator_evaluator is None:
-            self._interpolator_evaluator = self._interpolator.evaluator(self)
+        if self._interpolation_evaluator is None:
+            self._interpolation_evaluator = self._interpolation.evaluator(self)
 
-        return self._interpolator_evaluator
+        return self._interpolation_evaluator
 
     def _evaluate(self, eval_points, *, derivative=0):
         """"Evaluate the object or its derivatives at a list of values.
@@ -586,7 +586,7 @@ class FDataGrid(FData):
         if self.extrapolation != other.extrapolation:
             return False
 
-        if self.interpolator != other.interpolator:
+        if self.interpolation != other.interpolation:
             return False
 
         return True
@@ -863,7 +863,7 @@ class FDataGrid(FData):
              data_matrix=None, sample_points=None,
              domain_range=None, dataset_label=None,
              axes_labels=None, extrapolation=None,
-             interpolator=None, keepdims=None):
+             interpolation=None, keepdims=None):
         """Returns a copy of the FDataGrid.
 
         If an argument is provided the corresponding attribute in the new copy
@@ -891,8 +891,8 @@ class FDataGrid(FData):
         if extrapolation is None:
             extrapolation = self.extrapolation
 
-        if interpolator is None:
-            interpolator = self.interpolator
+        if interpolation is None:
+            interpolation = self.interpolation
 
         if keepdims is None:
             keepdims = self.keepdims
@@ -901,7 +901,7 @@ class FDataGrid(FData):
                          domain_range=domain_range,
                          dataset_label=dataset_label,
                          axes_labels=axes_labels, extrapolation=extrapolation,
-                         interpolator=interpolator, keepdims=keepdims)
+                         interpolation=interpolation, keepdims=keepdims)
 
     def shift(self, shifts, *, restrict_domain=False, extrapolation=None,
               eval_points=None):
@@ -1075,7 +1075,7 @@ class FDataGrid(FData):
                 f"\ndataset_label={repr(self.dataset_label)},"
                 f"\naxes_labels={repr(axes_labels)},"
                 f"\nextrapolation={repr(self.extrapolation)},"
-                f"\ninterpolator={repr(self.interpolator)},"
+                f"\ninterpolation={repr(self.interpolation)},"
                 f"\nkeepdims={repr(self.keepdims)})").replace('\n', '\n    ')
 
     def __getitem__(self, key):
diff --git a/skfda/representation/interpolation.py b/skfda/representation/interpolation.py
index 31666428..2daf0cb2 100644
--- a/skfda/representation/interpolation.py
+++ b/skfda/representation/interpolation.py
@@ -11,18 +11,18 @@ import numpy as np
 from .evaluator import Evaluator, EvaluatorConstructor
 
 
-# Scipy interpolator methods used internally
-class SplineInterpolator(EvaluatorConstructor):
-    r"""Spline interpolator of :class:`FDataGrid`.
+# Scipy interpolation methods used internally
+class SplineInterpolation(EvaluatorConstructor):
+    r"""Spline interpolation of :class:`FDataGrid`.
 
-    Spline interpolator of discretized functional objects. Implements different
+    Spline interpolation of discretized functional objects. Implements different
     interpolation methods based in splines, using the sample points of the
     grid as nodes to interpolate.
 
     See the interpolation example to a detailled explanation.
 
     Attributes:
-        interpolator_order (int, optional): Order of the interpolation, 1
+        interpolation_order (int, optional): Order of the interpolation, 1
             for linear interpolation, 2 for cuadratic, 3 for cubic and so
             on. In case of curves and surfaces there is available
             interpolation up to degree 5. For higher dimensional objects
@@ -41,10 +41,10 @@ class SplineInterpolator(EvaluatorConstructor):
 
     def __init__(self, interpolation_order=1, smoothness_parameter=0.,
                  monotone=False):
-        r"""Constructor of the SplineInterpolator.
+        r"""Constructor of the SplineInterpolation.
 
         Args:
-            interpolator_order (int, optional): Order of the interpolation, 1
+            interpolation_order (int, optional): Order of the interpolation, 1
                 for linear interpolation, 2 for cuadratic, 3 for cubic and so
                 on. In case of curves and surfaces there is available
                 interpolation up to degree 5. For higher dimensional objects
@@ -55,7 +55,7 @@ class SplineInterpolator(EvaluatorConstructor):
                 surfaces. If 0 the residuals of the interpolation will be 0.
                 Defaults 0.
             monotone (boolean, optional): Performs monotone interpolation in
-                curves using a PCHIP interpolator. Only valid for curves
+                curves using a PCHIP interpolation. Only valid for curves
                 (domain dimension equal to 1) and interpolation order equal
                 to 1 or 3.
                 Defaults false.
@@ -81,49 +81,49 @@ class SplineInterpolator(EvaluatorConstructor):
         return self._monotone
 
     def __eq__(self, other):
-        """Equality operator between SplineInterpolator"""
+        """Equality operator between SplineInterpolation"""
         return (super().__eq__(other) and
                 self.interpolation_order == other.interpolation_order and
                 self.smoothness_parameter == other.smoothness_parameter and
                 self.monotone == other.monotone)
 
     def evaluator(self, fdatagrid):
-        """Construct a SplineInterpolatorEvaluator used in the evaluation.
+        """Construct a SplineInterpolationEvaluator used in the evaluation.
 
         Args:
             fdatagrid (:class:`FDataGrid`): Functional object where the
                 evaluator will be used.
 
         Returns:
-            (:class:`SplineInterpolatorEvaluator`): Evaluator of the fdatagrid.
+            (:class:`SplineInterpolationEvaluator`): Evaluator of the fdatagrid.
 
         """
-        return SplineInterpolatorEvaluator(fdatagrid, self.interpolation_order,
-                                           self.smoothness_parameter,
-                                           self.monotone)
+        return SplineInterpolationEvaluator(fdatagrid, self.interpolation_order,
+                                            self.smoothness_parameter,
+                                            self.monotone)
 
     def __repr__(self):
-        """repr method of the interpolator"""
+        """repr method of the interpolation"""
         return (f"{type(self).__name__}("
                 f"interpolation_order={self.interpolation_order}, "
                 f"smoothness_parameter={self.smoothness_parameter}, "
                 f"monotone={self.monotone})")
 
 
-class SplineInterpolatorEvaluator(Evaluator):
-    r"""Spline interpolator evaluator of :class:`FDataGrid`.
+class SplineInterpolationEvaluator(Evaluator):
+    r"""Spline interpolation evaluator of :class:`FDataGrid`.
 
-    It is generated by the SplineInterpolator, and it is used internally
+    It is generated by the SplineInterpolation, and it is used internally
     during the evaluation.
 
-    Spline interpolator of discretized functional objects. Implements different
+    Spline interpolation of discretized functional objects. Implements different
     interpolation methods based in splines, using the sample points of the
     grid as nodes to interpolate.
 
     See the interpolation example to a detailled explanation.
 
     Attributes:
-        interpolator_order (int, optional): Order of the interpolation, 1
+        interpolation_order (int, optional): Order of the interpolation, 1
             for linear interpolation, 2 for cuadratic, 3 for cubic and so
             on. In case of curves and surfaces there is available
             interpolation up to degree 5. For higher dimensional objects
@@ -141,11 +141,11 @@ class SplineInterpolatorEvaluator(Evaluator):
     """
 
     def __init__(self, fdatagrid, k=1, s=0., monotone=False):
-        r"""Constructor of the SplineInterpolatorEvaluator.
+        r"""Constructor of the SplineInterpolationEvaluator.
 
         Args:
             fdatagir (fdatagrid): Grid to be interpolated.
-            interpolator_order (int, optional): Order of the interpolation, 1
+            interpolation_order (int, optional): Order of the interpolation, 1
                 for linear interpolation, 2 for cuadratic, 3 for cubic and so
                 on. In case of curves and surfaces there is available
                 interpolation up to degree 5. For higher dimensional objects
@@ -156,7 +156,7 @@ class SplineInterpolatorEvaluator(Evaluator):
                 surfaces. If 0 the residuals of the interpolation will be 0.
                 Defaults 0.
             monotone (boolean, optional): Performs monotone interpolation in
-                curves using a PCHIP interpolator. Only valid for curves
+                curves using a PCHIP interpolation. Only valid for curves
                 (domain dimension equal to 1) and interpolation order equal to
                 1 or 3.
                 Defaults false.
@@ -198,23 +198,23 @@ class SplineInterpolatorEvaluator(Evaluator):
 
     def _construct_spline_1_m(self, sample_points, data_matrix,
                               k, s, monotone):
-        r"""Construct the matrix of interpolators for curves.
+        r"""Construct the matrix of interpolations for curves.
 
-        Constructs the matrix of interpolators for objects with domain
+        Constructs the matrix of interpolations for objects with domain
         dimension = 1. Calling internally during the creationg of the
         evaluator.
 
-        Uses internally the scipy interpolator UnivariateSpline or
+        Uses internally the scipy interpolation UnivariateSpline or
         PchipInterpolator.
 
         Args:
             sample_points (np.ndarray): Sample points of the fdatagrid.
             data_matrix (np.ndarray): Data matrix of the fdatagrid.
-            k (integer): Order of the spline interpolators.
+            k (integer): Order of the spline interpolations.
 
         Returns:
             (np.ndarray): Array of size n_samples x dim_codomain with the
-            corresponding interpolator of the sample i, and image dimension j
+            corresponding interpolation of the sample i, and image dimension j
             in the entry (i,j) of the array.
 
         Raises:
@@ -259,34 +259,34 @@ class SplineInterpolatorEvaluator(Evaluator):
 
         if monotone:
             def constructor(data):
-                """Constructs an unidimensional cubic monotone interpolator"""
+                """Constructs an unidimensional cubic monotone interpolation"""
                 return PchipInterpolator(sample_points, data)
 
         else:
 
             def constructor(data):
-                """Constructs an unidimensional interpolator"""
+                """Constructs an unidimensional interpolation"""
                 return UnivariateSpline(sample_points, data, s=s, k=k)
 
         return np.apply_along_axis(constructor, 1, data_matrix)
 
     def _construct_spline_2_m(self, sample_points, data_matrix, k, s):
-        r"""Construct the matrix of interpolators for surfaces.
+        r"""Construct the matrix of interpolations for surfaces.
 
-        Constructs the matrix of interpolators for objects with domain
+        Constructs the matrix of interpolations for objects with domain
         dimension = 2. Calling internally during the creationg of the
         evaluator.
 
-        Uses internally the scipy interpolator RectBivariateSpline.
+        Uses internally the scipy interpolation RectBivariateSpline.
 
         Args:
             sample_points (np.ndarray): Sample points of the fdatagrid.
             data_matrix (np.ndarray): Data matrix of the fdatagrid.
-            k (integer): Order of the spline interpolators.
+            k (integer): Order of the spline interpolations.
 
         Returns:
             (np.ndarray): Array of size n_samples x dim_codomain with the
-            corresponding interpolator of the sample i, and image dimension j
+            corresponding interpolation of the sample i, and image dimension j
             in the entry (i,j) of the array.
 
         Raises:
@@ -336,24 +336,24 @@ class SplineInterpolatorEvaluator(Evaluator):
         return spline
 
     def _construct_spline_n_m(self, sample_points, data_matrix, k):
-        r"""Construct the matrix of interpolators.
+        r"""Construct the matrix of interpolations.
 
-        Constructs the matrix of interpolators for objects with domain
+        Constructs the matrix of interpolations for objects with domain
         dimension > 2. Calling internally during the creationg of the
         evaluator.
 
-        Only linear and nearest interpolators are available for objects with
-        domain dimension >= 3. Uses internally the scipy interpolator
+        Only linear and nearest interpolations are available for objects with
+        domain dimension >= 3. Uses internally the scipy interpolation
         RegularGridInterpolator.
 
         Args:
             sample_points (np.ndarray): Sample points of the fdatagrid.
             data_matrix (np.ndarray): Data matrix of the fdatagrid.
-            k (integer): Order of the spline interpolators.
+            k (integer): Order of the spline interpolations.
 
         Returns:
             (np.ndarray): Array of size n_samples x dim_codomain with the
-            corresponding interpolator of the sample i, and image dimension j
+            corresponding interpolation of the sample i, and image dimension j
             in the entry (i,j) of the array.
 
         Raises:


Test patch:
diff --git a/tests/test_interpolation.py b/tests/test_interpolation.py
index 369f2124..adebea9a 100644
--- a/tests/test_interpolation.py
+++ b/tests/test_interpolation.py
@@ -1,13 +1,14 @@
 
-import unittest
 from skfda import FDataGrid
-from skfda.representation.interpolation import SplineInterpolator
+from skfda.representation.interpolation import SplineInterpolation
+import unittest
+
 import numpy as np
 
-# TODO: Unitest for grids with domain dimension > 1
 
+# TODO: Unitest for grids with domain dimension > 1
 class TestEvaluationSpline1_1(unittest.TestCase):
-    """Test the evaluation of a grid spline interpolator with
+    """Test the evaluation of a grid spline interpolation with
     domain and image dimension equal to 1.
     """
 
@@ -19,7 +20,6 @@ class TestEvaluationSpline1_1(unittest.TestCase):
         self.data_matrix_1_1 = [np.arange(10)**2,
                                 np.arange(start=9, stop=-1, step=-1)**2]
 
-
     def test_evaluation_linear_simple(self):
         """Test basic usage of evaluation"""
 
@@ -30,9 +30,9 @@ class TestEvaluationSpline1_1(unittest.TestCase):
             f(np.arange(10)), self.data_matrix_1_1)
 
         # Test evaluation in a list of times
-        np.testing.assert_array_almost_equal(f([0.5,1.5,2.5]),
-                                      np.array([[ 0.5,  2.5,  6.5],
-                                                [72.5, 56.5, 42.5]]))
+        np.testing.assert_array_almost_equal(f([0.5, 1.5, 2.5]),
+                                             np.array([[0.5,  2.5,  6.5],
+                                                       [72.5, 56.5, 42.5]]))
 
     def test_evaluation_linear_point(self):
         """Test the evaluation of a single point"""
@@ -41,20 +41,19 @@ class TestEvaluationSpline1_1(unittest.TestCase):
 
         # Test a single point
         np.testing.assert_array_almost_equal(f(5.3).round(1),
-                                      np.array([[28.3], [13.9]]))
+                                             np.array([[28.3], [13.9]]))
         np.testing.assert_array_almost_equal(f([3]), np.array([[9.], [36.]]))
         np.testing.assert_array_almost_equal(f((2,)), np.array([[4.], [49.]]))
 
-
     def test_evaluation_linear_derivative(self):
         """Test derivative"""
         f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10))
 
         # Derivate = [2*x, 2*(9-x)]
         np.testing.assert_array_almost_equal(
-            f([0.5,1.5,2.5], derivative=1).round(3),
-                                      np.array([[  1.,   3.,   5.],
-                                                [-17., -15., -13.]]))
+            f([0.5, 1.5, 2.5], derivative=1).round(3),
+            np.array([[1.,   3.,   5.],
+                      [-17., -15., -13.]]))
 
     def test_evaluation_linear_grid(self):
         """Test grid evaluation. With domain dimension = 1"""
@@ -65,8 +64,8 @@ class TestEvaluationSpline1_1(unittest.TestCase):
         np.testing.assert_array_almost_equal(f(np.arange(10)),
                                              self.data_matrix_1_1)
 
-        res = np.array([[ 0.5,  2.5,  6.5], [72.5, 56.5, 42.5]])
-        t = [0.5,1.5,2.5]
+        res = np.array([[0.5,  2.5,  6.5], [72.5, 56.5, 42.5]])
+        t = [0.5, 1.5, 2.5]
 
         # Test evaluation in a list of times
         np.testing.assert_array_almost_equal(f(t, grid=True), res)
@@ -77,28 +76,29 @@ class TestEvaluationSpline1_1(unittest.TestCase):
                                              np.array([[9.], [36.]]))
 
         # Check erroneous axis
-        with np.testing.assert_raises(ValueError): f((t,t), grid=True)
+        with np.testing.assert_raises(ValueError):
+            f((t, t), grid=True)
 
     def test_evaluation_linear_composed(self):
 
         f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10))
 
         # Evaluate (x**2, (9-x)**2) in (1,8)
-        np.testing.assert_array_almost_equal(f([[1],[8]],
+        np.testing.assert_array_almost_equal(f([[1], [8]],
                                                aligned_evaluation=False),
-                                      np.array([[1.], [1.]]))
+                                             np.array([[1.], [1.]]))
 
-        t = np.linspace(4,6,4)
+        t = np.linspace(4, 6, 4)
         np.testing.assert_array_almost_equal(
-            f([t,9-t], aligned_evaluation=False).round(2),
-            np.array([[16.  , 22.  , 28.67, 36.  ],
-                      [16.  , 22.  , 28.67, 36.  ]]))
+            f([t, 9 - t], aligned_evaluation=False).round(2),
+            np.array([[16., 22., 28.67, 36.],
+                      [16., 22., 28.67, 36.]]))
 
         # Same length than nsample
-        t = np.linspace(4,6,2)
+        t = np.linspace(4, 6, 2)
         np.testing.assert_array_almost_equal(
-            f([t,9-t], aligned_evaluation=False).round(2),
-            np.array([[16.  , 36.], [16.  , 36.]]))
+            f([t, 9 - t], aligned_evaluation=False).round(2),
+            np.array([[16., 36.], [16., 36.]]))
 
     def test_evaluation_linear_keepdims(self):
         """Test parameter keepdims"""
@@ -111,10 +111,9 @@ class TestEvaluationSpline1_1(unittest.TestCase):
         fk = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
                        keepdims=True)
 
-        t = [0.5,1.5,2.5]
-        res = np.array([[ 0.5,  2.5,  6.5], [72.5, 56.5, 42.5]])
-        res_keepdims = res.reshape((2,3,1))
-
+        t = [0.5, 1.5, 2.5]
+        res = np.array([[0.5,  2.5,  6.5], [72.5, 56.5, 42.5]])
+        res_keepdims = res.reshape((2, 3, 1))
 
         # Test combinations of keepdims with list
         np.testing.assert_array_almost_equal(f(t), res)
@@ -123,20 +122,23 @@ class TestEvaluationSpline1_1(unittest.TestCase):
 
         np.testing.assert_array_almost_equal(fk(t), res_keepdims)
         np.testing.assert_array_almost_equal(fk(t, keepdims=False), res)
-        np.testing.assert_array_almost_equal(fk(t, keepdims=True), res_keepdims)
+        np.testing.assert_array_almost_equal(
+            fk(t, keepdims=True), res_keepdims)
 
         t2 = 4
         res2 = np.array([[16.], [25.]])
-        res2_keepdims = res2.reshape(2,1,1)
+        res2_keepdims = res2.reshape(2, 1, 1)
 
         # Test combinations of keepdims with a single point
         np.testing.assert_array_almost_equal(f(t2), res2)
         np.testing.assert_array_almost_equal(f(t2, keepdims=False), res2)
-        np.testing.assert_array_almost_equal(f(t2, keepdims=True), res2_keepdims)
+        np.testing.assert_array_almost_equal(
+            f(t2, keepdims=True), res2_keepdims)
 
         np.testing.assert_array_almost_equal(fk(t2), res2_keepdims)
         np.testing.assert_array_almost_equal(fk(t2, keepdims=False), res2)
-        np.testing.assert_array_almost_equal(fk(t2, keepdims=True), res2_keepdims)
+        np.testing.assert_array_almost_equal(
+            fk(t2, keepdims=True), res2_keepdims)
 
     def test_evaluation_composed_linear_keepdims(self):
         """Test parameter keepdims with composed evaluation"""
@@ -150,23 +152,24 @@ class TestEvaluationSpline1_1(unittest.TestCase):
                        keepdims=True)
 
         t = np.array([1, 2, 3])
-        t = [t, 9 -  t]
-        res = np.array([[ 1.,  4.,  9.], [ 1.,  4.,  9.]])
-        res_keepdims = res.reshape((2,3,1))
+        t = [t, 9 - t]
+        res = np.array([[1.,  4.,  9.], [1.,  4.,  9.]])
+        res_keepdims = res.reshape((2, 3, 1))
 
         # Test combinations of keepdims with list
-        np.testing.assert_array_almost_equal(f(t, aligned_evaluation=False), res)
+        np.testing.assert_array_almost_equal(
+            f(t, aligned_evaluation=False), res)
         np.testing.assert_array_almost_equal(f(t, aligned_evaluation=False,
-                                        keepdims=False), res)
+                                               keepdims=False), res)
         np.testing.assert_array_almost_equal(f(t, aligned_evaluation=False,
-                                        keepdims=True), res_keepdims)
+                                               keepdims=True), res_keepdims)
 
         np.testing.assert_array_almost_equal(fk(t, aligned_evaluation=False),
-                                      res_keepdims)
+                                             res_keepdims)
         np.testing.assert_array_almost_equal(fk(t, aligned_evaluation=False,
-                                         keepdims=False), res)
+                                                keepdims=False), res)
         np.testing.assert_array_almost_equal(fk(t, aligned_evaluation=False,
-                                         keepdims=True), res_keepdims)
+                                                keepdims=True), res_keepdims)
 
     def test_evaluation_grid_linear_keepdims(self):
         """Test grid evaluation with keepdims"""
@@ -179,130 +182,132 @@ class TestEvaluationSpline1_1(unittest.TestCase):
         fk = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
                        keepdims=True)
 
-        t = [0.5,1.5,2.5]
-        res = np.array([[ 0.5,  2.5,  6.5], [72.5, 56.5, 42.5]])
-        res_keepdims = res.reshape(2,3,1)
+        t = [0.5, 1.5, 2.5]
+        res = np.array([[0.5,  2.5,  6.5], [72.5, 56.5, 42.5]])
+        res_keepdims = res.reshape(2, 3, 1)
 
         np.testing.assert_array_almost_equal(f(t, grid=True), res)
         np.testing.assert_array_almost_equal(f((t,), grid=True, keepdims=True),
-                                      res_keepdims)
-        np.testing.assert_array_almost_equal(f([t], grid=True, keepdims=False), res)
+                                             res_keepdims)
+        np.testing.assert_array_almost_equal(
+            f([t], grid=True, keepdims=False), res)
 
         np.testing.assert_array_almost_equal(fk(t, grid=True), res_keepdims)
         np.testing.assert_array_almost_equal(fk((t,), grid=True, keepdims=True),
-                                      res_keepdims)
-        np.testing.assert_array_almost_equal(fk([t], grid=True, keepdims=False), res)
+                                             res_keepdims)
+        np.testing.assert_array_almost_equal(
+            fk([t], grid=True, keepdims=False), res)
 
     def test_evaluation_cubic_simple(self):
         """Test basic usage of evaluation"""
 
         f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
-                      interpolator=SplineInterpolator(3))
+                      interpolation=SplineInterpolation(3))
 
         # Test interpolation in nodes
         np.testing.assert_array_almost_equal(f(np.arange(10)).round(1),
-                                      self.data_matrix_1_1)
+                                             self.data_matrix_1_1)
 
         # Test evaluation in a list of times
-        np.testing.assert_array_almost_equal(f([0.5,1.5,2.5]).round(2),
-                                      np.array([[ 0.25,  2.25,  6.25],
-                                                [72.25, 56.25, 42.25]]))
+        np.testing.assert_array_almost_equal(f([0.5, 1.5, 2.5]).round(2),
+                                             np.array([[0.25,  2.25,  6.25],
+                                                       [72.25, 56.25, 42.25]]))
 
     def test_evaluation_cubic_point(self):
         """Test the evaluation of a single point"""
 
         f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
-                      interpolator=SplineInterpolator(3))
+                      interpolation=SplineInterpolation(3))
 
         # Test a single point
         np.testing.assert_array_almost_equal(f(5.3).round(3), np.array([[28.09],
-                                                                 [13.69]]))
-
-        np.testing.assert_array_almost_equal(f([3]).round(3), np.array([[9.], [36.]]))
-        np.testing.assert_array_almost_equal(f((2,)).round(3), np.array([[4.], [49.]]))
+                                                                        [13.69]]))
 
+        np.testing.assert_array_almost_equal(
+            f([3]).round(3), np.array([[9.], [36.]]))
+        np.testing.assert_array_almost_equal(
+            f((2,)).round(3), np.array([[4.], [49.]]))
 
     def test_evaluation_cubic_derivative(self):
         """Test derivative"""
         f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
-                      interpolator=SplineInterpolator(3))
+                      interpolation=SplineInterpolation(3))
 
         # Derivate = [2*x, 2*(9-x)]
-        np.testing.assert_array_almost_equal(f([0.5,1.5,2.5], derivative=1).round(3),
-                                      np.array([[  1.,   3.,   5.],
-                                                [-17., -15., -13.]]))
+        np.testing.assert_array_almost_equal(f([0.5, 1.5, 2.5], derivative=1).round(3),
+                                             np.array([[1.,   3.,   5.],
+                                                       [-17., -15., -13.]]))
 
     def test_evaluation_cubic_grid(self):
         """Test grid evaluation. With domain dimension = 1"""
 
         f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
-                      interpolator=SplineInterpolator(3))
-
-        t = [0.5,1.5,2.5]
-        res = np.array([[ 0.25,  2.25,  6.25], [72.25, 56.25, 42.25]])
+                      interpolation=SplineInterpolation(3))
 
+        t = [0.5, 1.5, 2.5]
+        res = np.array([[0.25,  2.25,  6.25], [72.25, 56.25, 42.25]])
 
         # Test evaluation in a list of times
         np.testing.assert_array_almost_equal(f(t, grid=True).round(3), res)
         np.testing.assert_array_almost_equal(f((t,), grid=True).round(3), res)
         np.testing.assert_array_almost_equal(f([t], grid=True).round(3), res)
         # Single point with grid
-        np.testing.assert_array_almost_equal(f(3, grid=True), np.array([[9.], [36.]]))
+        np.testing.assert_array_almost_equal(
+            f(3, grid=True), np.array([[9.], [36.]]))
 
         # Check erroneous axis
-        with np.testing.assert_raises(ValueError): f((t,t), grid=True)
+        with np.testing.assert_raises(ValueError):
+            f((t, t), grid=True)
 
     def test_evaluation_cubic_composed(self):
 
         f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
-                      interpolator=SplineInterpolator(3))
-
+                      interpolation=SplineInterpolation(3))
 
         # Evaluate (x**2, (9-x)**2) in (1,8)
-        np.testing.assert_array_almost_equal(f([[1],[8]], aligned_evaluation=False).round(3)
-                                      ,np.array([[1.], [1.]]))
+        np.testing.assert_array_almost_equal(
+            f([[1], [8]], aligned_evaluation=False).round(3), np.array([[1.], [1.]]))
 
-        t = np.linspace(4,6,4)
-        np.testing.assert_array_almost_equal(f([t,9-t], aligned_evaluation=False).round(2),
-                                      np.array([[16.  , 21.78, 28.44, 36.  ],
-                                                [16.  , 21.78, 28.44, 36.  ]]))
+        t = np.linspace(4, 6, 4)
+        np.testing.assert_array_almost_equal(f([t, 9 - t], aligned_evaluation=False).round(2),
+                                             np.array([[16., 21.78, 28.44, 36.],
+                                                       [16., 21.78, 28.44, 36.]]))
 
         # Same length than nsample
-        t = np.linspace(4,6,2)
-        np.testing.assert_array_almost_equal(f([t,9-t], aligned_evaluation=False).round(3),
-                                      np.array([[16.  , 36.], [16.  , 36.]]))
+        t = np.linspace(4, 6, 2)
+        np.testing.assert_array_almost_equal(f([t, 9 - t], aligned_evaluation=False).round(3),
+                                             np.array([[16., 36.], [16., 36.]]))
 
     def test_evaluation_nodes(self):
         """Test interpolation in nodes for all dimensions"""
 
-        for degree in range(1,6):
-            interpolator = SplineInterpolator(degree)
+        for degree in range(1, 6):
+            interpolation = SplineInterpolation(degree)
 
             f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
-                          interpolator=interpolator)
+                          interpolation=interpolation)
 
             # Test interpolation in nodes
             np.testing.assert_array_almost_equal(f(np.arange(10)).round(5),
-                                          self.data_matrix_1_1)
+                                                 self.data_matrix_1_1)
 
     def test_error_degree(self):
 
-
         with np.testing.assert_raises(ValueError):
-            interpolator = SplineInterpolator(7)
+            interpolation = SplineInterpolation(7)
             f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
-                          interpolator=interpolator)
+                          interpolation=interpolation)
             f(1)
 
         with np.testing.assert_raises(ValueError):
-            interpolator = SplineInterpolator(0)
+            interpolation = SplineInterpolation(0)
             f = FDataGrid(self.data_matrix_1_1, sample_points=np.arange(10),
-                          interpolator=interpolator)
+                          interpolation=interpolation)
             f(1)
 
 
 class TestEvaluationSpline1_n(unittest.TestCase):
-    """Test the evaluation of a grid spline interpolator with
+    """Test the evaluation of a grid spline interpolation with
     domain dimension equal to 1 and arbitary image dimension.
     """
 
@@ -316,29 +321,28 @@ class TestEvaluationSpline1_n(unittest.TestCase):
 
         data_1 = np.array([np.arange(10)**2,
                            np.arange(start=9, stop=-1, step=-1)**2])
-        data_2 = np.sin(np.pi/81 * data_1)
-
-        self.data_matrix_1_n = np.dstack((data_1,data_2))
+        data_2 = np.sin(np.pi / 81 * data_1)
 
-        self.interpolator = SplineInterpolator(interpolation_order=2)
+        self.data_matrix_1_n = np.dstack((data_1, data_2))
 
+        self.interpolation = SplineInterpolation(interpolation_order=2)
 
     def test_evaluation_simple(self):
         """Test basic usage of evaluation"""
 
         f = FDataGrid(self.data_matrix_1_n, sample_points=np.arange(10),
-                      interpolator=self.interpolator)
+                      interpolation=self.interpolation)
 
         # Test interpolation in nodes
         np.testing.assert_array_almost_equal(f(self.t), self.data_matrix_1_n)
         # Test evaluation in a list of times
-        np.testing.assert_array_almost_equal(f([1.5,2.5,3.5]),
-                                             np.array([[[ 2.25    ,  0.087212],
-                                                        [ 6.25    ,  0.240202],
-                                                        [12.25    ,  0.45773 ]],
-                                                       [[56.25    ,  0.816142],
-                                                        [42.25    ,  0.997589],
-                                                        [30.25    ,  0.922146]]]
+        np.testing.assert_array_almost_equal(f([1.5, 2.5, 3.5]),
+                                             np.array([[[2.25,  0.087212],
+                                                        [6.25,  0.240202],
+                                                        [12.25,  0.45773]],
+                                                       [[56.25,  0.816142],
+                                                        [42.25,  0.997589],
+                                                        [30.25,  0.922146]]]
                                                       )
                                              )
 
@@ -346,42 +350,42 @@ class TestEvaluationSpline1_n(unittest.TestCase):
         """Test the evaluation of a single point"""
 
         f = FDataGrid(self.data_matrix_1_n, sample_points=np.arange(10),
-                      interpolator=self.interpolator)
+                      interpolation=self.interpolation)
 
         # Test a single point
         np.testing.assert_array_almost_equal(f(5.3),
-                                             np.array([[[28.09    ,  0.885526]],
-                                                       [[13.69    ,  0.50697 ]]]
+                                             np.array([[[28.09,  0.885526]],
+                                                       [[13.69,  0.50697]]]
                                                       )
                                              )
 
     def test_evaluation_derivative(self):
         """Test derivative"""
         f = FDataGrid(self.data_matrix_1_n, sample_points=self.t,
-                      interpolator=self.interpolator)
+                      interpolation=self.interpolation)
 
         # [(2*x, d/dx sin(pi/81*x**2)), (2*(9-x), d/dx sin(pi/81*(9-x)**2))]
-        np.testing.assert_array_almost_equal(f([1.5,2.5,3.5], derivative=1),
-                                             np.array([[[  3.   , 0.1162381],
-                                                        [  5.   , 0.1897434],
-                                                        [  7.   , 0.2453124]],
-                                                       [[-15.   , 0.3385772],
-                                                        [-13.   , 0.0243172],
-                                                        [-11.   ,-0.1752035]]]))
+        np.testing.assert_array_almost_equal(f([1.5, 2.5, 3.5], derivative=1),
+                                             np.array([[[3., 0.1162381],
+                                                        [5., 0.1897434],
+                                                        [7., 0.2453124]],
+                                                       [[-15., 0.3385772],
+                                                        [-13., 0.0243172],
+                                                        [-11., -0.1752035]]]))
 
     def test_evaluation_grid(self):
         """Test grid evaluation. With domain dimension = 1"""
 
         f = FDataGrid(self.data_matrix_1_n, sample_points=np.arange(10),
-                      interpolator=SplineInterpolator(2))
+                      interpolation=SplineInterpolation(2))
 
-        t = [1.5,2.5,3.5]
-        res = np.array([[[ 2.25      ,  0.08721158],
-                         [ 6.25      ,  0.24020233],
-                         [12.25      ,  0.4577302 ]],
-                        [[56.25      ,  0.81614206],
-                         [42.25      ,  0.99758925],
-                         [30.25      ,  0.92214607]]])
+        t = [1.5, 2.5, 3.5]
+        res = np.array([[[2.25,  0.08721158],
+                         [6.25,  0.24020233],
+                         [12.25,  0.4577302]],
+                        [[56.25,  0.81614206],
+                         [42.25,  0.99758925],
+                         [30.25,  0.92214607]]])
 
         # Test evaluation in a list of times
         np.testing.assert_array_almost_equal(f(t, grid=True), res)
@@ -389,31 +393,30 @@ class TestEvaluationSpline1_n(unittest.TestCase):
         np.testing.assert_array_almost_equal(f([t], grid=True), res)
 
         # Check erroneous axis
-        with np.testing.assert_raises(ValueError): f((t,t), grid=True)
+        with np.testing.assert_raises(ValueError):
+            f((t, t), grid=True)
 
     def test_evaluation_composed(self):
 
         f = FDataGrid(self.data_matrix_1_n, sample_points=self.t,
-                      interpolator=self.interpolator)
-
+                      interpolation=self.interpolation)
 
         # Evaluate (x**2, (9-x)**2) in (1,8)
-        np.testing.assert_array_almost_equal(f([[1],[4]],
+        np.testing.assert_array_almost_equal(f([[1], [4]],
                                                aligned_evaluation=False)[0],
                                              f(1)[0])
-        np.testing.assert_array_almost_equal(f([[1],[4]],
+        np.testing.assert_array_almost_equal(f([[1], [4]],
                                                aligned_evaluation=False)[1],
                                              f(4)[1])
 
-
     def test_evaluation_keepdims(self):
         """Test keepdims"""
 
         f = FDataGrid(self.data_matrix_1_n, sample_points=np.arange(10),
-                      interpolator=self.interpolator, keepdims=True)
+                      interpolation=self.interpolation, keepdims=True)
 
         fk = FDataGrid(self.data_matrix_1_n, sample_points=np.arange(10),
-                      interpolator=self.interpolator, keepdims=False)
+                       interpolation=self.interpolation, keepdims=False)
 
         res = f(self.t)
         # Test interpolation in nodes
@@ -423,25 +426,20 @@ class TestEvaluationSpline1_n(unittest.TestCase):
         np.testing.assert_array_almost_equal(fk(self.t, keepdims=False), res)
         np.testing.assert_array_almost_equal(fk(self.t, keepdims=True), res)
 
-
     def test_evaluation_nodes(self):
         """Test interpolation in nodes for all dimensions"""
 
-        for degree in range(1,6):
-            interpolator = SplineInterpolator(degree)
+        for degree in range(1, 6):
+            interpolation = SplineInterpolation(degree)
 
             f = FDataGrid(self.data_matrix_1_n, sample_points=np.arange(10),
-                          interpolator=interpolator)
+                          interpolation=interpolation)
 
             # Test interpolation in nodes
             np.testing.assert_array_almost_equal(f(np.arange(10)),
                                                  self.data_matrix_1_n)
 
 
-
-
-
-
 if __name__ == '__main__':
     print()
     unittest.main()
diff --git a/tests/test_registration.py b/tests/test_registration.py
index e71dc56b..07f997c7 100644
--- a/tests/test_registration.py
+++ b/tests/test_registration.py
@@ -10,7 +10,7 @@ from skfda.preprocessing.registration.validation import (
     AmplitudePhaseDecomposition, LeastSquares,
     SobolevLeastSquares, PairwiseCorrelation)
 from skfda.representation.basis import Fourier
-from skfda.representation.interpolation import SplineInterpolator
+from skfda.representation.interpolation import SplineInterpolation
 import unittest
 
 from sklearn.exceptions import NotFittedError
@@ -25,9 +25,9 @@ class TestWarping(unittest.TestCase):
         """Initialization of samples"""
 
         self.time = np.linspace(-1, 1, 50)
-        interpolator = SplineInterpolator(3, monotone=True)
+        interpolation = SplineInterpolation(3, monotone=True)
         self.polynomial = FDataGrid([self.time**3, self.time**5],
-                                    self.time, interpolator=interpolator)
+                                    self.time, interpolation=interpolation)
 
     def test_invert_warping(self):