diff --git a/docs/examples.md b/docs/examples.md
index 7b4b269b2f..6c6f418fff 100644
--- a/docs/examples.md
+++ b/docs/examples.md
@@ -183,6 +183,17 @@ Overview of Transformations
 
 :::
 
+:::{grid-item-card}
+:img-top: examples/transformations/img/preprocessing.png
+:class-img-top: aeon-card-image-m
+:link: /examples/transformations/preprocessing.ipynb
+:link-type: ref
+:text-align: center
+
+Preprocessing time series
+
+:::
+
 :::{grid-item-card}
 :img-top: examples/transformations/img/tsfresh.png
 :class-img-top: aeon-card-image-m
@@ -238,17 +249,6 @@ SAST transform
 
 :::
 
-:::{grid-item-card}
-:img-top: examples/transformations/img/interpolation.png
-:class-img-top: aeon-card-image-m
-:link: /examples/transformations/interpolation.ipynb
-:link-type: ref
-:text-align: center
-
-Interpolation
-
-:::
-
 :::{grid-item-card}
 :img-top: examples/transformations/img/signature.png
 :class-img-top: aeon-card-image-m
@@ -260,17 +260,6 @@ Signature method
 
 :::
 
-:::{grid-item-card}
-:img-top: examples/transformations/img/theta.png
-:class-img-top: aeon-card-image-m
-:link: /examples/transformations/theta_transform.ipynb
-:link-type: ref
-:text-align: center
-
-Theta transform
-
-:::
-
 ::::
 
 ## Segmentation
@@ -343,7 +332,7 @@ Using aeon distances with scikit-learn
 
 ::::
 
-## Similarity search
+## Similarity Search
 
 ::::{grid} 2 3 4 4
 :gutter: 1
diff --git a/examples/transformations/img/preprocessing.png b/examples/transformations/img/preprocessing.png
new file mode 100644
index 0000000000..db183dde2e
Binary files /dev/null and b/examples/transformations/img/preprocessing.png differ
diff --git a/examples/transformations/preprocessing.ipynb b/examples/transformations/preprocessing.ipynb
index 6b82b3d226..9d3bbab247 100644
--- a/examples/transformations/preprocessing.ipynb
+++ b/examples/transformations/preprocessing.ipynb
@@ -6,11 +6,12 @@
     "# Preprocessing time series with aeon\n",
     "\n",
     "It is common to need to preprocess time series data before applying machine learning\n",
-    "algorithms. Transformers in `aeon` can be used to preprocess collections of time\n",
-    "series. This notebook demonstrates three common use cases\n",
+    "algorithms. So algorithms can handle these characteristics, or `aeon` transformers can be used to preprocess collections of time\n",
+    "series into standard format. This notebook demonstrates three common use cases\n",
     "\n",
-    "1. Rescaling time series\n",
-    "2. Resizing time series\n"
+    "1. [Rescaling time series](#Rescaling-time-series)\n",
+    "2. [Resizing time series](#Resizing-time-series)\n",
+    "3. [Dealing with missing values](#missing-values)\n"
    ],
    "metadata": {
     "collapsed": false
@@ -34,17 +35,6 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "array([[561.875     ],\n       [604.95833333],\n       [629.16666667],\n       [801.45833333],\n       [540.75      ]])"
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
     "import numpy as np\n",
     "\n",
@@ -54,28 +44,59 @@
     "np.mean(X, axis=-1)[0:5]"
    ],
    "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:32:56.353179Z",
+     "start_time": "2024-11-12T16:32:56.335570Z"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "array([[428.95224215],\n       [483.35481095],\n       [514.90052977],\n       [629.00847763],\n       [389.10059218]])"
+      "text/plain": [
+       "array([[561.875     ],\n",
+       "       [604.95833333],\n",
+       "       [629.16666667],\n",
+       "       [801.45833333],\n",
+       "       [540.75      ]])"
+      ]
      },
-     "execution_count": 3,
+     "execution_count": 31,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
+   "execution_count": 31
+  },
+  {
+   "cell_type": "code",
    "source": [
     "np.std(X, axis=-1)[0:5]"
    ],
    "metadata": {
-    "collapsed": false
-   }
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:32:56.916707Z",
+     "start_time": "2024-11-12T16:32:56.909707Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[428.95224215],\n",
+       "       [483.35481095],\n",
+       "       [514.90052977],\n",
+       "       [629.00847763],\n",
+       "       [389.10059218]])"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 32
   },
   {
    "cell_type": "markdown",
@@ -90,17 +111,6 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "array([[ 0.],\n       [-0.],\n       [ 0.],\n       [-0.],\n       [-0.]])"
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
     "from aeon.transformations.collection import Normalizer\n",
     "\n",
@@ -109,28 +119,59 @@
     "np.round(np.mean(X2, axis=-1)[0:5], 6)"
    ],
    "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:32:58.247416Z",
+     "start_time": "2024-11-12T16:32:58.240777Z"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "array([[1.],\n       [1.],\n       [1.],\n       [1.],\n       [1.]])"
+      "text/plain": [
+       "array([[ 0.],\n",
+       "       [-0.],\n",
+       "       [ 0.],\n",
+       "       [-0.],\n",
+       "       [-0.]])"
+      ]
      },
-     "execution_count": 5,
+     "execution_count": 33,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
+   "execution_count": 33
+  },
+  {
+   "cell_type": "code",
    "source": [
     "np.round(np.std(X2, axis=-1)[0:5], 6)"
    ],
    "metadata": {
-    "collapsed": false
-   }
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:32:59.026173Z",
+     "start_time": "2024-11-12T16:32:59.006225Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1.],\n",
+       "       [1.],\n",
+       "       [1.],\n",
+       "       [1.],\n",
+       "       [1.]])"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 34
   },
   {
    "cell_type": "markdown",
@@ -143,17 +184,6 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "array([[ 0.],\n       [-0.],\n       [ 0.],\n       [-0.],\n       [ 0.]])"
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
     "from aeon.transformations.collection import Centerer\n",
     "\n",
@@ -162,8 +192,29 @@
     "np.round(np.mean(X3, axis=-1)[0:5], 6)"
    ],
    "metadata": {
-    "collapsed": false
-   }
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:33:00.283438Z",
+     "start_time": "2024-11-12T16:33:00.263489Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 0.],\n",
+       "       [-0.],\n",
+       "       [ 0.],\n",
+       "       [-0.],\n",
+       "       [ 0.]])"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 35
   },
   {
    "cell_type": "markdown",
@@ -176,17 +227,6 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "array([[0.],\n       [0.],\n       [0.],\n       [0.],\n       [0.]])"
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
     "from aeon.transformations.collection import MinMaxScaler\n",
     "\n",
@@ -195,28 +235,59 @@
     "np.round(np.min(X4, axis=-1)[0:5], 6)"
    ],
    "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:33:01.726406Z",
+     "start_time": "2024-11-12T16:33:01.712241Z"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "array([[1.],\n       [1.],\n       [1.],\n       [1.],\n       [1.]])"
+      "text/plain": [
+       "array([[0.],\n",
+       "       [0.],\n",
+       "       [0.],\n",
+       "       [0.],\n",
+       "       [0.]])"
+      ]
      },
-     "execution_count": 8,
+     "execution_count": 36,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
+   "execution_count": 36
+  },
+  {
+   "cell_type": "code",
    "source": [
     "np.round(np.max(X4, axis=-1)[0:5], 6)"
    ],
    "metadata": {
-    "collapsed": false
-   }
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:33:02.556739Z",
+     "start_time": "2024-11-12T16:33:02.536132Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1.],\n",
+       "       [1.],\n",
+       "       [1.],\n",
+       "       [1.],\n",
+       "       [1.]])"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 37
   },
   {
    "cell_type": "markdown",
@@ -232,7 +303,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Resizing time series\n",
+    "## Resizing time series\n",
     "\n",
     "Suppose we have a collections of time series with different lengths, i.e. different\n",
     "number of time points. Currently, most of aeon's collection estimators\n",
@@ -243,7 +314,6 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2020-12-19T14:31:58.456171Z",
@@ -253,13 +323,19 @@
     },
     "pycharm": {
      "is_executing": true
+    },
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:33:06.040725Z",
+     "start_time": "2024-11-12T16:33:06.031583Z"
     }
    },
-   "outputs": [],
    "source": [
     "from aeon.classification.convolution_based import RocketClassifier\n",
-    "from aeon.datasets import load_basic_motions, load_plaid"
-   ]
+    "from aeon.datasets import load_basic_motions, load_japanese_vowels, load_plaid\n",
+    "from aeon.utils.validation import has_missing, is_equal_length, is_univariate"
+   ],
+   "outputs": [],
+   "execution_count": 38
   },
   {
    "cell_type": "markdown",
@@ -277,7 +353,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Unequal or equal length collections time series\n",
+    "### Unequal or equal length collections time series\n",
     "\n",
     "If a collection contains all equal length series, it will store the data in a 3D\n",
     "numpy of shape `(n_cases, n_channels, n_timepoints)`. If it is unequal length, it is\n",
@@ -286,7 +362,6 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2020-12-19T14:31:59.194445Z",
@@ -296,66 +371,105 @@
     },
     "pycharm": {
      "is_executing": true
+    },
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:33:11.372396Z",
+     "start_time": "2024-11-12T16:33:11.334983Z"
     }
    },
-   "outputs": [],
    "source": [
     "# Equal length multivariate data\n",
     "bm_X, bm_y = load_basic_motions()\n",
-    "print(type(bm_X), \"\\n\", bm_X.shape)"
-   ]
+    "X = bm_X\n",
+    "print(f\"{type(X)}, {X.shape}\")\n",
+    "print(\n",
+    "    f\"univariate = {is_univariate(X)}, has missing ={has_missing(X)}, equal \"\n",
+    "    f\"length = {is_equal_length(X)}\"\n",
+    ")"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'numpy.ndarray'>, (80, 6, 100)\n",
+      "univariate = False, has missing =False, equal length = True\n"
+     ]
+    }
+   ],
+   "execution_count": 39
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
    "source": [
     "# Unequal length univariate data\n",
     "plaid_X, plaid_y = load_plaid()\n",
-    "print(type(plaid_X), \"\\n\", plaid_X[0].shape, \"\\n\", plaid_X[10].shape)"
+    "X = plaid_X\n",
+    "print(type(plaid_X), \"\\n\", plaid_X[0].shape, \"\\n\", plaid_X[10].shape)\n",
+    "print(\n",
+    "    f\"univariate = {is_univariate(X)}, has missing ={has_missing(X)}, equal \"\n",
+    "    f\"length = {is_equal_length(X)}\"\n",
+    ")"
    ],
    "metadata": {
     "collapsed": false,
     "pycharm": {
      "is_executing": true
+    },
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:33:15.995745Z",
+     "start_time": "2024-11-12T16:33:15.838016Z"
     }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If time series are unequal length, collection estimators will raise an error if they\n",
-    "do not have the capability to handle this characteristic.\n"
-   ]
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'list'> \n",
+      " (1, 500) \n",
+      " (1, 300)\n",
+      "univariate = True, has missing =False, equal length = False\n"
+     ]
+    }
+   ],
+   "execution_count": 40
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2020-12-19T14:32:01.026183Z",
-     "iopub.status.busy": "2020-12-19T14:32:01.025650Z",
-     "iopub.status.idle": "2020-12-19T14:32:01.239714Z",
-     "shell.execute_reply": "2020-12-19T14:32:01.240542Z"
-    },
-    "pycharm": {
-     "is_executing": true
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:33:49.713555Z",
+     "start_time": "2024-11-12T16:33:49.675458Z"
     }
    },
-   "outputs": [],
+   "cell_type": "code",
    "source": [
-    "rc = RocketClassifier()\n",
-    "try:\n",
-    "    rc.fit(plaid_X, plaid_y)\n",
-    "except ValueError as e:\n",
-    "    print(f\"ValueError: {e}\")"
-   ]
+    "\n",
+    "vowels_X, vowels_y = load_japanese_vowels(split=\"train\")\n",
+    "X = vowels_X\n",
+    "print(\n",
+    "    f\"univariate = {is_univariate(X)}, has missing ={has_missing(X)}, equal \"\n",
+    "    f\"length = {is_equal_length(X)}\"\n",
+    ")"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "univariate = False, has missing =False, equal length = False\n"
+     ]
+    }
+   ],
+   "execution_count": 42
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": "\n"
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
    "source": [
     "series_lengths = [array.shape[1] for array in plaid_X]\n",
     "\n",
@@ -368,14 +482,142 @@
     "collapsed": false,
     "pycharm": {
      "is_executing": true
+    },
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:33:54.002965Z",
+     "start_time": "2024-11-12T16:33:53.996513Z"
     }
-   }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Min length =  100  max length =  1344\n"
+     ]
+    }
+   ],
+   "execution_count": 43
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "There are two basic strategies for unequal length problems\n",
+    "1. Use an estimator that can internally handle missing values\n",
+    "2. Transform the data to be equal length by, for example, truncating or padding series\n",
+    "\n",
+    "Estimators with the tag `\"capability:unequal_length\": True` have the capability to\n",
+    "handle unequal length series. For classification, regression and\n",
+    "clusterign, the\n",
+    "current list is"
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:34:00.658671Z",
+     "start_time": "2024-11-12T16:34:00.546786Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "from aeon.utils.discovery import all_estimators\n",
+    "\n",
+    "all_estimators(\n",
+    "    type_filter=[\"classifier\", \"regressor\", \"clusterer\"],\n",
+    "    tag_filter={\"capability:unequal_length\": True},\n",
+    ")"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[('Catch22Classifier',\n",
+       "  aeon.classification.feature_based._catch22.Catch22Classifier),\n",
+       " ('Catch22Clusterer', aeon.clustering.feature_based._catch22.Catch22Clusterer),\n",
+       " ('Catch22Regressor', aeon.regression.feature_based._catch22.Catch22Regressor),\n",
+       " ('DummyClassifier', aeon.classification.dummy.DummyClassifier),\n",
+       " ('DummyRegressor', aeon.regression._dummy.DummyRegressor),\n",
+       " ('ElasticEnsemble',\n",
+       "  aeon.classification.distance_based._elastic_ensemble.ElasticEnsemble),\n",
+       " ('KNeighborsTimeSeriesClassifier',\n",
+       "  aeon.classification.distance_based._time_series_neighbors.KNeighborsTimeSeriesClassifier),\n",
+       " ('KNeighborsTimeSeriesRegressor',\n",
+       "  aeon.regression.distance_based._time_series_neighbors.KNeighborsTimeSeriesRegressor),\n",
+       " ('RDSTClassifier', aeon.classification.shapelet_based._rdst.RDSTClassifier),\n",
+       " ('RDSTRegressor', aeon.regression.shapelet_based._rdst.RDSTRegressor)]"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 44
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "You can pass these estimators unequal length series and they will work as expected.\n"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:34:03.070381Z",
+     "start_time": "2024-11-12T16:34:03.042207Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier\n",
+    "\n",
+    "knn = KNeighborsTimeSeriesClassifier()\n",
+    "model = knn.fit(plaid_X, plaid_y)"
+   ],
+   "outputs": [],
+   "execution_count": 45
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "If time series are unequal length, collection estimators will raise an error if they\n",
+    "do not have the capability to handle this characteristic. If you want to use them, \n",
+    "you will need to preprocess the data to be equal length. "
+   ]
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:34:04.886239Z",
+     "start_time": "2024-11-12T16:34:04.856319Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "rc = RocketClassifier()\n",
+    "try:\n",
+    "    rc.fit(plaid_X, plaid_y)\n",
+    "except ValueError as e:\n",
+    "    print(f\"ValueError: {e}\")"
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ValueError: Data seen by instance of RocketClassifier has unequal length series, but RocketClassifier cannot handle unequal length series. \n"
+     ]
+    }
+   ],
+   "execution_count": 46
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Padding, truncating or resizing.\n",
+    "### Padding, truncating or resizing.\n",
     "\n",
     "We can pad, truncate or resize. By default, pad adds zeros to make all series the\n",
     "length of the longest, truncate removes all values beyond the length of the shortest\n",
@@ -384,7 +626,6 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
    "metadata": {
     "execution": {
      "iopub.execute_input": "2020-12-19T14:32:01.245270Z",
@@ -394,9 +635,12 @@
     },
     "pycharm": {
      "is_executing": true
+    },
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:34:07.677683Z",
+     "start_time": "2024-11-12T16:34:07.554662Z"
     }
    },
-   "outputs": [],
    "source": [
     "from aeon.transformations.collection import Padder, Resizer, Truncator\n",
     "\n",
@@ -407,7 +651,58 @@
     "X3 = truncate.fit_transform(plaid_X)\n",
     "X4 = resize.fit_transform(plaid_X)\n",
     "print(X2.shape, \"\\n\", X3.shape, \"\\n\", X4.shape)"
-   ]
+   ],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1074, 1, 1344) \n",
+      " (1074, 1, 100) \n",
+      " (1074, 1, 600)\n"
+     ]
+    }
+   ],
+   "execution_count": 47
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-11-12T16:34:15.198556Z",
+     "start_time": "2024-11-12T16:34:14.994028Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.title(\"Before and after padding: PLAID first case (shifted up for unpadded)\")\n",
+    "plt.plot(plaid_X[0][0] + 10)\n",
+    "plt.plot(X2[0][0])"
+   ],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x20e17c9d6d0>]"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "execution_count": 48
   },
   {
    "cell_type": "markdown",
@@ -442,6 +737,56 @@
      "is_executing": true
     }
    }
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Missing Values\n",
+    "\n",
+    "Missing values are indicated by `NaN` in numpy array. You can test whether any `aeon`\n",
+    " data structure contains missing values using the utility function"
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "X = np.random.random(size=(10, 2, 200))\n",
+    "has_missing(X)"
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "X[5][0][55] = np.NAN\n",
+    "has_missing(X)"
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "There are a range of strategies for handling missing values. These include:\n",
+    "\n",
+    "1. Use an estimator that internally handles missing values. It is fairly easy for\n",
+    "some algorithms (such as decision trees) to internally deal with missing values,\n",
+    "usually be using it as a distinct series value after discretisation.\n",
+    "2. Removing series with missing: this is often desirable if the train set size is\n",
+    "large, the number of series with missing is small and the proportion of missing\n",
+    "values for these series is high.\n",
+    "3. Interpolating: estimating the missing values from the other series values. This is\n",
+    " often desirable if the train set size is small and the proportion of missing values\n",
+    " is low.\n",
+    "\n",
+    "Removing series with missing and interpolation is currently best done by you: there\n",
+    "are no transformers to deal with at at the moment. It is on the wish list.\n"
+   ]
   }
  ],
  "metadata": {
diff --git a/examples/transformations/rocket.ipynb b/examples/transformations/rocket.ipynb
index eec06438ca..3e1ed7db1d 100644
--- a/examples/transformations/rocket.ipynb
+++ b/examples/transformations/rocket.ipynb
@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Demo of ROCKET transform\n",
+    "# The ROCKET transform\n",
     "\n",
     "## Overview\n",
     "\n",
diff --git a/examples/transformations/transformations.ipynb b/examples/transformations/transformations.ipynb
index db78fec3a8..7d88735104 100644
--- a/examples/transformations/transformations.ipynb
+++ b/examples/transformations/transformations.ipynb
@@ -221,6 +221,7 @@
     "A list of all the available transformers can be found in the [API](https://www.aeon-toolkit.org/en/latest/api_reference/transformations.html). We currently have\n",
     "specific notebooks for the following transformers:\n",
     "\n",
+    "- [preprocessing](preprocessing.ipynb)\n",
     "- [catch22](catch22.ipynb)\n",
     "- [channel selection](channel_selection.ipynb)\n",
     "- [mini rocket](mini_rocket.ipynb)\n",
diff --git a/examples/utils/preprocessing.ipynb b/examples/utils/preprocessing.ipynb
deleted file mode 100644
index 68a434a320..0000000000
--- a/examples/utils/preprocessing.ipynb
+++ /dev/null
@@ -1,353 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "source": [
-    "# Preprocessing data prior to machine learning\n",
-    "\n",
-    "For machine learning, we assume that data is in shape `(n_cases, n_channels,\n",
-    "n_timepoints)` for equal length series or a python list with `len` of `[n_cases]` if\n",
-    "the series are unequal length. However, in reality, there are often many steps to get\n",
-    " your data into this format. We introduce some common uses cases that may be handled\n",
-    " with preprocessing, and give some suggestions about how to handle them.\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "\n",
-    "from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier\n",
-    "from aeon.datasets import load_japanese_vowels, load_plaid\n",
-    "from aeon.utils.discovery import all_estimators\n",
-    "from aeon.utils.validation import has_missing, is_equal_length, is_univariate"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "is_executing": true
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "## Missing values\n",
-    "\n",
-    "Missing values are indicated by `NaN` in numpy array. You can test whether any `aeon`\n",
-    " data structure contains missing values using the utility function\n",
-    "\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "False"
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "X = np.random.random(size=(10, 2, 200))\n",
-    "has_missing(X)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "True"
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "X[5][0][55] = np.NAN\n",
-    "has_missing(X)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "There are a range of strategies for handling missing values. These include:\n",
-    "\n",
-    "1. Use an estimator that internally handles missing values. It is fairly easy for\n",
-    "some algorithms (such as decision trees) to internally deal with missing values,\n",
-    "usually be using it as a distinct series value after discretisation.\n",
-    "2. Removing series with missing: this is often desirable if the train set size is\n",
-    "large, the number of series with missing is small and the proportion of missing\n",
-    "values for these series is high.\n",
-    "3. Interpolating: estimating the missing values from the other series values. This is\n",
-    " often desirable if the train set size is small and the proportion of missing values\n",
-    " is low.\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "all_estimators(\n",
-    "    type_filter=[\"classifier\", \"regressor\", \"clusterer\"],\n",
-    "    tag_filter={\"capability:missing_values\": True},\n",
-    ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "is_executing": true
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "Removing series with missing and interpolation is currently best done by you: there\n",
-    "are no transformers to deal with at at the moment. It is on the wish list."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "## Unequal length series\n",
-    "\n",
-    "Learning from unequal length series is very common. aeon provided two baked in\n",
-    "unequal length collections: the univariate PLAID dataset, and the multivariate\n",
-    "JapaneseVowels dataset:\n"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "plaid_X, plaid_y = load_plaid(split=\"train\")\n",
-    "print(\n",
-    "    f\"PLAID is univariate = {is_univariate(plaid_X)} has missing =\"\n",
-    "    f\"{has_missing(plaid_X)} is equal length = {is_equal_length(plaid_X)}\"\n",
-    ")\n",
-    "vowels_X, vowels_y = load_japanese_vowels(split=\"train\")\n",
-    "print(\n",
-    "    f\"JapaneseVowels is univariate = {is_univariate(vowels_X)} \"\n",
-    "    f\"has missing = {has_missing(vowels_X)} is \"\n",
-    "    f\"equal length = {is_equal_length(vowels_X)}\"\n",
-    ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "is_executing": true
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "### Handling unequal length\n",
-    "\n",
-    "There are two basic strategies for unequal length problems\n",
-    "1. Use an estimator that can internally handle missing values\n",
-    "2. Transform the data to be equal length by, for example, truncating or padding series\n",
-    "\n",
-    "At the time of writing, functionality for handling unequal length series is limited.\n",
-    "Estimators with the tag `\"capability:unequal_length\": True` have the capability to\n",
-    "handle unequal length series. For classification, regression and\n",
-    "clusterign, the\n",
-    "current list is"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "                             name  \\\n0               Catch22Classifier   \n1                Catch22Regressor   \n2                 DummyClassifier   \n3                 ElasticEnsemble   \n4  KNeighborsTimeSeriesClassifier   \n5   KNeighborsTimeSeriesRegressor   \n\n                                           estimator  \n0  <class 'aeon.classification.feature_based._cat...  \n1  <class 'aeon.regression.feature_based._catch22...  \n2  <class 'aeon.classification._dummy.DummyClassi...  \n3  <class 'aeon.classification.distance_based._el...  \n4  <class 'aeon.classification.distance_based._ti...  \n5  <class 'aeon.regression.distance_based._time_s...  ",
-      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>name</th>\n      <th>estimator</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Catch22Classifier</td>\n      <td>&lt;class 'aeon.classification.feature_based._cat...</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Catch22Regressor</td>\n      <td>&lt;class 'aeon.regression.feature_based._catch22...</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>DummyClassifier</td>\n      <td>&lt;class 'aeon.classification._dummy.DummyClassi...</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>ElasticEnsemble</td>\n      <td>&lt;class 'aeon.classification.distance_based._el...</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>KNeighborsTimeSeriesClassifier</td>\n      <td>&lt;class 'aeon.classification.distance_based._ti...</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>KNeighborsTimeSeriesRegressor</td>\n      <td>&lt;class 'aeon.regression.distance_based._time_s...</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all_estimators(\n",
-    "    type_filter=[\"classifier\", \"regressor\", \"clusterer\"],\n",
-    "    tag_filter={\"capability:unequal_length\": True},\n",
-    ")"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "You can pass these estimators unequal length series and they will work as expected."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "KNeighborsTimeSeriesClassifier()",
-      "text/html": "<style>#sk-container-id-2 {color: black;background-color: white;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>KNeighborsTimeSeriesClassifier()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">KNeighborsTimeSeriesClassifier</label><div class=\"sk-toggleable__content\"><pre>KNeighborsTimeSeriesClassifier()</pre></div></div></div></div></div>"
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "knn = KNeighborsTimeSeriesClassifier()\n",
-    "knn.fit(plaid_X, plaid_y)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "The alternative is to transform your data so that it becomes equal length, and can\n",
-    "then be used with any time series estimator. Two simple examples are tpo pad the\n",
-    "series to the longest series length, or to truncate to the shortest series length. By\n",
-    " default, padding pads with zeros. Be careful if your data is not normalised, because\n",
-    "  this could then effect the classifier."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "(537, 1, 1344)"
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from aeon.transformations.collection import Padder\n",
-    "\n",
-    "pt = Padder()\n",
-    "plaid_equal = pt.fit_transform(plaid_X)\n",
-    "plaid_equal.shape"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "[<matplotlib.lines.Line2D at 0x235ecdc37f0>]"
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 640x480 with 1 Axes>",
-      "image/png": "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"
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "plt.title(\"Before and after padding: PLAID first case (shifted up for unpadded)\")\n",
-    "plt.plot(plaid_X[0][0] + 10)\n",
-    "plt.plot(plaid_equal[0][0])"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "## Coming soon\n",
-    "\n",
-    "Unequally spaced samples\n",
-    "Streaming series: windowing and segmenting\n",
-    "Channel selection for multivariate series"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 2
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}