From 4ccc2cf6bf87395ffd7f64b39ed3da8a71e89c98 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 10:32:55 -0400
Subject: [PATCH 01/24] First steps towards documenting VPTree.

---
 doc/sidebar.html                           |   5 +
 doc/user/core/trees/binary_space_tree.md   | 345 ++++++++++++++++++++-
 src/mlpack/core/tree/hollow_ball_bound.hpp |  10 -
 3 files changed, 348 insertions(+), 12 deletions(-)

diff --git a/doc/sidebar.html b/doc/sidebar.html
index e49272ed4f..d02d5a3047 100644
--- a/doc/sidebar.html
+++ b/doc/sidebar.html
@@ -86,6 +86,11 @@ when the sidebar is built for each page.
                 <code>MeanSplitKDTree</code>
               </a>
             </li>
+            <li>
+              <a href="LINKROOTuser/core/trees/vptree.html">
+                <code>VPTree</code>
+              </a>
+            </li>
             <li>
               <a href="LINKROOTuser/core/trees/binary_space_tree.html">
                 <code>BinarySpaceTree</code>
diff --git a/doc/user/core/trees/binary_space_tree.md b/doc/user/core/trees/binary_space_tree.md
index de906335aa..1dcb401d2d 100644
--- a/doc/user/core/trees/binary_space_tree.md
+++ b/doc/user/core/trees/binary_space_tree.md
@@ -421,6 +421,8 @@ write a custom `BoundType` for use with `BinarySpaceTree`:
 
  * [`HRectBound`](#hrectbound): hyperrectangle bound, encloses the descendant
    points in the smallest possible hyperrectangle
+ * [`HollowBallBound`](#hollowballbound): hollow ball bound, equivalent to a
+   ball bound with a ball subtracted from it.
  * [Custom `BoundType`s](#custom-boundtypes): implement a fully custom
    `BoundType`
 
@@ -567,7 +569,7 @@ operations with data points or other bounds.
 
 Once an `HRectBound` has been successfully created and set to the desired
 bounding hyperrectangle, there are a number of functions that can bound the
-distance between a `HRectBound` and other objects.
+distance between an `HRectBound` and other objects.
 
  * `b.Contains(point)`
  * `b.Contains(bound)`
@@ -764,13 +766,352 @@ std::cout << "Distance between Manhattan distance HRectBound and "
 // point.
 arma::fmat floatData(3, 25, arma::fill::randu);
 mlpack::HRectBound<mlpack::ChebyshevDistance, float> cb;
-cb |= floatData; // This will set the bound to [2.0, 3.0] in every dimension.
+cb |= floatData;
 // Note the use of arma::fvec to represent a point, since ElemType is float.
 const mlpack::RangeType<float> r3 = cb.RangeDistance(arma::fvec("1.5 1.5 4.0"));
 std::cout << "Distance between Chebyshev distance HRectBound and "
     << "[1.5, 1.5, 4.0]: [" << r3.Lo() << ", " << r3.Hi() << "]." << std::endl;
 ```
 
+### `HollowBallBound`
+
+The `HollowBallBound` class represents a bounding shape that is an
+arbitrary-dimensional ball bound with another smaller ball subtracted from its
+inside.  A `HollowBallBound` consists of a center point, an outer radius, and a
+secondary center point and inner radius.  An example `HollowBallBound` is shown
+below in two dimensions; shaded area represents area held within the bound.
+
+<center>
+<img src="../../../img/hollowballbound.png" width="50%" alt="hollow ball bound">
+</center>
+
+`HollowBallBound` is used directly by the [`VPTree`](vptree.md) class.
+
+#### Constructors
+
+`HollowBallBound` allows configurable behavior via its two template parameters:
+
+```
+HollowBallBound<DistanceType, ElemType>
+```
+
+Different constructor forms can be used to specify different template parameters
+(and thus different bound behavior).
+
+ * `b = HollowBallBound(dimensionality)`
+   - Construct a `HollowBallBound` with the given `dimensionality`.
+   - The bound will be empty with invalid centers and radii (e.g., `b` will not
+     contain any points at all).
+   - The bound will use the [Euclidean distance](../distances.md#lmetric) for
+     distance computation, and will expect data to have elements with type
+     `double`.
+
+ * `b = HollowBallBound<DistanceType, ElemType>(dimensionality)`
+   - Construct a `HollowBallBound` with the given `dimensionality` that will use
+     the given `DistanceType` class to compute distances, and expect data to
+     have elements with type `ElemType`.
+   - `ElemType` should generally be `double` or `float`.
+
+<!-- TODO: update links here after merge of BallBound PR -->
+
+***Note***: these constructors provide an empty bound; be sure to
+[grow](#growing-and-shrinking-the-bound-1) the bound or
+[directly modify the bound](#accessing-and-modifying-properties-of-the-bound-1)
+before using it!
+
+---
+
+ * `b = HollowBallBound(innerRadius, outerRadius, center)`
+   - Construct a `HollowBallBound` with the given `innerRadius` for the inner
+     ball, `outerRadius` for the outer ball, and `center`.
+   - Both the inner and outer ball are centered at `center`.
+   - `innerRadius` and `outerRadius` should have type `double`.
+   - `center` should have type `arma::vec`.
+   - The bound will use the [Euclidean distance](../distances.md#lmetric) for
+     distance computation, and will expect data to have elements with type
+     `double`.
+
+ * `b = HollowBallBound<DistanceType, ElemType>(innerRadius, outerRadius, center)`
+   - Construct a `HollowBallBound` with the given `innerRadius` for the inner
+     ball, `outerRadius` for the outer ball, and `center`.
+   - Both the inner and outer ball are centered at `center`.
+   - `innerRadius` and `outerRadius` should have type `ElemType`.
+   - `center` should be a vector with element type `ElemType` (e.g.
+     `arma::Col<ElemType>`).
+   - The bound will use the given `DistanceType` class to compute distances, and
+     expect data to have elements with type `ElemType`.
+
+#### Accessing and modifying properties of the bound
+
+The individual bounds associated with each dimension of a `HollowBallBound` can
+be accessed and modified.
+
+ * `b.Dim()` will return a `size_t` indicating the dimensionality of the bound.
+
+ * `b.Center()` returns an `arma::vec&` containing the center of the outer ball.
+   Its elements can be directly modified.
+
+ * `b.HollowCenter()` returns an `arma::vec&` containing the center of the inner
+   ball.  Its elements can be directly modified.
+
+ * `b.OuterRadius()` will return a `double` that is the radius of the outer
+   ball.
+   - `b.OuterRadius() = r` will set the radius of the outer ball to `r`.
+
+ * `b.InnerRadius()` will return a `double` that is the radius of the inner
+   ball.
+   - `b.InnerRadius() = r` will set the radius of the inner ball to `r`.
+
+ * `b[dim]` will return a [`Range`](../math.md#range) object representing the
+   extents of the bound in dimension `dim`.
+   - The range is defined as
+     `[b.Center()[dim] - b.OuterRadius(), b.Center()[dim] + b.OuterRadius()]`.
+   - ***Note:*** this returns the maximum extents of the bound and does not
+     consider the inner (hollow) ball.
+
+ * `b.Diameter()` returns the diameter of the ball. This is always equal to
+   `2 * b.OuterRadius()`.
+
+ * `b.MinWidth()` returns the minimum width of the bound in any dimension as a
+   `double`. This is always equal to `b.Diameter()`.
+
+ * `b.Distance()` returns either a
+   [`EuclideanDistance`](../distances.md#lmetric) distance metric object, or a
+   `DistanceType` if a custom `DistanceType` has been specified in the
+   constructor.
+
+ * `b.Center(center)` will store the center of the `HollowBallBound` in the
+   vector `center`. `center` should be of type `arma::vec`.
+
+ * `b.MinWidth()` returns the minimum width of the bound in any dimension as a
+   `double`.  This value is cached and no computation is performed when calling
+   `b.MinWidth()`.  If the bound is empty, `0` is returned.
+
+ * `b.Distance()` returns either a
+   [`EuclideanDistance`](../distances.md#lmetric) distance metric object, or a
+   `DistanceType` if a custom `DistanceType` has been specified in the
+   constructor.
+
+ * `b.Center(center)` will compute the center of the `HRectBound` (e.g. the
+   vector with elements equal to the midpoint of `b` in each dimension) and
+   store it in the vector `center`.  `center` should be of type `arma::vec`.
+
+ * `b.Volume()` computes the volume of the hyperrectangle specified by `b`.  The
+   volume is returned as a `double`.
+
+ * `b.Diameter()` computes the longest diagonal of the hyperrectangle specified
+   by `b`.
+
+ * A `HollowBallBound` can be serialized with
+   [`data::Save()` and `data::Load()`](../../load_save.md#mlpack-objects).
+
+***Note:*** if a custom `ElemType` was specified in the constructor, then:
+
+ * `b[dim]` will return a `RangeType<ElemType>`;
+ * `b.OuterRadius()`, `b.InnerRadius()`, `b.MinWidth()`, and `b.Diameter()` will
+   return `ElemType`;
+ * `b.Center()` and `b.HollowCenter()` will return `arma::Col<ElemType>&`; and
+ * `b.Center(center)` expects `center` to be of type `arma::Col<ElemType>`.
+
+#### Growing the bound
+
+The `HollowBallBound` uses the logical `|=` to grow the bound to include points.
+
+ * `b |= data` expands `b` so the outer ball includes all of the data points in
+   `data`, shrinking the inner ball as necessary.  `data` should be a
+   [column-major `arma::mat`](../../matrices.md#representing-data-in-mlpack).
+   The expansion operation is minimal, so `b` is not expanded any more than
+   necessary.
+   - The bound is grown using [Jack Ritter's bounding sphere
+     algorithm](https://en.wikipedia.org/wiki/Bounding_sphere#Ritter's_bounding_sphere),
+     which may move the center of the bound as it iteratively adds points to the
+     bound.  (The hollow center is not moved.)
+   - If the bound is empty, the centers are initialized to the first point of
+     `data`.
+   - If the bound is not empty, then `data` is expected to have dimensionality
+     that matches `b.Dim()`.
+
+***Notes:***
+
+ - The growth operation does not grow the inner (hollow) ball.  Properties
+   related to the inner ball should be set manually with `b.HollowCenter()` and
+   `b.InnerRadius()`.
+
+ - If a custom `ElemType` was specified, then any `data` argument should be a
+   matrix with that `ElemType` (e.g. `arma::Mat<ElemType>`).
+
+#### Bounding distances to other objects
+
+Once a `HollowBallBound` has been successfully created and set to the desired
+bounding balls, there are a number of functions that can bound the
+distance between a `HollowBallBound` and other objects.
+
+ * `b.Contains(point)`
+ * `b.Contains(bound)`
+   - Return a `bool` indicating whether or not `b` contains the given `point`
+     (an `arma::vec`) or another `bound` (an `HRectBound`).
+   - When passing another `bound`, `true` will be returned if `bound` even
+     partially overlaps with `b`.
+
+ * `b.MinDistance(point)`
+ * `b.MinDistance(bound)`
+   - Return a `double` whose value is the minimum possible distance between `b`
+     and either a `point` (an `arma::vec`) or another `bound` (a
+     `HollowBallBound`).
+   - The minimum distance between `b` and another point or bound is the length
+     of the shortest possible line that can connect the other point or bound to
+     `b`.
+   - If `point` or `bound` are contained in `b`, then the returned distance is
+     0.
+
+ * `b.MaxDistance(point)`
+ * `b.MaxDistance(bound)`
+   - Return a `double` whose value is the maximum possible distance between `b`
+     and either a `point` (an `arma::vec`) or another `bound` (a
+     `HollowBallBound`).
+   - The maximum distance between `b` and a given `point` is the furthest
+     possible distance between `point` and any possible point falling within the
+     bounding hyperrectangle of `b`.
+   - The maximum distance between `b` and another `bound` is the furthest
+     possible distance between any possible point falling within the bounding
+     hyperrectangle of `b`, and any possible point falling within the bounding
+     hyperrectangle of `bound`.
+   - Note that this definition means that even if `b.Contains(point)` or
+     `b.Contains(bound)` is `true`, the maximum distance may be greater than
+     `0`.
+
+ * `b.RangeDistance(point)`
+ * `b.RangeDistance(bound)`
+   - Compute the minimum and maximum distance between `b` and `point` or
+     `bound`, returning the result as a [`Range`](../math.md#range) object.
+   - This is more efficient than calling `b.MinDistance()` and
+     `b.MaxDistance()`.
+
+***Note:*** if a custom `DistanceType` and `ElemType` were specified in the
+constructor, then all distances will be computed with respect to the specified
+`DistanceType` and all return values will either be `ElemType` or
+[`RangeType<ElemType>`](../math.md#range) (except for `Contains()`, which will
+still return a `bool`).
+
+#### Example usage
+
+```c++
+// Create a hollow ball bound in 3 dimensions whose outer ball is the unit ball
+// and whose inner ball is the ball with radius 0.5 centered at the origin.
+// The bounding range for all three dimensions is [0.0, 1.0].
+mlpack::HollowBallBound b(0.5, 1.0, arma::vec(3));
+
+std::cout << "Hollow unit ball bound created manually:" << std::endl;
+std::cout << " - Center: " << b.Center().t();
+std::cout << " - Outer radius: " << b.OuterRadius() << "." << std::endl;
+std::cout << " - Hollow center: " << b.HollowCenter.();
+std::cout << " - Inner radius: " << b.InnerRadius() << "." << std::endl;
+for (size_t i = 0; i < 3; ++i)
+{
+  std::cout << " - Dimension " << i << " extents: [" << b[i].Lo() << ", "
+      << b[i].Hi() << "]." << std::endl;
+}
+std::cout << std::endl;
+
+// Create a small dataset of 5 points.
+arma::mat dataset(3, 5);
+dataset.col(0) = arma::vec("2.0 2.0 2.0");
+dataset.col(1) = arma::vec("2.5 2.5 2.5");
+dataset.col(2) = arma::vec("3.0 2.0 3.0");
+dataset.col(3) = arma::vec("2.0 3.0 2.0");
+dataset.col(4) = arma::vec("3.0 3.0 3.0");
+
+// If we simply build a HollowBallBound to enclose those points, the hollow part
+// of the ball is unmodified and remains empty.
+mlpack::HollowBallBound b2(3);
+b2 |= dataset;
+std::cout << "Hollow ball bound on points with only `operator|=()`:"
+    << std::endl;
+std::cout << " - Center: " << b2.Center().t();
+std::cout << " - Outer radius: " << b2.OuterRadius() << "." << std::endl;
+std::cout << " - Hollow center: " << b2.HollowCenter().t();
+std::cout << " - Inner radius: " << b2.InnerRadius() << "." << std::endl;
+std::cout << std::endl;
+
+// On the other hand, if we initialize a HollowBallBound to a non-empty bound,
+// then `operator|=()` will shrink the hollow ball as necessary.
+//
+// We initialize this ball bound to a "slice" with radii [2.6, 2.7].
+mlpack::HollowBallBound b3(2.6, 2.7, arma::vec(3));
+b3 |= dataset;
+std::cout << "Hollow ball bound on points with pre-initialization and "
+    << "`operator|=()`:" << std::endl;
+std::cout << " - Center: " << b3.Center().t();
+std::cout << " - Outer radius: " << b3.OuterRadius() << "." << std::endl;
+std::cout << " - Hollow center: " << b3.HollowCenter().t();
+std::cout << " - Inner radius: " << b3.InnerRadius() << "." << std::endl;
+std::cout << std::endl;
+
+// Manually create a hollow ball bound whose hollow center is different than the
+// outer ball's center.
+mlpack::HollowBallBound b4(3);
+b4.OuterRadius() = 3.0;
+b4.InnerRadius() = 1.5;
+b4.Center() = arma::vec(3);
+b4.HollowCenter() = arma::vec("1.0 1.0 1.0");
+
+// Compute the minimum distance between a point inside the hollow unit ball's
+// outer ball.
+const double d1 = b.MinDistance(arma::vec("0.75 0.75 0.75"));
+std::cout << "Minimum distance between hollow unit ball bound and [0.75, 0.75, "
+    << "0.75]: " << d1 << "." << std::endl;
+
+// Compute the minimum distance between a point inside the hollow unit ball's
+// inner ball (so the point is not contained in the bound---it is within the
+// hollow section).
+const double d2 = b.MinDistance(arma::vec("0.25 0.25 0.25"));
+std::cout << "Minimum distance between hollow unit ball bound and [0.25, 0.25, "
+    << "0.25]: " << d2 << "." << std::endl;
+std::cout << std::endl;
+
+// Use Contains().  In this case, the 'else' will be taken.
+if (b.Contains(arma::vec("1.5 1.5 1.5")))
+{
+  std::cout << "Hollow unit ball bound contains [1.5, 1.5, 1.5]." << std::endl;
+}
+else
+{
+  std::cout << "Hollow unit ball bound does not contain [1.5, 1.5, 1.5]."
+      << std::endl;
+}
+std::cout << std::endl;
+
+// Compute the maximum distance between a point inside the unit ball and the
+// unit hollow ball bound.
+const double d2 = b4.MaxDistance(arma::vec("0.1 0.1 0.1"));
+std::cout << "Maximum distance between hollow unit ball bound and [0.1, 0.1, "
+    << "0.1]: " << d2 << "." << std::endl;
+
+// Compute the minimum and maximum distances between the hollow unit ball bound
+// and the bound built on data points.
+const mlpack::Range r = b.RangeDistance(b3);
+std::cout << "Distances between hollow unit ball bound and second hollow "
+    << "dataset bound: [" << r.Lo() << ", " << r.Hi() << "]." << std::endl;
+
+// Create a bound using the Manhattan (L1) distance and compute the minimum and
+// maximum distance to a point.
+mlpack::HollowBallBound<mlpack::ManhattanDistance> mb(2.0, 5.0, arma::vec(3));
+const mlpack::Range r2 = mb.RangeDistance(arma::vec("1.5 1.5 4.0"));
+std::cout << "Distance between Manhattan distance HollowBallBound and "
+    << "[1.5, 1.5, 4.0]: [" << r2.Lo() << ", " << r2.Hi() << "]." << std::endl;
+
+// Create a bound using the Chebyshev (L-inf) distance, using random 32-bit
+// floating point elements, and compute the minimum and maximum distance to a
+// point.
+arma::fmat floatData(3, 25, arma::fill::randu);
+mlpack::HollowBallBound<mlpack::ChebyshevDistance, float> cb;
+cb |= floatData;
+// Note the use of arma::fvec to represent a point, since ElemType is float.
+const mlpack::RangeType<float> r3 = cb.RangeDistance(arma::fvec("1.5 1.5 4.0"));
+std::cout << "Distance between Chebyshev distance HollowBallBound and "
+    << "[1.5, 1.5, 4.0]: [" << r3.Lo() << ", " << r3.Hi() << "]." << std::endl;
+```
+
 ### Custom `BoundType`s
 
 The `BinarySpaceTree` class allows an arbitrary `BoundType` template parameter
diff --git a/src/mlpack/core/tree/hollow_ball_bound.hpp b/src/mlpack/core/tree/hollow_ball_bound.hpp
index 2cad206b82..a41c10798f 100644
--- a/src/mlpack/core/tree/hollow_ball_bound.hpp
+++ b/src/mlpack/core/tree/hollow_ball_bound.hpp
@@ -212,16 +212,6 @@ class HollowBallBound
   template<typename MatType>
   const HollowBallBound& operator|=(const MatType& data);
 
-  /**
-   * Expand the bound to include the given bound.  The centroid will not be
-   * moved.
-   *
-   * @tparam MatType Type of matrix; could be arma::mat, arma::spmat, or a
-   *     vector.
-   * @tparam data Data points to add.
-   */
-  const HollowBallBound& operator|=(const HollowBallBound& other);
-
   /**
    * Returns the diameter of the ballbound.
    */

From d8b7c6654f22f775d52f882506508b5554faba14 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 12:49:16 -0400
Subject: [PATCH 02/24] Add documentation for VantagePointSplit.

---
 doc/user/core/trees/binary_space_tree.md | 46 ++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/doc/user/core/trees/binary_space_tree.md b/doc/user/core/trees/binary_space_tree.md
index 1dcb401d2d..561ba1df26 100644
--- a/doc/user/core/trees/binary_space_tree.md
+++ b/doc/user/core/trees/binary_space_tree.md
@@ -1295,6 +1295,8 @@ to write a fully custom split:
    with maximum width
  * [`MeanSplit`](#meansplit): splits on the mean value of the points in the
    dimension with maximum width
+ * [`VantagePointSplit`](#vantagepointsplit): split by selecting a 'vantage
+   point' and then split points into 'near' and 'far' sets
  * [Custom `SplitType`s](#custom-splittypes): implement a fully custom
    `SplitType` class
 
@@ -1343,6 +1345,50 @@ task*.
 For implementation details, see
 [the source code](/src/mlpack/core/tree/binary_space_tree/mean_split_impl.hpp).
 
+### `VantagePointSplit`
+
+The `VantagePointSplit` class is a splitting strategy that can be used by
+[`BinarySpaceTree`](#binaryspacetree).  It is the default strategy for splitting
+[`VPTree`s](vptree.md), and is detailed in [the paper](...).
+Due to the nature of the split, ***`VantagePointSplit` should always be used
+with the [`HollowBallBound`](#hollowballbound)***.
+
+The splitting strategy for the `VantagePointSplit` class is, given a set of
+points:
+
+ * Select a vantage point from a sample of 100 random candidate points (or use
+   the full set if there are fewer than 100 points):
+   - Compute the distances between each candidate point and 100 additional
+     random samples (or the full set if there are fewer than 100 points).
+   - Select the vantage point as the candidate with maximum average distance to
+     the additional random samples.
+ * Compute a boundary distance `mu` that is the median distance between the
+   vantage point and its random samples.
+ * Points with distance less than `mu` from the vantage point will go to the
+   left child.
+ * Points with distance greater than `mu` from the vantage point will go to the
+   right child.
+
+The `VantagePointSplit` class has three template parameters:
+
+```
+VantagePointSplit<BoundType, MatType, MaxNumSamples = 100>
+```
+
+If a custom number of samples `S` is desired, the easiest way to specify is via
+a template typedef:
+
+```
+template<typename BoundType, typename MatType>
+using MyVantagePointSplit = VantagePointSplit<BoundType, MatType, S>;
+```
+
+Then, `MyVantagePointSplit` can be used directly with `BinarySpaceTree` as a
+`SplitType`.
+
+For implementation details, see
+[the source code](/src/mlpack/core/tree/binary_space_tree/vantage_point_split_impl.hpp).
+
 ### Custom `SplitType`s
 
 Custom split strategies for a binary space tree can be implemented via the

From 548950080613be526cefc7740ab6939afd347654 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 14:50:09 -0400
Subject: [PATCH 03/24] Remove useless assert (it is always true).

---
 .../core/tree/binary_space_tree/vantage_point_split_impl.hpp     | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/mlpack/core/tree/binary_space_tree/vantage_point_split_impl.hpp b/src/mlpack/core/tree/binary_space_tree/vantage_point_split_impl.hpp
index d19dcb1f18..b815b849b4 100644
--- a/src/mlpack/core/tree/binary_space_tree/vantage_point_split_impl.hpp
+++ b/src/mlpack/core/tree/binary_space_tree/vantage_point_split_impl.hpp
@@ -89,7 +89,6 @@ SelectVantagePoint(const DistanceType& distance, const MatType& data,
       mu = arma::median(distances);
     }
   }
-  assert(bestSpread > 0);
 }
 
 } // namespace mlpack

From 3a69b4a615613c46acb167af220e8f6c0ab364e8 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 15:08:01 -0400
Subject: [PATCH 04/24] Make sure that Go installed on MacOS CI builds.

---
 .ci/macos-steps.yaml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.ci/macos-steps.yaml b/.ci/macos-steps.yaml
index d6f177f28a..c29979479a 100644
--- a/.ci/macos-steps.yaml
+++ b/.ci/macos-steps.yaml
@@ -24,6 +24,10 @@ steps:
       brew install --cask julia
     fi
 
+    if [ "$BINDING" = "go" ]; then
+      brew install go
+    fi
+
   displayName: 'Install Build Dependencies'
 
 # Configure mlpack (CMake)

From 00c11fca42d6fad87c0bce1ea016c9eaa7c611f3 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 17:28:37 -0400
Subject: [PATCH 05/24] I think the -t option is not necessary (it sets the
 timeout?).

---
 .ci/macos-steps.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.ci/macos-steps.yaml b/.ci/macos-steps.yaml
index c29979479a..b250b6e690 100644
--- a/.ci/macos-steps.yaml
+++ b/.ci/macos-steps.yaml
@@ -36,7 +36,7 @@ steps:
     if [ "$BINDING" = "go" ]; then
       export GOPATH=$PWD/src/mlpack/bindings/go
       export GO111MODULE=off
-      go get -u -t gonum.org/v1/gonum/...
+      go get -u gonum.org/v1/gonum/...
     fi
     if [ "$BINDING" = "python" ]; then
       cmake $CMAKEARGS -DPYTHON_EXECUTABLE=$(which python) ..

From b64d741147ee90883d09039c0591b1ffe0e41318 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 17:29:21 -0400
Subject: [PATCH 06/24] Add documentation for VPTree.

---
 doc/img/hollowballbound.png   | Bin 0 -> 72856 bytes
 doc/user/core/trees/vptree.md | 634 ++++++++++++++++++++++++++++++++++
 2 files changed, 634 insertions(+)
 create mode 100644 doc/img/hollowballbound.png
 create mode 100644 doc/user/core/trees/vptree.md

diff --git a/doc/img/hollowballbound.png b/doc/img/hollowballbound.png
new file mode 100644
index 0000000000000000000000000000000000000000..3660328b3ab9fdb4ae8ccbd959b03d1c50f64ee1
GIT binary patch
literal 72856
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
J@yI&#{{W@xoxA`5

literal 0
HcmV?d00001

diff --git a/doc/user/core/trees/vptree.md b/doc/user/core/trees/vptree.md
new file mode 100644
index 0000000000..f4f6c5e400
--- /dev/null
+++ b/doc/user/core/trees/vptree.md
@@ -0,0 +1,634 @@
+# `VPTree`
+
+<!-- TODO: link to knn.md once it's done -->
+
+The `VPTree` class represents a `k`-dimensional vantage point tree,
+and is a well-known data structure for efficient distance operations (such as
+nearest neighbor search) in low dimensions---typically less than 100.  The
+vantage point tree is also known as the 'metric tree'.
+
+A vantage point tree is a binary tree where each node selects a 'vantage
+point', and child nodes partition points into those that are nearer to the
+vantage point and those that are further from it.  `VPTree` supports arbitrary
+[distance metrics](../distances.md) that are not
+[`LMetric`](../distances.md#lmetric), making it more flexible than `KDTree`.
+
+mlpack's `VPTree` implementation supports three template parameters for
+configurable behavior, and implements all the functionality required by the
+[TreeType API](../../../developer/trees.md#the-treetype-api), plus some
+additional functionality specific to vantage point trees.
+
+ * [Template parameters](#template-parameters)
+ * [Constructors](#constructors)
+ * [Basic tree properties](#basic-tree-properties)
+ * [Bounding distances with the tree](#bounding-distances-with-the-tree)
+ * [Tree traversals](#tree-traversals)
+ * [Example usage](#example-usage)
+
+## See also
+
+<!-- TODO: add links to all distance-based algorithms and other trees? -->
+
+ * [Vantage point tree on Wikipedia](https://en.wikipedia.org/wiki/Vantage-point_tree)
+ * [`BinarySpaceTree`](binary_space_tree.md)
+ * [Binary space partitioning on Wikipedia](https://dl.acm.org/doi/pdf/10.1145/361002.361007)
+ * [Data structures and algorithms for nearest neighbor search in general metric spaces (pdf)](https://scholar.archive.org/work/og2s6vjmcngfbkmesu3dbsazpq/access/wayback/https://dl.acm.org/doi/pdf/10.5555/313559.313789)
+ * [Satisfying General Proximity/Similarity Queries with Metric Trees (pdf)](https://www.mlpack.org/papers/uhlmann91.pdf)
+ * [Tree-Independent Dual-Tree Algorithms (pdf)](https://www.ratml.org/pub/pdf/2013tree.pdf)
+
+## Template parameters
+
+In accordance with the [TreeType
+API](../../../developer/trees.md#template-parameters-required-by-the-treetype-policy)
+(see also [this more detailed section](../../../developer/trees.md#template-parameters)),
+the `VPTree` class takes three template parameters:
+
+```
+VPTree<DistanceType, StatisticType, MatType>
+```
+
+ * `DistanceType`: the [distance metric](../distances.md) to use for distance
+   computations.  By default, this is
+   [`EuclideanDistance`](../distances.md#lmetric).
+ * [`StatisticType`](binary_space_tree.md#statistictype): this holds auxiliary
+   information in each tree node.  By default,
+   [`EmptyStatistic`](binary_space_tree.md#emptystatistic) is used, which holds
+   no information.
+ * `MatType`: the type of matrix used to represent points.  Must be a type
+   matching the [Armadillo API](../../matrices.md).  By default, `arma::mat` is
+   used, but other types such as `arma::fmat` or similar will work just fine.
+
+The `VPTree` class itself is a convenience typedef of the generic
+[`BinarySpaceTree`](binary_space_tree.md) class, using the
+[`HollowBallBound`](binary_space_tree.md#hollowballbound) class as the bounding
+structure, and using the
+[`VantagePointSplit`](binary_space_tree.md#vantagepointsplit) splitting strategy
+for construction, which splits points into those that are nearer and further
+from a 'vantage point'.
+
+## Constructors
+
+`VPTree`s are efficiently constructed by permuting points in a dataset in a
+quicksort-like algorithm.  However, this means that the ordering of points in
+the tree's dataset (accessed with `node.Dataset()`) after construction may be
+different.
+
+---
+
+ * `node = VPTree(data, maxLeafSize=20)`
+ * `node = VPTree(data, oldFromNew, maxLeafSize=20)`
+ * `node = VPTree(data, oldFromNew, newFromOld, maxLeafSize=20)`
+   - Construct a `VPTree` on the given `data`, using `maxLeafSize` as the
+     maximum number of points held in a leaf.
+   - By default, `data` is copied.  Avoid a copy by using `std::move()` (e.g.
+     `std::move(data)`); when doing this, `data` will be set to an empty matrix.
+   - Optionally, construct mappings from old points to new points.  `oldFromNew`
+     and `newFromOld` will have length `data.n_cols`, and:
+     * `oldFromNew[i]` indicates that point `i` in the tree's dataset was
+       originally point `oldFromNew[i]` in `data`; that is,
+       `node.Dataset().col(i)` is the point `data.col(oldFromNew[i])`.
+     * `newFromOld[i]` indicates that point `i` in `data` is now point
+       `newFromOld[i]` in the tree's dataset; that is,
+       `node.Dataset().col(newFromOld[i])` is the point `data.col(i)`.
+
+---
+
+ * `node = VPTree<DistanceType, StatisticType, MatType>(data, maxLeafSize=20)`
+ * `node = VPTree<DistanceType, StatisticType, MatType>(data, oldFromNew, maxLeafSize=20)`
+ * `node = VPTree<DistanceType, StatisticType, MatType>(data, oldFromNew, newFromOld, maxLeafSize=20)`
+   - Construct a `VPTree` on the given `data`, using custom template parameters
+     to control the behavior of the tree, using `maxLeafSize` as the maximum
+     number of points held in a leaf.
+   - By default, `data` is copied.  Avoid a copy by using `std::move()` (e.g.
+     `std::move(data)`); when doing this, `data` will be set to an empty matrix.
+   - Optionally, construct mappings from old points to new points.  `oldFromNew`
+     and `newFromOld` will have length `data.n_cols`, and:
+     * `oldFromNew[i]` indicates that point `i` in the tree's dataset was
+       originally point `oldFromNew[i]` in `data`; that is,
+       `node.Dataset().col(i)` is the point `data.col(oldFromNew[i])`.
+     * `newFromOld[i]` indicates that point `i` in `data` is now point
+       `newFromOld[i]` in the tree's dataset; that is,
+       `node.Dataset().col(newFromOld[i])` is the point `data.col(i)`.
+
+---
+
+ * `node = VPTree()`
+   - Construct an empty vantage point tree with no children and no points.
+
+---
+
+***Notes:***
+
+ - The name `node` is used here for `VPTree` objects instead of `tree`, because
+   each `VPTree` object is a single node in the tree.  The constructor returns
+   the node that is the root of the tree.
+
+ - Inserting individual points or removing individual points from a `VPTree` is
+   not supported, because this generally results in a vantage point tree with
+   very loose bounding balls.  It is better to simply build a new `VPTree` on
+   the modified dataset.  For trees that support individual insertion and
+   deletions, see the `RectangleTree` class and all its variants (e.g. `RTree`,
+   `RStarTree`, etc.).
+
+ - See also the
+   [developer documentation on tree constructors](../../../developer/trees.md#constructors-and-destructors).
+
+<!-- TODO: add links to RectangleTree above when it is documented -->
+
+---
+
+### Constructor parameters:
+
+| **name** | **type** | **description** | **default** |
+|----------|----------|-----------------|-------------|
+| `data` | [`arma::mat`](../../matrices.md) | [Column-major](../../matrices.md#representing-data-in-mlpack) matrix to build the tree on.  Pass with `std::move(data)` to avoid copying the matrix. | _(N/A)_ |
+| `maxLeafSize` | `size_t` | Maximum number of points to store in each leaf. | `20` |
+| `oldFromNew` | `std::vector<size_t>` | Mappings from points in `node.Dataset()` to points in `data`. | _(N/A)_ |
+| `newFromOld` | `std::vector<size_t>` | Mappings from points in `data` to points in `node.Dataset()`. | _(N/A)_ |
+
+## Basic tree properties
+
+Once a `VPTree` object is constructed, various properties of the tree can be
+accessed or inspected.  Many of these functions are required by the [TreeType
+API](../../../developer/trees.md#the-treetype-api).
+
+### Navigating the tree
+
+ * `node.NumChildren()` returns the number of children in `node`.  This is
+   either `2` if `node` has children, or `0` if `node` is a leaf.
+
+ * `node.IsLeaf()` returns a `bool` indicating whether or not `node` is a leaf.
+
+ * `node.Child(i)` returns a `VPTree&` that is the `i`th child.
+   - `i` must be `0` or `1`.
+   - This function should only be called if `node.NumChildren()` is not `0`
+     (e.g. if `node` is not a leaf).  Note that this returns a valid `VPTree&`
+     that can itself be used just like the root node of the tree!
+   - `node.Left()` and `node.Right()` are convenience functions specific to
+     `VPTree` that will return `VPTree*` (pointers) to the left and right
+     children, respectively, or `NULL` if `node` has no children.
+
+ * `node.Parent()` will return a `VPTree*` that points to the parent of `node`,
+   or `NULL` if `node` is the root of the `VPTree`.
+
+---
+
+### Accessing members of a tree
+
+ * `node.Bound()` will return an
+   [`HollowBallBound&`](binary_space_tree.md#hollowballbound) object that
+   represents the hollow bounding ball of `node`.  This structure encloses all
+   the descendant points of `node`.
+
+ * `node.Stat()` will return an `EmptyStatistic&` (or a `StatisticType&` if a
+   [custom `StatisticType`](#template-parameters) was specified as a template
+   parameter) holding the statistics of the node that were computed during tree
+   construction.
+
+ * `node.Distance()` will return a
+   [`EuclideanDistance&`](../distances.md#lmetric) (or a `DistanceType&` if a
+   [custom `DistanceType`](#template-parameters) was specified as a template
+   parameter).
+
+See also the
+[developer documentation](../../../developer/trees.md#basic-tree-functionality)
+for basic tree functionality in mlpack.
+
+---
+
+### Accessing data held in a tree
+
+ * `node.Dataset()` will return a `const arma::mat&` that is the dataset the
+   tree was built on.  Note that this is a permuted version of the `data` matrix
+   passed to the constructor.
+   - If a [custom `MatType`](#template-parameters) is being used, the return
+     type will be `const MatType&` instead of `const arma::mat&`.
+
+ * `node.NumPoints()` returns a `size_t` indicating the number of points held
+   directly in `node`.
+   - If `node` is not a leaf, this will return `0`, as `VPTree` only holds
+     points directly in its leaves.
+   - If `node` is a leaf, then the number of points will be less than or equal
+     to the `maxLeafSize` that was specified when the tree was constructed.
+
+ * `node.Point(i)` returns a `size_t` indicating the index of the `i`'th point
+   in `node.Dataset()`.
+   - `i` must be in the range `[0, node.NumPoints() - 1]` (inclusive).
+   - `node` must be a leaf (as non-leaves do not hold any points).
+   - The `i`'th point in `node` can then be accessed as
+     `node.Dataset().col(node.Point(i))`.
+   - In a `VPTree`, because of the permutation of points done [during
+     construction](#constructors), point indices are contiguous:
+     `node.Point(i + j)` is the same as `node.Point(i) + j` for valid `i` and
+     `j`.
+   - Accessing the actual `i`'th point itself can be done with, e.g.,
+     `node.Dataset().col(node.Point(i))`.
+
+ * `node.NumDescendants()` returns a `size_t` indicating the number of points
+   held in all descendant leaves of `node`.
+   - If `node` is the root of the tree, then `node.NumDescendants()` will be
+     equal to `node.Dataset().n_cols`.
+
+ * `node.Descendant(i)` returns a `size_t` indicating the index of the `i`'th
+   descendant point in `node.Dataset()`.
+   - `i` must be in the range `[0, node.NumDescendants() - 1]` (inclusive).
+   - `node` does not need to be a leaf.
+   - The `i`'th descendant point in `node` can then be accessed as
+     `node.Dataset().col(node.Descendant(i))`.
+   - In a `VPTree`, because of the permutation of points done [during
+     construction](#constructors), point indices are contiguous:
+     `node.Descendant(i + j)` is the same as `node.Descendant(i) + j` for valid
+     `i` and `j`.
+   - Accessing the actual `i`'th descendant itself can be done with, e.g.,
+     `node.Dataset().col(node.Descendant(i))`.
+
+ * `node.Begin()` returns a `size_t` indicating the index of the first
+   descendant point of `node`.
+   - This is equivalent to `node.Descendant(0)`.
+
+ * `node.Count()` returns a `size_t` indicating the number of descendant points    of `node`.
+   - This is equivalent to `node.NumDescendants()`.
+
+---
+
+### Accessing computed bound quantities of a tree
+
+The following quantities are cached for each node in a `VPTree`, and so
+accessing them does not require any computation.
+
+ * `node.FurthestPointDistance()` returns a `double` representing the distance
+   between the center of the hollow bounding ball of `node` and the furthest
+   point held by `node`.
+   - If `node` is not a leaf, this returns 0 (because `node` does not hold any
+     points).
+
+ * `node.FurthestDescendantDistance()` returns a `double` representing the
+   distance between the center of the hollow bounding ball of `node` and the
+   furthest descendant point held by `node`.
+
+ * `node.MinimumBoundDistance()` returns a `double` representing minimum
+   possible distance from the center of the node to any edge of the
+   hollow ball bound.
+   - This quantity is equivalent to `node.Bound().OuterRadius()`.
+
+ * `node.ParentDistance()` returns a `double` representing the distance between
+   the center of the hollow bounding ball of `node` and the center of the
+   hollow bounding ball of its parent.
+   - If `node` is the root of the tree, `0` is returned.
+
+***Notes:***
+
+ - If a [custom `MatType`](#template-parameters) was specified when constructing
+   the `VPTree`, then the return type of each method is the element type of the
+   given `MatType` instead of `double`.  (e.g., if `MatType` is `arma::fmat`,
+   then the return type is `float`.)
+
+ - For more details on each bound quantity, see the
+   [developer documentation](../../../developer/trees.md#complex-tree-functionality-and-bounds)
+   on bound quantities for trees.
+
+---
+
+### Other functionality
+
+ * `node.Center(center)` computes the center of the hollow bounding ball of
+   `node` and stores it in `center`.
+   - `center` should be of type `arma::vec&`.  (If a [custom
+     `MatType`](#template-parameters) was specified when constructing the
+     `VPTree`, the type is instead the column vector type for the given
+     `MatType`; e.g., `arma::fvec&` when `MatType` is `arma::fmat`.)
+   - `center` will be set to have size equivalent to the dimensionality of the
+     dataset held by `node`.
+   - This is equivalent to calling `node.Bound().Center(center)`.
+
+ * A `VPTree` can be serialized with
+   [`data::Save()` and `data::Load()`](../../load_save.md#mlpack-objects).
+
+## Bounding distances with the tree
+
+The primary use of trees in mlpack is bounding distances to points or other tree
+nodes.  The following functions can be used for these tasks.
+
+ * `node.GetNearestChild(point)`
+ * `node.GetFurthestChild(point)`
+   - Return a `size_t` indicating the index of the child (`0` for left, `1` for
+     right) that is closest to (or furthest from) `point`, with respect
+     to the `MinDistance()` (or `MaxDistance()`) function.
+   - If there is a tie, `0` (the left child) is returned.
+   - If `node` is a leaf, `0` is returned.
+   - `point` should be of type `arma::vec`.  (If a [custom
+     `MatType`](#template-parameters) was specified when constructing the
+     `VPTree`, the type is instead the column vector type for the given
+     `MatType`; e.g., `arma::fvec` when `MatType` is `arma::fmat`.)
+
+ * `node.GetNearestChild(other)`
+ * `node.GetFurthestChild(other)`
+   - Return a `size_t` indicating the index of the child (`0` for left, `1` for
+     right) that is closest to (or furthest from) the `VPTree` node `other`,
+     with respect to the `MinDistance()` (or `MaxDistance()`) function.
+   - If there is a tie, `2` (an invalid index) is returned. ***Note that this
+     behavior differs from the version above that takes a point.***
+   - If `node` is a leaf, `0` is returned.
+
+---
+
+ * `node.MinDistance(point)`
+ * `node.MinDistance(other)`
+   - Return a `double` indicating the minimum possible distance between `node`
+     and `point`, or the `VPTree` node `other`.
+   - This is equivalent to the minimum possible distance between any point
+     contained in the hollow bounding ball of `node` and `point`, or between
+     any point contained in the hollow bounding ball of `node` and any point
+     contained in the hollow bounding ball of `other`.
+   - `point` should be of type `arma::vec`.  (If a [custom
+     `MatType`](#template-parameters) was specified when constructing the
+     `VPTree`, the type is instead the column vector type for the given
+     `MatType`, and the return type is the element type of `MatType`; e.g.,
+     `point` should be `arma::fvec` when `MatType` is `arma::fmat`, and the
+     returned distance is `float`).
+
+ * `node.MaxDistance(point)`
+ * `node.MaxDistance(other)`
+   - Return a `double` indicating the maximum possible distance between `node`
+     and `point`, or the `VPTree` node `other`.
+   - This is equivalent to the maximum possible distance between any point
+     contained in the hollow bounding ball of `node` and `point`, or between
+     any point contained in the hollow bounding ball of `node` and any point
+     contained in the hollow bounding ball of `other`.
+   - `point` should be of type `arma::vec`.  (If a [custom
+     `MatType`](#template-parameters) was specified when constructing the
+     `VPTree`, the type is instead the column vector type for the given
+     `MatType`, and the return type is the element type of `MatType`; e.g.,
+     `point` should be `arma::fvec` when `MatType` is `arma::fmat`, and the
+     returned distance is `float`).
+
+ * `node.RangeDistance(point)`
+ * `node.RangeDistance(other)`
+   - Return a [`Range`](../math.md#range) whose lower bound is
+     `node.MinDistance(point)` or `node.MinDistance(other)`, and whose upper
+      bound is `node.MaxDistance(point)` or `node.MaxDistance(other)`.
+   - `point` should be of type `arma::vec`.  (If a
+     [custom `MatType`](#template-parameters) was specified when constructing
+     the `VPTree`, the type is instead the column vector type for the given
+     `MatType`, and the return type is a `RangeType` with element type the same
+     as `MatType`; e.g., `point` should be `arma::fvec` when `MatType` is
+     `arma::fmat`, and the returned type is
+     [`RangeType<float>`](../math.md#range)).
+
+### Tree traversals
+
+Like every mlpack tree, the `VPTree` class provides a [single-tree and dual-tree
+traversal](../../../developer/trees.md#traversals) that can be paired with a
+[`RuleType` class](../../../developer/trees.md#rules) to implement a single-tree
+or dual-tree algorithm.
+
+ * `VPTree::SingleTreeTraverser`
+   - Implements a depth-first single-tree traverser.
+
+ * `VPTree::DualTreeTraverser`
+   - Implements a dual-depth-first dual-tree traverser.
+
+In addition to those two classes, which are required by the
+[`TreeType` policy](../../../developer/trees.md), an additional traverser is
+available:
+
+ * `VPTree::BreadthFirstDualTreeTraverser`
+   - Implements a dual-breadth-first dual-tree traverser.
+   - ***Note:*** this traverser is not useful for all tasks; because the
+     `VPTree` only holds points in the leaves, this means that no base cases
+     (e.g. comparisons between points) will be called until *all* pairs of
+     intermediate nodes have been scored!
+
+## Example usage
+
+Build a `VPTree` on the `cloud` dataset and print basic statistics about the
+tree.
+
+```c++
+// See https://datasets.mlpack.org/cloud.csv.
+arma::mat dataset;
+mlpack::data::Load("cloud.csv", dataset, true);
+
+// Build the vp-tree with a leaf size of 10.  (This means that nodes are split
+// until they contain 10 or fewer points.)
+//
+// The std::move() means that `dataset` will be empty after this call, and no
+// data will be copied during tree building.
+//
+// Note that the '<>' isn't necessary if C++20 is being used (e.g.
+// `mlpack::VPTree tree(...)` will work fine in C++20 or newer).
+mlpack::VPTree<> tree(std::move(dataset));
+
+// Print the bounding ball of the root node.  (There will be no hollow ball.)
+std::cout << "Bounding ball of root node:" << std::endl;
+std::cout << " - Center: " << tree.Bound().Center().t();
+std::cout << " - Outer radius: " << tree.Bound().OuterRadius() << "."
+    << std::endl;
+std::cout << " - Hollow center: " << tree.Bound().HollowCenter().t();
+std::cout << " - Inner radius: " << tree.Bound().InnerRadius() << "."
+    << std::endl;
+std::cout << std::endl;
+
+// Print the bounding ball of the right child.  (This will have a hollow ball.)
+std::cout << "Bounding ball of right child: " << std::endl;
+std::cout << " - Center: " << tree.Right()->Bound().Center().t();
+std::cout << " - Outer radius: " << tree.Right()->Bound().OuterRadius() << "."
+    << std::endl;
+std::cout << " - Hollow center: " << tree.Right()->Bound().HollowCenter().t();
+std::cout << " - Inner radius: " << tree.Right()->Bound().InnerRadius() << "."
+    << std::endl;
+std::cout << " - Distance between centers: " <<
+mlpack::EuclideanDistance::Evaluate(tree.Right()->Bound().Center(),
+tree.Right()->Bound().HollowCenter()) << "." << std::endl;
+std::cout << std::endl;
+
+// Print the number of descendant points of the root, and of each of its
+// children.
+std::cout << "Descendant points of root:        "
+    << tree.NumDescendants() << "." << std::endl;
+std::cout << "Descendant points of left child:  "
+    << tree.Left()->NumDescendants() << "." << std::endl;
+std::cout << "Descendant points of right child: "
+    << tree.Right()->NumDescendants() << "." << std::endl;
+std::cout << std::endl;
+
+// Print the center of the vp-tree.
+arma::vec center;
+tree.Center(center);
+std::cout << "Center of vp-tree: " << center.t();
+```
+
+---
+
+Build two `VPTree`s on subsets of the corel dataset and compute various
+bounding quantities.
+
+```c++
+// See https://datasets.mlpack.org/corel-histogram.csv.
+arma::mat dataset;
+mlpack::data::Load("corel-histogram.csv", dataset, true);
+
+// Build vp-trees on the first half and the second half of points.
+mlpack::VPTree<> tree1(dataset.cols(0, dataset.n_cols / 2));
+mlpack::VPTree<> tree2(dataset.cols(dataset.n_cols / 2 + 1,
+    dataset.n_cols - 1));
+
+// Compute the maximum distance between the trees.
+std::cout << "Maximum distance between tree root nodes: "
+    << tree1.MaxDistance(tree2) << "." << std::endl;
+
+// Get the leftmost grandchild of the first tree's root---if it exists.
+if (!tree1.IsLeaf() && !tree1.Child(0).IsLeaf())
+{
+  mlpack::VPTree<>& node1 = tree1.Child(0).Child(0);
+
+  // Get the rightmost grandchild of the second tree's root---if it exists.
+  if (!tree2.IsLeaf() && !tree2.Child(1).IsLeaf())
+  {
+    mlpack::VPTree<>& node2 = tree2.Child(1).Child(1);
+
+    // Print the minimum and maximum distance between the nodes.
+    mlpack::Range dists = node1.RangeDistance(node2);
+    std::cout << "Possible distances between two grandchild nodes: ["
+        << dists.Lo() << ", " << dists.Hi() << "]." << std::endl;
+
+    // Print the minimum distance between the first node and the first
+    // descendant point of the second node.
+    const size_t descendantIndex = node2.Descendant(0);
+    const double descendantMinDist =
+        node1.MinDistance(node2.Dataset().col(descendantIndex));
+    std::cout << "Minimum distance between grandchild node and descendant "
+        << "point: " << descendantMinDist << "." << std::endl;
+
+    // Which child of node2 is closer to node1?
+    const size_t closerIndex = node2.GetNearestChild(node1);
+    if (closerIndex == 0)
+      std::cout << "The left child of node2 is closer to node1." << std::endl;
+    else if (closerIndex == 1)
+      std::cout << "The right child of node2 is closer to node1." << std::endl;
+    else // closerIndex == 2 in this case.
+      std::cout << "Both children of node2 are equally close to node1."
+          << std::endl;
+
+    // And which child of node1 is further from node2?
+    const size_t furtherIndex = node1.GetFurthestChild(node2);
+    if (furtherIndex == 0)
+      std::cout << "The left child of node1 is further from node2."
+          << std::endl;
+    else if (furtherIndex == 1)
+      std::cout << "The right child of node1 is further from node2."
+          << std::endl;
+    else // furtherIndex == 2 in this case.
+      std::cout << "Both children of node1 are equally far from node2."
+          << std::endl;
+  }
+}
+```
+
+---
+
+Build a `VPTree` on 32-bit floating point data and save it to disk.
+
+```c++
+// See https://datasets.mlpack.org/corel-histogram.csv.
+arma::fmat dataset;
+mlpack::data::Load("corel-histogram.csv", dataset);
+
+// Build the VPTree using 32-bit floating point data as the matrix type.
+// We will still use the default EmptyStatistic and EuclideanDistance
+// parameters.  A leaf size of 100 is used here.
+mlpack::VPTree<mlpack::EuclideanDistance,
+               mlpack::EmptyStatistic,
+               arma::fmat> tree(std::move(dataset), 100);
+
+// Save the VPTree to disk with the name 'tree'.
+mlpack::data::Save("tree.bin", "tree", tree);
+
+std::cout << "Saved tree with " << tree.Dataset().n_cols << " points to "
+    << "'tree.bin'." << std::endl;
+```
+
+---
+
+Load a 32-bit floating point `VPTree` from disk, then traverse it manually and
+find the number of leaf nodes with less than 10 children.
+
+```c++
+// This assumes the tree has already been saved to 'tree.bin' (as in the example
+// above).
+
+// This convenient typedef saves us a long type name!
+typedef mlpack::VPTree<mlpack::EuclideanDistance,
+                       mlpack::EmptyStatistic,
+                       arma::fmat> TreeType;
+
+TreeType tree;
+mlpack::data::Load("tree.bin", "tree", tree);
+std::cout << "Tree loaded with " << tree.NumDescendants() << " points."
+    << std::endl;
+
+// Recurse in a depth-first manner.  Count both the total number of leaves, and
+// the number of leaves with less than 10 points.
+size_t leafCount = 0;
+size_t totalLeafCount = 0;
+std::stack<TreeType*> stack;
+stack.push(&tree);
+while (!stack.empty())
+{
+  TreeType* node = stack.top();
+  stack.pop();
+
+  if (node->NumPoints() < 10)
+    ++leafCount;
+  ++totalLeafCount;
+
+  if (!node->IsLeaf())
+  {
+    stack.push(node->Left());
+    stack.push(node->Right());
+  }
+}
+
+// Note that it would be possible to use TreeType::SingleTreeTraverser to
+// perform the recursion above, but that is more well-suited for more complex
+// tasks that require pruning and other non-trivial behavior; so using a simple
+// stack is the better option here.
+
+// Print the results.
+std::cout << leafCount << " out of " << totalLeafCount << " leaves have less "
+  << "than 10 points." << std::endl;
+```
+
+---
+
+Build a `VPTree` and map between original points and new points.
+
+```c++
+// See https://datasets.mlpack.org/cloud.csv.
+arma::mat dataset;
+mlpack::data::Load("cloud.csv", dataset, true);
+
+// Build the tree.
+std::vector<size_t> oldFromNew, newFromOld;
+mlpack::VPTree<> tree(dataset, oldFromNew, newFromOld);
+
+// oldFromNew and newFromOld will be set to the same size as the dataset.
+std::cout << "Number of points in dataset: " << dataset.n_cols << "."
+    << std::endl;
+std::cout << "Size of oldFromNew: " << oldFromNew.size() << "." << std::endl;
+std::cout << "Size of newFromOld: " << newFromOld.size() << "." << std::endl;
+std::cout << std::endl;
+
+// See where point 42 in the tree's dataset came from.
+std::cout << "Point 42 in the permuted tree's dataset:" << std::endl;
+std::cout << "  " << tree.Dataset().col(42).t();
+std::cout << "Was originally point " << oldFromNew[42] << ":" << std::endl;
+std::cout << "  " << dataset.col(oldFromNew[42]).t();
+std::cout << std::endl;
+
+// See where point 7 in the original dataset was mapped.
+std::cout << "Point 7 in original dataset:" << std::endl;
+std::cout << "  " << dataset.col(7).t();
+std::cout << "Mapped to point " << newFromOld[7] << ":" << std::endl;
+std::cout << "  " << tree.Dataset().col(newFromOld[7]).t();
+```

From 5665e3f3944bbd47d0ef30bd13e1883668cd79a9 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 17:33:47 -0400
Subject: [PATCH 07/24] Minor fixes to HollowBallBound documentation.

---
 doc/user/core/trees/binary_space_tree.md | 51 +++++++++++++++++-------
 1 file changed, 37 insertions(+), 14 deletions(-)

diff --git a/doc/user/core/trees/binary_space_tree.md b/doc/user/core/trees/binary_space_tree.md
index 561ba1df26..ef66cecd1e 100644
--- a/doc/user/core/trees/binary_space_tree.md
+++ b/doc/user/core/trees/binary_space_tree.md
@@ -413,7 +413,7 @@ class uses a hyperrectangle bound.  An example `HRectBound` is shown below; the
 bound is the smallest rectangle that encloses all of the points.
 
 <center>
-<img src="../../../img/hrectbound.png" width="50%" alt="hyperrectangle bound enclosing points">
+<img src="../../../img/hrectbound.png" width="450" alt="hyperrectangle bound enclosing points">
 </center>
 
 mlpack supplies several drop-in `BoundType` classes, and it is also possible to
@@ -782,11 +782,13 @@ secondary center point and inner radius.  An example `HollowBallBound` is shown
 below in two dimensions; shaded area represents area held within the bound.
 
 <center>
-<img src="../../../img/hollowballbound.png" width="50%" alt="hollow ball bound">
+<img src="../../../img/hollowballbound.png" width="350" alt="hollow ball bound">
 </center>
 
 `HollowBallBound` is used directly by the [`VPTree`](vptree.md) class.
 
+---
+
 #### Constructors
 
 `HollowBallBound` allows configurable behavior via its two template parameters:
@@ -841,6 +843,8 @@ before using it!
    - The bound will use the given `DistanceType` class to compute distances, and
      expect data to have elements with type `ElemType`.
 
+---
+
 #### Accessing and modifying properties of the bound
 
 The individual bounds associated with each dimension of a `HollowBallBound` can
@@ -853,6 +857,7 @@ be accessed and modified.
 
  * `b.HollowCenter()` returns an `arma::vec&` containing the center of the inner
    ball.  Its elements can be directly modified.
+   - It is possible that `b.HollowCenter()` is outside of the outer ball!
 
  * `b.OuterRadius()` will return a `double` that is the radius of the outer
    ball.
@@ -861,6 +866,9 @@ be accessed and modified.
  * `b.InnerRadius()` will return a `double` that is the radius of the inner
    ball.
    - `b.InnerRadius() = r` will set the radius of the inner ball to `r`.
+   - It is possible that `b.InnerRadius() > b.OuterRadius()`, and this implies
+     that the hollow center is outside the outer ball (otherwise the bound is
+     empty).
 
  * `b[dim]` will return a [`Range`](../math.md#range) object representing the
    extents of the bound in dimension `dim`.
@@ -913,9 +921,12 @@ be accessed and modified.
  * `b.Center()` and `b.HollowCenter()` will return `arma::Col<ElemType>&`; and
  * `b.Center(center)` expects `center` to be of type `arma::Col<ElemType>`.
 
+---
+
 #### Growing the bound
 
-The `HollowBallBound` uses the logical `|=` to grow the bound to include points.
+The `HollowBallBound` uses the logical `|=` to grow the bound to include points
+or other bounds.
 
  * `b |= data` expands `b` so the outer ball includes all of the data points in
    `data`, shrinking the inner ball as necessary.  `data` should be a
@@ -931,6 +942,14 @@ The `HollowBallBound` uses the logical `|=` to grow the bound to include points.
    - If the bound is not empty, then `data` is expected to have dimensionality
      that matches `b.Dim()`.
 
+ * `b |= bound` expands `b` to include all of the volume included in `bound`.
+   The center points will not be modified.
+   - The outer ball's radius will be expanded to include the outer balls of both
+     `b` and `bound`.
+   - The inner (hollow) ball's radius will be shrunk to be the intersection of
+     the inner balls of `b` and `bound`.  (This may result in `b.InnerRadius()`
+     being 0.)
+
 ***Notes:***
 
  - The growth operation does not grow the inner (hollow) ball.  Properties
@@ -940,6 +959,8 @@ The `HollowBallBound` uses the logical `|=` to grow the bound to include points.
  - If a custom `ElemType` was specified, then any `data` argument should be a
    matrix with that `ElemType` (e.g. `arma::Mat<ElemType>`).
 
+---
+
 #### Bounding distances to other objects
 
 Once a `HollowBallBound` has been successfully created and set to the desired
@@ -993,6 +1014,8 @@ constructor, then all distances will be computed with respect to the specified
 [`RangeType<ElemType>`](../math.md#range) (except for `Contains()`, which will
 still return a `bool`).
 
+---
+
 #### Example usage
 
 ```c++
@@ -1004,7 +1027,7 @@ mlpack::HollowBallBound b(0.5, 1.0, arma::vec(3));
 std::cout << "Hollow unit ball bound created manually:" << std::endl;
 std::cout << " - Center: " << b.Center().t();
 std::cout << " - Outer radius: " << b.OuterRadius() << "." << std::endl;
-std::cout << " - Hollow center: " << b.HollowCenter.();
+std::cout << " - Hollow center: " << b.HollowCenter().t();
 std::cout << " - Inner radius: " << b.InnerRadius() << "." << std::endl;
 for (size_t i = 0; i < 3; ++i)
 {
@@ -1036,8 +1059,8 @@ std::cout << std::endl;
 // On the other hand, if we initialize a HollowBallBound to a non-empty bound,
 // then `operator|=()` will shrink the hollow ball as necessary.
 //
-// We initialize this ball bound to a "slice" with radii [2.6, 2.7].
-mlpack::HollowBallBound b3(2.6, 2.7, arma::vec(3));
+// We initialize this ball bound to a "slice" with radii [3.6, 3.7].
+mlpack::HollowBallBound b3(3.6, 3.7, arma::vec(3));
 b3 |= dataset;
 std::cout << "Hollow ball bound on points with pre-initialization and "
     << "`operator|=()`:" << std::endl;
@@ -1057,16 +1080,16 @@ b4.HollowCenter() = arma::vec("1.0 1.0 1.0");
 
 // Compute the minimum distance between a point inside the hollow unit ball's
 // outer ball.
-const double d1 = b.MinDistance(arma::vec("0.75 0.75 0.75"));
-std::cout << "Minimum distance between hollow unit ball bound and [0.75, 0.75, "
-    << "0.75]: " << d1 << "." << std::endl;
+const double d1 = b.MinDistance(arma::vec("0.9 0.9 0.9"));
+std::cout << "Minimum distance between hollow unit ball bound and [0.9, 0.9, "
+    << "0.9]: " << d1 << "." << std::endl;
 
 // Compute the minimum distance between a point inside the hollow unit ball's
 // inner ball (so the point is not contained in the bound---it is within the
 // hollow section).
-const double d2 = b.MinDistance(arma::vec("0.25 0.25 0.25"));
-std::cout << "Minimum distance between hollow unit ball bound and [0.25, 0.25, "
-    << "0.25]: " << d2 << "." << std::endl;
+const double d2 = b.MinDistance(arma::vec("0.0 0.0 0.0"));
+std::cout << "Minimum distance between hollow unit ball bound and [0.0, 0.0, "
+    << "0.0]: " << d2 << "." << std::endl;
 std::cout << std::endl;
 
 // Use Contains().  In this case, the 'else' will be taken.
@@ -1083,9 +1106,9 @@ std::cout << std::endl;
 
 // Compute the maximum distance between a point inside the unit ball and the
 // unit hollow ball bound.
-const double d2 = b4.MaxDistance(arma::vec("0.1 0.1 0.1"));
+const double d3 = b4.MaxDistance(arma::vec("0.1 0.1 0.1"));
 std::cout << "Maximum distance between hollow unit ball bound and [0.1, 0.1, "
-    << "0.1]: " << d2 << "." << std::endl;
+    << "0.1]: " << d3 << "." << std::endl;
 
 // Compute the minimum and maximum distances between the hollow unit ball bound
 // and the bound built on data points.

From 959333cebda6cb10e3625271c4aa4b40cf30f1f2 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 17:34:07 -0400
Subject: [PATCH 08/24] Add default template parameters for VPTree typedef.

---
 src/mlpack/core/tree/binary_space_tree/typedef.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/mlpack/core/tree/binary_space_tree/typedef.hpp b/src/mlpack/core/tree/binary_space_tree/typedef.hpp
index 021ecbdd7d..c14d1da02e 100644
--- a/src/mlpack/core/tree/binary_space_tree/typedef.hpp
+++ b/src/mlpack/core/tree/binary_space_tree/typedef.hpp
@@ -194,7 +194,9 @@ template<typename BoundType,
          typename MatType = arma::mat>
 using VPTreeSplit = VantagePointSplit<BoundType, MatType, 100>;
 
-template<typename DistanceType, typename StatisticType, typename MatType>
+template<typename DistanceType = EuclideanDistance,
+         typename StatisticType = EmptyStatistic,
+         typename MatType = arma::mat>
 using VPTree = BinarySpaceTree<DistanceType,
                                StatisticType,
                                MatType,

From 351bce0fd70a99f612b12bd6273b4e2bd90dbbfd Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 17:34:21 -0400
Subject: [PATCH 09/24] Restore operator|=() overload because it actually was
 implemented.

---
 src/mlpack/core/tree/hollow_ball_bound.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/mlpack/core/tree/hollow_ball_bound.hpp b/src/mlpack/core/tree/hollow_ball_bound.hpp
index a41c10798f..2cad206b82 100644
--- a/src/mlpack/core/tree/hollow_ball_bound.hpp
+++ b/src/mlpack/core/tree/hollow_ball_bound.hpp
@@ -212,6 +212,16 @@ class HollowBallBound
   template<typename MatType>
   const HollowBallBound& operator|=(const MatType& data);
 
+  /**
+   * Expand the bound to include the given bound.  The centroid will not be
+   * moved.
+   *
+   * @tparam MatType Type of matrix; could be arma::mat, arma::spmat, or a
+   *     vector.
+   * @tparam data Data points to add.
+   */
+  const HollowBallBound& operator|=(const HollowBallBound& other);
+
   /**
    * Returns the diameter of the ballbound.
    */

From 100d50089aec4e55fb711b1750ff06f48e31eda7 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 17:34:57 -0400
Subject: [PATCH 10/24] Fix bugs in HollowBallBound implementation.

---
 src/mlpack/core/tree/hollow_ball_bound_impl.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/mlpack/core/tree/hollow_ball_bound_impl.hpp b/src/mlpack/core/tree/hollow_ball_bound_impl.hpp
index 4d65a0aeec..41d3122234 100644
--- a/src/mlpack/core/tree/hollow_ball_bound_impl.hpp
+++ b/src/mlpack/core/tree/hollow_ball_bound_impl.hpp
@@ -316,8 +316,8 @@ RangeType<ElemType> HollowBallBound<TDistanceType, ElemType>::RangeDistance(
     typename std::enable_if_t<IsVector<VecType>::value>* /* junk */) const
 {
   if (radii.Hi() < 0)
-    return Range(std::numeric_limits<ElemType>::max(),
-                       std::numeric_limits<ElemType>::max());
+    return RangeType<ElemType>(std::numeric_limits<ElemType>::max(),
+                               std::numeric_limits<ElemType>::max());
   else
   {
     RangeType<ElemType> range;
@@ -461,7 +461,7 @@ void HollowBallBound<TDistanceType, ElemType>::serialize(
   ar(CEREAL_NVP(radii));
   ar(CEREAL_NVP(center));
   ar(CEREAL_NVP(hollowCenter));
-  ar(CEREAL_POINTER(distance));
+
   if (cereal::is_loading<Archive>())
   {
     // If we're loading, delete the local distance since we'll have a new one.
@@ -470,6 +470,8 @@ void HollowBallBound<TDistanceType, ElemType>::serialize(
 
     ownsDistance = true;
   }
+
+  ar(CEREAL_POINTER(distance));
 }
 
 } // namespace mlpack

From 0eb90aeb4db7a4d346a625b92ca1cd716343cc9c Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 2 Oct 2024 17:41:20 -0400
Subject: [PATCH 11/24] Add HISTORY.md entry for fixes.

---
 HISTORY.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/HISTORY.md b/HISTORY.md
index 81689fcada..bc7d882b5a 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -4,8 +4,9 @@
 
 _????-??-??_
 
- * Fix compilation with clang 19 (#3799)
+ * Fix compilation with clang 19 (#3799).
 
+ * Fix serialization and `MinDistance()` bugs with `HollowBallBound` (#3808).
 
 ## mlpack 4.5.0
 

From 06703fbd3c1ec98d47867a8fc61c25286fd7f8a7 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Mon, 7 Oct 2024 10:57:13 -0400
Subject: [PATCH 12/24] Don't search for gonum anymore; it's automatically
 installed by Go modules.

---
 .ci/linux-steps.yaml                        | 5 -----
 .ci/macos-steps.yaml                        | 5 -----
 README.md                                   | 3 ++-
 src/mlpack/bindings/go/CMakeLists.txt       | 7 ++-----
 src/mlpack/bindings/go/tests/CMakeLists.txt | 3 ---
 5 files changed, 4 insertions(+), 19 deletions(-)

diff --git a/.ci/linux-steps.yaml b/.ci/linux-steps.yaml
index cb669ba27e..b5e208e265 100644
--- a/.ci/linux-steps.yaml
+++ b/.ci/linux-steps.yaml
@@ -69,11 +69,6 @@ steps:
 # Configure mlpack (CMake)
 - script: |
     mkdir build && cd build
-    if [ "$BINDING" = "go" ]; then
-      export GOPATH=$PWD/src/mlpack/bindings/go
-      export GO111MODULE=off
-      go get -u -t gonum.org/v1/gonum/...
-    fi
     cmake $CMAKEARGS -DPYTHON_EXECUTABLE=`which python` -DCEREAL_INCLUDE_DIR=/usr/include/ ..
   displayName: 'CMake'
 
diff --git a/.ci/macos-steps.yaml b/.ci/macos-steps.yaml
index b250b6e690..f94c273da6 100644
--- a/.ci/macos-steps.yaml
+++ b/.ci/macos-steps.yaml
@@ -33,11 +33,6 @@ steps:
 # Configure mlpack (CMake)
 - script: |
     mkdir build && cd build
-    if [ "$BINDING" = "go" ]; then
-      export GOPATH=$PWD/src/mlpack/bindings/go
-      export GO111MODULE=off
-      go get -u gonum.org/v1/gonum/...
-    fi
     if [ "$BINDING" = "python" ]; then
       cmake $CMAKEARGS -DPYTHON_EXECUTABLE=$(which python) ..
     else
diff --git a/README.md b/README.md
index 4fb8659634..495b0e13a7 100644
--- a/README.md
+++ b/README.md
@@ -396,7 +396,8 @@ and then `using mlpack` should work.
 *See also the [Go quickstart](doc/quickstart/go.md).*
 
 To build mlpack's Go bindings, ensure that Go >= 1.11.0 is installed, and that
-the Gonum package is available.  You can use `go get` to install mlpack for Go:
+the Gonum package is available.  You can use `go get` to install mlpack as a
+module in a Go project:
 
 ```sh
 go get -u -d mlpack.org/v1/mlpack
diff --git a/src/mlpack/bindings/go/CMakeLists.txt b/src/mlpack/bindings/go/CMakeLists.txt
index 079348cad0..50fa4677f3 100644
--- a/src/mlpack/bindings/go/CMakeLists.txt
+++ b/src/mlpack/bindings/go/CMakeLists.txt
@@ -40,20 +40,17 @@ endif ()
 
 if (BUILD_GO_BINDINGS)
 
+  # Gonum will automatically be installed by Go's module support during build.
   find_package(Go 1.11.0)
   if (NOT GO_FOUND)
     set(GO_NOT_FOUND_MSG "${GO_NOT_FOUND_MSG}\n    - Go")
   endif ()
-  find_package(Gonum)
-  if (NOT GONUM_FOUND)
-    set(GO_NOT_FOUND_MSG "${GO_NOT_FOUND_MSG}\n    - Gonum")
-  endif ()
 
   ## We need to check here if Golang is even available.  Although actually
   ## technically, I'm not sure if we even need to know!  For the tests though we
   ## do.  So it's probably a good idea to check.
   if (FORCE_BUILD_GO_BINDINGS)
-    if (NOT GO_FOUND OR NOT GONUM_FOUND)
+    if (NOT GO_FOUND)
       unset(BUILD_GO_BINDINGS CACHE)
       set(BUILD_GO_SHLIB OFF)
       message(FATAL_ERROR "\nCould not Build Go Bindings; the following modules are not available: ${GO_NOT_FOUND_MSG}")
diff --git a/src/mlpack/bindings/go/tests/CMakeLists.txt b/src/mlpack/bindings/go/tests/CMakeLists.txt
index 17b6aa85a2..1bf80326eb 100644
--- a/src/mlpack/bindings/go/tests/CMakeLists.txt
+++ b/src/mlpack/bindings/go/tests/CMakeLists.txt
@@ -5,7 +5,4 @@ if (BUILD_GO_BINDINGS)
 add_test(NAME go_binding_test
     COMMAND ${GO_EXECUTABLE} test -v  ${CMAKE_CURRENT_SOURCE_DIR}/go_binding_test.go
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/src/mlpack/bindings/go/src/mlpack.org/v1/mlpack/)
-set_tests_properties(go_binding_test
-      PROPERTIES ENVIRONMENT "GOPATH=$ENV{GOPATH}:${CMAKE_BINARY_DIR}/src/mlpack/bindings/go/;
-      LD_LIBRARY_PATH=$ENV{LD_LIBRARY_PATH}:${CMAKE_BINARY_DIR}/src/mlpack/bindings/go/src/mlpack.org/v1/mlpack/")
 endif()

From b5c024525f6b1328a8f6f12cdc34eaa0e83d4ef1 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Mon, 7 Oct 2024 11:50:35 -0400
Subject: [PATCH 13/24] Update documentation for how to use Go bindings with
 modules.

---
 README.md            | 15 ++++++++++++---
 doc/quickstart/go.md | 14 +++++++++++---
 2 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 495b0e13a7..2c95a012aa 100644
--- a/README.md
+++ b/README.md
@@ -400,11 +400,20 @@ the Gonum package is available.  You can use `go get` to install mlpack as a
 module in a Go project:
 
 ```sh
-go get -u -d mlpack.org/v1/mlpack
-cd ${GOPATH}/src/mlpack.org/v1/mlpack
-make install
+go get -u mlpack.org/v1/mlpack
 ```
 
+The Go bindings themselves will then need to be compiled.  Find the mlpack
+directory under `$GOMODCACHE/mlpack.org/v1/mlpack` and run these commands:
+
+```sh
+make
+sudo make install
+```
+
+Then, `go run my_code.go` will be able to correctly link against mlpack's Go
+bindings and run.
+
 The process of building the Go bindings by hand is a little tedious, so
 following the steps above is recommended.  However, if you wish to build the Go
 bindings by hand anyway, you can do this by running the following commands from
diff --git a/doc/quickstart/go.md b/doc/quickstart/go.md
index bdb6ea62ca..ffb6fbe2c9 100644
--- a/doc/quickstart/go.md
+++ b/doc/quickstart/go.md
@@ -9,13 +9,21 @@ This quickstart guide is also available for [C++](cpp.md), [Python](python.md),
 ## Installing mlpack
 
 Installing the mlpack bindings for Go is somewhat time-consuming as the library
-must be built; you can run the following code:
+must be built; you can run the following to add mlpack as a dependency inside of
+a Go module:
 
 ```sh
 go get -u -d mlpack.org/v1/mlpack
-cd ${GOPATH}/src/mlpack.org/v1/mlpack
-make install
 ```
+
+The Go bindings themselves will then need to be compiled.  Find the mlpack
+directory under `$GOMODCACHE/mlpack.org/v1/mlpack` and run these commands:
+
+```sh
+make
+sudo make install
+```
+
 Building the Go bindings from scratch is a little more in-depth, though.  For
 information on that, follow the instructions in the
 [main README](../../README.md).

From 471a3daa270f98cd54914cd7f11abe3a4a3358e5 Mon Sep 17 00:00:00 2001
From: Martin Lambertsen <github@lambertsen.one>
Date: Fri, 11 Oct 2024 18:39:44 +0200
Subject: [PATCH 14/24] Modernize STL type traits

With newer standards the readability of template heavy code can
be improved a lot by using a form with trailing _t for ::type and
_v for ::value respectively. Especially for ::type it also makes
the additional typename before the trait dispensable.

This PR combines multiple commits that modernize the traits,
starting with what clang-tidy could achieve while analyzing test files
and continuing by regex replaces with few manual corrections.

While it does not guarantee that all current occurrences are modernized,
it moves the codebase considerably into the modern direction. Note that
also before this PR both notations were used, so missing a few should
be acceptable.
---
 doc/developer/trees.md                        |  4 +-
 doc/user/cv.md                                |  2 +-
 src/mlpack/bindings/R/default_param.hpp       | 32 +++----
 src/mlpack/bindings/R/default_param_impl.hpp  | 42 ++++----
 src/mlpack/bindings/R/get_printable_param.hpp | 24 ++---
 src/mlpack/bindings/R/get_printable_type.hpp  | 94 +++++++++---------
 .../bindings/R/get_printable_type_impl.hpp    | 96 +++++++++----------
 src/mlpack/bindings/R/get_r_type.hpp          | 84 ++++++++--------
 src/mlpack/bindings/R/get_type.hpp            | 92 +++++++++---------
 src/mlpack/bindings/R/print_doc.hpp           |  2 +-
 src/mlpack/bindings/R/print_input_param.hpp   |  2 +-
 .../bindings/R/print_input_processing.hpp     | 20 ++--
 .../bindings/R/print_output_processing.hpp    | 24 ++---
 .../bindings/R/print_serialize_util.hpp       | 12 +--
 src/mlpack/bindings/R/print_type_doc.hpp      | 24 ++---
 src/mlpack/bindings/R/print_type_doc_impl.hpp | 38 ++++----
 src/mlpack/bindings/cli/add_to_cli11.hpp      | 80 ++++++++--------
 src/mlpack/bindings/cli/cli_option.hpp        | 10 +-
 src/mlpack/bindings/cli/default_param.hpp     | 32 +++----
 .../bindings/cli/default_param_impl.hpp       | 32 +++----
 .../bindings/cli/delete_allocated_memory.hpp  | 12 +--
 .../bindings/cli/get_allocated_memory.hpp     | 12 +--
 src/mlpack/bindings/cli/get_param.hpp         | 20 ++--
 .../bindings/cli/get_printable_param.hpp      | 24 ++---
 .../bindings/cli/get_printable_param_impl.hpp | 28 +++---
 .../bindings/cli/get_printable_param_name.hpp | 20 ++--
 .../cli/get_printable_param_name_impl.hpp     | 18 ++--
 .../cli/get_printable_param_value.hpp         | 20 ++--
 .../cli/get_printable_param_value_impl.hpp    | 18 ++--
 .../bindings/cli/get_printable_type.hpp       | 24 ++---
 .../bindings/cli/get_printable_type_impl.hpp  | 46 ++++-----
 src/mlpack/bindings/cli/get_raw_param.hpp     | 20 ++--
 src/mlpack/bindings/cli/in_place_copy.hpp     | 22 ++---
 .../bindings/cli/map_parameter_name.hpp       | 18 ++--
 src/mlpack/bindings/cli/output_param.hpp      | 24 ++---
 src/mlpack/bindings/cli/output_param_impl.hpp | 22 ++---
 src/mlpack/bindings/cli/print_type_doc.hpp    | 24 ++---
 .../bindings/cli/print_type_doc_impl.hpp      | 46 ++++-----
 src/mlpack/bindings/cli/set_param.hpp         | 24 ++---
 src/mlpack/bindings/cli/string_type_param.hpp |  8 +-
 .../bindings/cli/string_type_param_impl.hpp   |  8 +-
 src/mlpack/bindings/go/default_param.hpp      | 32 +++----
 src/mlpack/bindings/go/default_param_impl.hpp | 44 ++++-----
 src/mlpack/bindings/go/get_go_type.hpp        | 82 ++++++++--------
 .../bindings/go/get_printable_param.hpp       | 24 ++---
 src/mlpack/bindings/go/get_printable_type.hpp | 82 ++++++++--------
 .../bindings/go/get_printable_type_impl.hpp   | 80 ++++++++--------
 src/mlpack/bindings/go/get_type.hpp           | 56 +++++------
 src/mlpack/bindings/go/print_defn_input.hpp   | 20 ++--
 src/mlpack/bindings/go/print_defn_output.hpp  | 20 ++--
 src/mlpack/bindings/go/print_doc.hpp          |  2 +-
 .../bindings/go/print_input_processing.hpp    | 22 ++---
 .../bindings/go/print_method_config.hpp       | 28 +++---
 src/mlpack/bindings/go/print_method_init.hpp  | 28 +++---
 .../bindings/go/print_output_processing.hpp   | 24 ++---
 src/mlpack/bindings/go/print_type_doc.hpp     | 24 ++---
 .../bindings/go/print_type_doc_impl.hpp       | 34 +++----
 src/mlpack/bindings/julia/default_param.hpp   | 32 +++----
 .../bindings/julia/default_param_impl.hpp     | 42 ++++----
 src/mlpack/bindings/julia/get_julia_type.hpp  | 94 +++++++++---------
 .../bindings/julia/get_printable_param.hpp    | 24 ++---
 .../bindings/julia/get_printable_type.hpp     | 24 ++---
 .../julia/get_printable_type_impl.hpp         | 46 ++++-----
 .../bindings/julia/print_input_param.hpp      |  4 +-
 .../bindings/julia/print_input_processing.hpp | 28 +++---
 .../julia/print_input_processing_impl.hpp     | 32 +++----
 .../julia/print_model_type_import.hpp         | 12 +--
 .../julia/print_output_processing.hpp         | 28 +++---
 .../julia/print_output_processing_impl.hpp    | 44 ++++-----
 .../bindings/julia/print_param_defn.hpp       | 12 +--
 src/mlpack/bindings/julia/print_type_doc.hpp  | 24 ++---
 .../bindings/julia/print_type_doc_impl.hpp    | 38 ++++----
 .../bindings/markdown/default_param.hpp       | 10 +-
 .../bindings/markdown/get_printable_param.hpp | 24 ++---
 .../markdown/get_printable_param_name.hpp     | 20 ++--
 .../get_printable_param_name_impl.hpp         | 18 ++--
 .../markdown/get_printable_param_value.hpp    | 20 ++--
 .../get_printable_param_value_impl.hpp        | 18 ++--
 .../bindings/markdown/get_printable_type.hpp  | 10 +-
 .../bindings/markdown/is_serializable.hpp     |  8 +-
 .../bindings/markdown/print_type_doc.hpp      | 10 +-
 src/mlpack/bindings/python/default_param.hpp  | 32 +++----
 .../bindings/python/default_param_impl.hpp    | 42 ++++----
 .../bindings/python/get_cython_type.hpp       | 50 +++++-----
 .../bindings/python/get_printable_param.hpp   | 24 ++---
 .../bindings/python/get_printable_type.hpp    | 92 +++++++++---------
 .../python/get_printable_type_impl.hpp        | 94 +++++++++---------
 src/mlpack/bindings/python/import_decl.hpp    | 12 +--
 .../bindings/python/is_serializable.hpp       |  6 +-
 .../bindings/python/print_class_defn.hpp      | 12 +--
 src/mlpack/bindings/python/print_defn.hpp     |  2 +-
 src/mlpack/bindings/python/print_doc.hpp      |  2 +-
 .../python/print_input_processing.hpp         | 40 ++++----
 .../python/print_output_processing.hpp        | 20 ++--
 src/mlpack/bindings/python/print_type_doc.hpp | 24 ++---
 .../bindings/python/print_type_doc_impl.hpp   | 38 ++++----
 .../tests/delete_allocated_memory.hpp         | 12 +--
 .../bindings/tests/get_allocated_memory.hpp   | 12 +--
 .../bindings/tests/get_printable_param.hpp    | 24 ++---
 .../tests/get_printable_param_impl.hpp        | 22 ++---
 src/mlpack/core/cereal/is_loading.hpp         | 16 ++--
 src/mlpack/core/cereal/is_saving.hpp          | 16 ++--
 src/mlpack/core/cv/cv_base.hpp                | 16 ++--
 src/mlpack/core/cv/cv_base_impl.hpp           | 37 +++----
 src/mlpack/core/cv/k_fold_cv.hpp              |  8 +-
 src/mlpack/core/cv/meta_info_extractor.hpp    | 14 +--
 src/mlpack/core/cv/simple_cv.hpp              |  4 +-
 src/mlpack/core/data/dataset_mapper_impl.hpp  |  4 +-
 src/mlpack/core/data/has_serialize.hpp        |  2 +-
 src/mlpack/core/data/load_numeric_csv.hpp     | 10 +-
 src/mlpack/core/data/string_encoding.hpp      |  4 +-
 src/mlpack/core/data/string_encoding_impl.hpp | 22 ++---
 .../distributions/discrete_distribution.hpp   |  2 +-
 .../discrete_distribution_impl.hpp            |  4 +-
 .../core/distributions/gamma_distribution.hpp |  8 +-
 src/mlpack/core/hpt/cv_function.hpp           | 16 ++--
 src/mlpack/core/hpt/deduce_hp_types.hpp       |  2 +-
 src/mlpack/core/hpt/fixed.hpp                 |  2 +-
 src/mlpack/core/hpt/hpt.hpp                   | 10 +-
 src/mlpack/core/hpt/hpt_impl.hpp              |  4 +-
 src/mlpack/core/math/digamma.hpp              |  6 +-
 src/mlpack/core/math/trigamma.hpp             |  4 +-
 src/mlpack/core/tree/address.hpp              | 20 ++--
 .../tree/binary_space_tree/ub_tree_split.hpp  |  4 +-
 src/mlpack/core/tree/build_tree.hpp           |  8 +-
 src/mlpack/core/tree/cellbound.hpp            |  4 +-
 .../rectangle_tree/discrete_hilbert_value.hpp |  4 +-
 .../tree/rectangle_tree/rectangle_tree.hpp    |  2 +-
 src/mlpack/core/util/ens_traits.hpp           | 12 +--
 .../core/util/first_element_is_arma.hpp       |  4 +-
 src/mlpack/core/util/prefixedoutstream.hpp    |  4 +-
 .../core/util/prefixedoutstream_impl.hpp      |  4 +-
 src/mlpack/core/util/sfinae_utility.hpp       | 29 +++---
 src/mlpack/core/util/size_checks.hpp          | 10 +-
 src/mlpack/core/util/using.hpp                |  2 +-
 src/mlpack/methods/adaboost/adaboost.hpp      | 10 +-
 src/mlpack/methods/adaboost/adaboost_impl.hpp | 10 +-
 .../ann/convolution_rules/fft_convolution.hpp |  8 +-
 .../convolution_rules/naive_convolution.hpp   |  8 +-
 src/mlpack/methods/ann/ffn.hpp                |  8 +-
 src/mlpack/methods/ann/ffn_impl.hpp           |  8 +-
 src/mlpack/methods/ann/not_adapted/brnn.hpp   |  8 +-
 .../methods/ann/not_adapted/brnn_impl.hpp     | 12 +--
 .../methods/ann/not_adapted/gan/gan.hpp       | 34 +++----
 .../methods/ann/not_adapted/gan/gan_impl.hpp  | 12 +--
 .../methods/ann/not_adapted/gan/wgan_impl.hpp |  6 +-
 .../ann/not_adapted/gan/wgangp_impl.hpp       | 12 +--
 .../methods/ann/not_adapted/rbm/rbm.hpp       | 38 ++++----
 .../methods/ann/not_adapted/rbm/rbm_impl.hpp  | 14 +--
 .../not_adapted/rbm/spike_slab_rbm_impl.hpp   | 22 ++---
 .../bayesian_linear_regression.hpp            | 36 +++----
 .../methods/decision_tree/decision_tree.hpp   | 16 ++--
 .../decision_tree/decision_tree_impl.hpp      | 67 +++++++------
 .../decision_tree/decision_tree_regressor.hpp | 16 ++--
 .../decision_tree_regressor_impl.hpp          | 72 +++++++-------
 .../best_binary_categorical_split_impl.hpp    |  2 +-
 .../splits/best_binary_numeric_split.hpp      |  8 +-
 .../splits/best_binary_numeric_split_impl.hpp |  8 +-
 src/mlpack/methods/det/dtree_impl.hpp         |  2 +-
 src/mlpack/methods/gmm/em_fit_impl.hpp        | 16 ++--
 .../gmm/positive_definite_constraint.hpp      |  4 +-
 src/mlpack/methods/kde/kde_impl.hpp           |  4 +-
 src/mlpack/methods/kde/kde_model.hpp          | 12 +--
 src/mlpack/methods/kde/kde_rules.hpp          |  2 +-
 .../methods/kmeans/dual_tree_kmeans_impl.hpp  |  8 +-
 src/mlpack/methods/lars/lars.hpp              | 96 +++++++++----------
 .../linear_regression/linear_regression.hpp   | 44 ++++-----
 .../linear_regression_impl.hpp                |  4 +-
 src/mlpack/methods/linear_svm/linear_svm.hpp  | 44 ++++-----
 src/mlpack/methods/lmnn/lmnn.hpp              | 20 ++--
 .../local_coordinate_coding/lcc_impl.hpp      |  2 +-
 .../logistic_regression.hpp                   | 48 +++++-----
 src/mlpack/methods/mean_shift/mean_shift.hpp  |  4 +-
 .../methods/mean_shift/mean_shift_impl.hpp    |  4 +-
 .../naive_bayes_classifier_impl.hpp           | 24 ++---
 src/mlpack/methods/nca/nca.hpp                | 20 ++--
 src/mlpack/methods/pca/pca_impl.hpp           | 12 +--
 src/mlpack/methods/perceptron/perceptron.hpp  |  8 +-
 .../methods/perceptron/perceptron_impl.hpp    |  8 +-
 .../softmax_regression/softmax_regression.hpp | 46 ++++-----
 src/mlpack/tests/cv_test.cpp                  |  4 +-
 src/mlpack/tests/distribution_test.cpp        | 32 +++----
 src/mlpack/tests/lars_test.cpp                |  6 +-
 src/mlpack/tests/lmnn_test.cpp                | 24 ++---
 .../tests/main_tests/main_test_fixture.hpp    |  2 +-
 src/mlpack/tests/nca_test.cpp                 |  6 +-
 src/mlpack/tests/pca_test.cpp                 |  6 +-
 src/mlpack/tests/sparse_coding_test.cpp       |  6 +-
 src/mlpack/tests/test_catch_tools.hpp         | 20 ++--
 src/mlpack/tests/ub_tree_test.cpp             |  4 +-
 190 files changed, 2142 insertions(+), 2141 deletions(-)

diff --git a/doc/developer/trees.md b/doc/developer/trees.md
index 48f548996e..aa31c277f0 100644
--- a/doc/developer/trees.md
+++ b/doc/developer/trees.md
@@ -222,7 +222,7 @@ class ExampleTree
   template<typename Archive>
   ExampleTree(
       Archive& ar,
-      const typename std::enable_if_c<typename Archive::is_loading>::type* = 0);
+      const std::enable_if_t<typename Archive::is_loading>* = 0);
 
   // Release any resources held by the tree.
   ~ExampleTree();
@@ -476,7 +476,7 @@ archive:
 template<typename Archive>
 ExampleTree(
     Archive& ar,
-    const typename std::enable_if_c<typename Archive::is_loading>::type* = 0);
+    const std::enable_if_t<typename Archive::is_loading>* = 0);
 ```
 
 This has implications on how the tree must be stored.  In this case, the dataset
diff --git a/doc/user/cv.md b/doc/user/cv.md
index 53067911d7..51302b57cd 100644
--- a/doc/user/cv.md
+++ b/doc/user/cv.md
@@ -111,7 +111,7 @@ DecisionTree(MatType&& data,
              WeightsType&& weights,
              const size_t minimumLeafSize = 10,
              const std::enable_if_t<arma::is_arma_type<
-                 typename std::remove_reference<WeightsType>::type>::value>*
+                 std::remove_reference_t<WeightsType>>::value>*
                   = 0);
 ```
 
diff --git a/src/mlpack/bindings/R/default_param.hpp b/src/mlpack/bindings/R/default_param.hpp
index 1b39120275..1e05baf21e 100644
--- a/src/mlpack/bindings/R/default_param.hpp
+++ b/src/mlpack/bindings/R/default_param.hpp
@@ -26,13 +26,13 @@ namespace r {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::string>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::string>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return the default value of a vector option.
@@ -40,7 +40,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return the default value of a string option.
@@ -48,8 +48,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value
-        >::type* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>
+        >* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -59,10 +59,10 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* /* junk */ = 0);
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* /* junk */ = 0);
 
 /**
  * Return the default value of a model option (this returns the default
@@ -71,8 +71,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Return the default value of an option.  This is the function that will be
@@ -84,7 +84,7 @@ void DefaultParam(util::ParamData& data,
                   void* output)
 {
   std::string* outstr = (std::string*) output;
-  *outstr = DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+  *outstr = DefaultParamImpl<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace r
diff --git a/src/mlpack/bindings/R/default_param_impl.hpp b/src/mlpack/bindings/R/default_param_impl.hpp
index a69a13892f..a542cf7885 100644
--- a/src/mlpack/bindings/R/default_param_impl.hpp
+++ b/src/mlpack/bindings/R/default_param_impl.hpp
@@ -24,15 +24,15 @@ namespace r {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T, std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T, std::string>>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*)
 {
   std::ostringstream oss;
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
   {
     // If this is the verbose option, print the default that uses the global
     // package option.
@@ -58,13 +58,13 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
   // Print each element in an array delimited by square brackets.
   std::ostringstream oss;
   const T& vector = std::any_cast<T>(data.value);
   oss << "c(";
-  if (std::is_same<T, std::vector<std::string>>::value)
+  if (std::is_same_v<T, std::vector<std::string>>)
   {
     if (vector.size() > 0)
     {
@@ -101,7 +101,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T, std::string>>*)
 {
   const std::string& s = *std::any_cast<std::string>(&data.value);
   return "\"" + s + "\"";
@@ -114,21 +114,21 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* /* junk */)
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* /* junk */)
 {
   // Get the filename and return it, or return an empty string.
-  if (std::is_same<T, arma::rowvec>::value ||
-      std::is_same<T, arma::vec>::value ||
-      std::is_same<T, arma::mat>::value)
+  if (std::is_same_v<T, arma::rowvec> ||
+      std::is_same_v<T, arma::vec> ||
+      std::is_same_v<T, arma::mat>)
   {
     return "matrix(numeric(), 0, 0)";
   }
-  else if (std::is_same<T, arma::Row<size_t>>::value ||
-      std::is_same<T, arma::Col<size_t>>::value ||
-      std::is_same<T, arma::Mat<size_t>>::value)
+  else if (std::is_same_v<T, arma::Row<size_t>> ||
+      std::is_same_v<T, arma::Col<size_t>> ||
+      std::is_same_v<T, arma::Mat<size_t>>)
   {
     return "matrix(integer(), 0, 0)";
   }
@@ -144,8 +144,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "NA";
 }
diff --git a/src/mlpack/bindings/R/get_printable_param.hpp b/src/mlpack/bindings/R/get_printable_param.hpp
index e1857855ba..e644113114 100644
--- a/src/mlpack/bindings/R/get_printable_param.hpp
+++ b/src/mlpack/bindings/R/get_printable_param.hpp
@@ -25,11 +25,11 @@ namespace r {
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   std::ostringstream oss;
   oss << std::any_cast<T>(data.value);
@@ -42,7 +42,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   const T& t = std::any_cast<T>(data.value);
 
@@ -58,7 +58,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Get the matrix.
   const T& matrix = std::any_cast<T>(data.value);
@@ -74,8 +74,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   std::ostringstream oss;
   oss << data.cppType << " model at " << std::any_cast<T*>(data.value);
@@ -88,8 +88,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // Get the matrix.
   const T& tuple = std::any_cast<T>(data.value);
@@ -116,7 +116,7 @@ void GetPrintableParam(util::ParamData& data,
                        void* output)
 {
   *((std::string*) output) =
-      GetPrintableParam<typename std::remove_pointer<T>::type>(data);
+      GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace r
diff --git a/src/mlpack/bindings/R/get_printable_type.hpp b/src/mlpack/bindings/R/get_printable_type.hpp
index 6ca4932fe1..72e9d0c5cf 100644
--- a/src/mlpack/bindings/R/get_printable_type.hpp
+++ b/src/mlpack/bindings/R/get_printable_type.hpp
@@ -23,88 +23,88 @@ namespace r {
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<>
 inline std::string GetPrintableType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<
-        !std::is_same<std::string,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<
+        !std::is_same_v<std::string,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<size_t>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<size_t>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<size_t>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<size_t>::value>::type*,
-    const typename std::enable_if<!std::is_same<size_t,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<size_t>::value>*,
+    const std::enable_if_t<!data::HasSerialize<size_t>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<size_t>::value>*,
+    const std::enable_if_t<!std::is_same_v<size_t,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 void GetPrintableType(util::ParamData& d,
@@ -112,7 +112,7 @@ void GetPrintableType(util::ParamData& d,
                       void* output)
 {
   *((std::string*) output) =
-      GetPrintableType<typename std::remove_pointer<T>::type>(d);
+      GetPrintableType<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace r
diff --git a/src/mlpack/bindings/R/get_printable_type_impl.hpp b/src/mlpack/bindings/R/get_printable_type_impl.hpp
index 5dea060aad..0f388103c8 100644
--- a/src/mlpack/bindings/R/get_printable_type_impl.hpp
+++ b/src/mlpack/bindings/R/get_printable_type_impl.hpp
@@ -22,11 +22,11 @@ namespace r {
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "unknown";
 }
@@ -34,11 +34,11 @@ inline std::string GetPrintableType(
 template<>
 inline std::string GetPrintableType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "integer";
 }
@@ -46,11 +46,11 @@ inline std::string GetPrintableType<int>(
 template<>
 inline std::string GetPrintableType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "numeric";
 }
@@ -58,15 +58,15 @@ inline std::string GetPrintableType<double>(
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<
-        !std::is_same<std::string,
-         std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<
+        !std::is_same_v<std::string,
+         std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "character";
 }
@@ -74,11 +74,11 @@ inline std::string GetPrintableType<std::string>(
 template<>
 inline std::string GetPrintableType<size_t>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<size_t>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<size_t>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<size_t>::value>::type*,
-    const typename std::enable_if<!std::is_same<size_t,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<size_t>::value>*,
+    const std::enable_if_t<!data::HasSerialize<size_t>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<size_t>::value>*,
+    const std::enable_if_t<!std::is_same_v<size_t,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "integer";
 }
@@ -86,11 +86,11 @@ inline std::string GetPrintableType<size_t>(
 template<>
 inline std::string GetPrintableType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "logical";
 }
@@ -98,9 +98,9 @@ inline std::string GetPrintableType<bool>(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "vector of " + GetPrintableType<typename T::value_type>(d) + "s";
 }
@@ -108,17 +108,17 @@ inline std::string GetPrintableType(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::string type = "numeric matrix";
-  if (std::is_same<typename T::elem_type, double>::value)
+  if (std::is_same_v<typename T::elem_type, double>)
   {
     if (T::is_row || T::is_col)
       type = "numeric vector";
   }
-  else if (std::is_same<typename T::elem_type, size_t>::value)
+  else if (std::is_same_v<typename T::elem_type, size_t>)
   {
     type = "integer matrix";
     if (T::is_row || T::is_col)
@@ -131,8 +131,8 @@ inline std::string GetPrintableType(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "categorical matrix/data.frame";
 }
@@ -140,10 +140,10 @@ inline std::string GetPrintableType(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::string type = util::StripType(d.cppType);
   if (type == "mlpackModel")
diff --git a/src/mlpack/bindings/R/get_r_type.hpp b/src/mlpack/bindings/R/get_r_type.hpp
index 3e92bb717d..fe8c3dd7e8 100644
--- a/src/mlpack/bindings/R/get_r_type.hpp
+++ b/src/mlpack/bindings/R/get_r_type.hpp
@@ -23,11 +23,11 @@ namespace r {
 template<typename T>
 inline std::string GetRType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   return "unknown";
 }
@@ -35,11 +35,11 @@ inline std::string GetRType(
 template<>
 inline std::string GetRType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "logical";
 }
@@ -47,11 +47,11 @@ inline std::string GetRType<bool>(
 template<>
 inline std::string GetRType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "integer";
 }
@@ -59,11 +59,11 @@ inline std::string GetRType<int>(
 template<>
 inline std::string GetRType<size_t>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<size_t>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<size_t>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<size_t>::value>::type*,
-    const typename std::enable_if<!std::is_same<size_t,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<size_t>::value>*,
+    const std::enable_if_t<!data::HasSerialize<size_t>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<size_t>::value>*,
+    const std::enable_if_t<!std::is_same_v<size_t,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "integer";
 }
@@ -71,11 +71,11 @@ inline std::string GetRType<size_t>(
 template<>
 inline std::string GetRType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "numeric";
 }
@@ -83,15 +83,15 @@ inline std::string GetRType<double>(
 template<>
 inline std::string GetRType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<
-        !std::is_same<std::string,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<
+        !std::is_same_v<std::string,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "character";
 }
@@ -99,7 +99,7 @@ inline std::string GetRType<std::string>(
 template<typename T>
 inline std::string GetRType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   return GetRType<typename T::value_type>(d) + " vector";
 }
@@ -107,9 +107,9 @@ inline std::string GetRType(
 template<typename T>
 inline std::string GetRType(
     util::ParamData& d,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0,
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   std::string elemType = GetRType<typename T::elem_type>(d);
   std::string type = "matrix";
@@ -124,8 +124,8 @@ inline std::string GetRType(
 template<typename T>
 inline std::string GetRType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   return "numeric matrix/data.frame with info";
 }
@@ -133,8 +133,8 @@ inline std::string GetRType(
 template<typename T>
 inline std::string GetRType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   return util::StripType(d.cppType);
 }
diff --git a/src/mlpack/bindings/R/get_type.hpp b/src/mlpack/bindings/R/get_type.hpp
index 55264eedb5..1ef816f7bc 100644
--- a/src/mlpack/bindings/R/get_type.hpp
+++ b/src/mlpack/bindings/R/get_type.hpp
@@ -24,11 +24,11 @@ namespace r {
 template<typename T>
 inline std::string GetType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   return "unknown";
 }
@@ -36,11 +36,11 @@ inline std::string GetType(
 template<>
 inline std::string GetType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "Int";
 }
@@ -48,11 +48,11 @@ inline std::string GetType<int>(
 template<>
 inline std::string GetType<float>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<float>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<float>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<float>::value>::type*,
-    const typename std::enable_if<!std::is_same<float,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<float>::value>*,
+    const std::enable_if_t<!data::HasSerialize<float>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<float>::value>*,
+    const std::enable_if_t<!std::is_same_v<float,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "Float";
 }
@@ -60,11 +60,11 @@ inline std::string GetType<float>(
 template<>
 inline std::string GetType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "Double";
 }
@@ -72,14 +72,14 @@ inline std::string GetType<double>(
 template<>
 inline std::string GetType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<std::string,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!std::is_same_v<std::string,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "String";
 }
@@ -87,11 +87,11 @@ inline std::string GetType<std::string>(
 template<>
 inline std::string GetType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "Bool";
 }
@@ -99,9 +99,9 @@ inline std::string GetType<bool>(
 template<typename T>
 inline std::string GetType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   return "Vec" + GetType<typename T::value_type>(d);
 }
@@ -109,12 +109,12 @@ inline std::string GetType(
 template<typename T>
 inline std::string GetType(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   std::string type = "";
-  if (std::is_same<typename T::elem_type, double>::value)
+  if (std::is_same_v<typename T::elem_type, double>)
   {
     if (T::is_row)
       type = "Row";
@@ -123,7 +123,7 @@ inline std::string GetType(
     else
       type = "Mat";
   }
-  else if (std::is_same<typename T::elem_type, size_t>::value)
+  else if (std::is_same_v<typename T::elem_type, size_t>)
   {
     if (T::is_row)
       type = "URow";
@@ -139,8 +139,8 @@ inline std::string GetType(
 template<typename T>
 inline std::string GetType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   return "MatWithInfo";
 }
@@ -148,8 +148,8 @@ inline std::string GetType(
 template<typename T>
 inline std::string GetType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   return d.cppType;
 }
@@ -170,7 +170,7 @@ void GetType(util::ParamData& d,
              void* output)
 {
   *((std::string*) output) =
-      GetType<typename std::remove_pointer<T>::type>(d);
+      GetType<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace r
diff --git a/src/mlpack/bindings/R/print_doc.hpp b/src/mlpack/bindings/R/print_doc.hpp
index 9acdb03dcf..5dc2ea65a7 100644
--- a/src/mlpack/bindings/R/print_doc.hpp
+++ b/src/mlpack/bindings/R/print_doc.hpp
@@ -82,7 +82,7 @@ void PrintDoc(util::ParamData& d,
     }
   }
 
-  oss << " (" << GetRType<typename std::remove_pointer<T>::type>(d) << ").";
+  oss << " (" << GetRType<std::remove_pointer_t<T>>(d) << ").";
 
   if (out)
     oss << "}";
diff --git a/src/mlpack/bindings/R/print_input_param.hpp b/src/mlpack/bindings/R/print_input_param.hpp
index 4af58ca80c..d56af209c1 100644
--- a/src/mlpack/bindings/R/print_input_param.hpp
+++ b/src/mlpack/bindings/R/print_input_param.hpp
@@ -29,7 +29,7 @@ void PrintInputParam(util::ParamData& d,
                      void* /* output */)
 {
   MLPACK_COUT_STREAM << d.name;
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
   {
     if (d.name == "verbose")
     {
diff --git a/src/mlpack/bindings/R/print_input_processing.hpp b/src/mlpack/bindings/R/print_input_processing.hpp
index 40a073c970..49ce8de9be 100644
--- a/src/mlpack/bindings/R/print_input_processing.hpp
+++ b/src/mlpack/bindings/R/print_input_processing.hpp
@@ -26,10 +26,10 @@ namespace r {
 template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   if (!d.required)
   {
@@ -72,7 +72,7 @@ void PrintInputProcessing(
 template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   std::string extraTransStr = "";
   if (d.cppType == "arma::mat")
@@ -135,8 +135,8 @@ void PrintInputProcessing(
 template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   if (!d.required)
   {
@@ -182,8 +182,8 @@ void PrintInputProcessing(
 template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   if (!d.required)
   {
@@ -229,7 +229,7 @@ void PrintInputProcessing(util::ParamData& d,
                           const void* /* input */,
                           void* /* output */)
 {
-  PrintInputProcessing<typename std::remove_pointer<T>::type>(d);
+  PrintInputProcessing<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace r
diff --git a/src/mlpack/bindings/R/print_output_processing.hpp b/src/mlpack/bindings/R/print_output_processing.hpp
index ad06ba31f1..df64d2451d 100644
--- a/src/mlpack/bindings/R/print_output_processing.hpp
+++ b/src/mlpack/bindings/R/print_output_processing.hpp
@@ -26,10 +26,10 @@ namespace r {
 template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   /**
    * This gives us code like:
@@ -48,9 +48,9 @@ void PrintOutputProcessing(
 template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   /**
    * This gives us code like:
@@ -69,8 +69,8 @@ void PrintOutputProcessing(
 template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   /**
    * This gives us code like:
@@ -89,8 +89,8 @@ void PrintOutputProcessing(
 template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   /**
    * This gives us code like:
@@ -112,7 +112,7 @@ void PrintOutputProcessing(util::ParamData& d,
                            const void* /*input*/,
                            void* /* output */)
 {
-  PrintOutputProcessing<typename std::remove_pointer<T>::type>(d);
+  PrintOutputProcessing<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace r
diff --git a/src/mlpack/bindings/R/print_serialize_util.hpp b/src/mlpack/bindings/R/print_serialize_util.hpp
index 362adbfe34..4a44781061 100644
--- a/src/mlpack/bindings/R/print_serialize_util.hpp
+++ b/src/mlpack/bindings/R/print_serialize_util.hpp
@@ -25,8 +25,8 @@ namespace r {
 template<typename T>
 void PrintSerializeUtil(
     util::ParamData& /* d */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0)
 {
   // Do Nothing.
 }
@@ -37,7 +37,7 @@ void PrintSerializeUtil(
 template<typename T>
 void PrintSerializeUtil(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Do Nothing.
 }
@@ -48,8 +48,8 @@ void PrintSerializeUtil(
 template<typename T>
 void PrintSerializeUtil(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   /**
    * This gives us code like:
@@ -76,7 +76,7 @@ void PrintSerializeUtil(util::ParamData& d,
                         const void* /*input*/,
                         void* /* output */)
 {
-  PrintSerializeUtil<typename std::remove_pointer<T>::type>(d);
+  PrintSerializeUtil<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace r
diff --git a/src/mlpack/bindings/R/print_type_doc.hpp b/src/mlpack/bindings/R/print_type_doc.hpp
index 5f0253578b..9925372eee 100644
--- a/src/mlpack/bindings/R/print_type_doc.hpp
+++ b/src/mlpack/bindings/R/print_type_doc.hpp
@@ -25,11 +25,11 @@ namespace r {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a vector.
@@ -37,7 +37,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix option.
@@ -45,7 +45,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix tuple option.
@@ -53,8 +53,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a model.
@@ -62,8 +62,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Print the command-line type of an option into a string.
@@ -74,7 +74,7 @@ void PrintTypeDoc(util::ParamData& data,
                   void* output)
 {
   *((std::string*) output) =
-      PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+      PrintTypeDoc<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace r
diff --git a/src/mlpack/bindings/R/print_type_doc_impl.hpp b/src/mlpack/bindings/R/print_type_doc_impl.hpp
index bc8ba85f25..a5f837a811 100644
--- a/src/mlpack/bindings/R/print_type_doc_impl.hpp
+++ b/src/mlpack/bindings/R/print_type_doc_impl.hpp
@@ -24,29 +24,29 @@ namespace r {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   // A flag type.
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
   {
     return "A boolean flag option (i.e. `TRUE` or `FALSE`).";
   }
   // An integer.
-  else if (std::is_same<T, int>::value)
+  else if (std::is_same_v<T, int>)
   {
     return "An integer (i.e., `1`).";
   }
   // A floating point value.
-  else if (std::is_same<T, double>::value)
+  else if (std::is_same_v<T, double>)
   {
     return "A floating-point number (i.e., `0.5`).";
   }
   // A string.
-  else if (std::is_same<T, std::string>::value)
+  else if (std::is_same_v<T, std::string>)
   {
     return "A character string (i.e., `\"hello\"`).";
   }
@@ -64,13 +64,13 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
-  if (std::is_same<T, std::vector<int>>::value)
+  if (std::is_same_v<T, std::vector<int>>)
   {
     return "A vector of integers; i.e., `c(0, 1, 2)`.";
   }
-  else if (std::is_same<T, std::vector<std::string>>::value)
+  else if (std::is_same_v<T, std::vector<std::string>>)
   {
     return "A vector of strings; i.e., `c(\"hello\", \"goodbye\")`.";
   }
@@ -86,9 +86,9 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
-  if (std::is_same<typename T::elem_type, double>::value)
+  if (std::is_same_v<typename T::elem_type, double>)
   {
     if (T::is_col || T::is_row)
     {
@@ -102,7 +102,7 @@ std::string PrintTypeDoc(
           "2-d `matrix`).";
     }
   }
-  else if (std::is_same<typename T::elem_type, size_t>::value)
+  else if (std::is_same_v<typename T::elem_type, size_t>)
   {
     if (T::is_col || T::is_row)
     {
@@ -128,8 +128,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "A 2-d array containing `numeric` data.  Like the regular 2-d matrices"
       ", this can be a `matrix`, or a `data.frame`. However, this type can also"
@@ -146,8 +146,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "An mlpack model pointer.  `<Model>` refers to the type of model that "
       "is being stored, so, e.g., for `cf()`, the type will be `CFModel`. "
diff --git a/src/mlpack/bindings/cli/add_to_cli11.hpp b/src/mlpack/bindings/cli/add_to_cli11.hpp
index c9b0e87bae..5bbb3eff9d 100644
--- a/src/mlpack/bindings/cli/add_to_cli11.hpp
+++ b/src/mlpack/bindings/cli/add_to_cli11.hpp
@@ -33,15 +33,15 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const typename std::enable_if<!std::is_same<T,
-                    bool>::value>::type* = 0,
-                const typename std::enable_if<!
-                    arma::is_arma_type<T>::value>::type* = 0,
-                const typename std::enable_if<!
-                    data::HasSerialize<T>::value>::type* = 0,
-                const typename std::enable_if<std::is_same<T,
+                const std::enable_if_t<!std::is_same_v<T,
+                    bool>>* = 0,
+                const std::enable_if_t<!
+                    arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<!
+                    data::HasSerialize<T>::value>* = 0,
+                const std::enable_if_t<std::is_same_v<T,
                     std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>::value>::type* = 0)
+                    arma::mat>>>* = 0)
 {
   app.add_option_function<std::string>(cliName.c_str(),
       [&param](const std::string& value)
@@ -65,15 +65,15 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const typename std::enable_if<!std::is_same<T,
-                    bool>::value>::type* = 0,
-                const typename std::enable_if<!
-                    arma::is_arma_type<T>::value>::type* = 0,
-                const typename std::enable_if<
-                    data::HasSerialize<T>::value>::type* = 0,
-                const typename std::enable_if<!std::is_same<T,
+                const std::enable_if_t<!std::is_same_v<T,
+                    bool>>* = 0,
+                const std::enable_if_t<!
+                    arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<
+                    data::HasSerialize<T>::value>* = 0,
+                const std::enable_if_t<!std::is_same_v<T,
                     std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>::value>::type* = 0)
+                    arma::mat>>>* = 0)
 {
   app.add_option_function<std::string>(cliName.c_str(),
       [&param](const std::string& value)
@@ -97,13 +97,13 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const typename std::enable_if<!
-                    std::is_same<T, bool>::value>::type* = 0,
-                const typename std::enable_if<
-                    arma::is_arma_type<T>::value>::type* = 0,
-                const typename std::enable_if<!std::is_same<T,
+                const std::enable_if_t<!
+                    std::is_same_v<T, bool>>* = 0,
+                const std::enable_if_t<
+                    arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<!std::is_same_v<T,
                   std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>::value>::type* = 0)
+                    arma::mat>>>* = 0)
 {
   app.add_option_function<std::string>(cliName.c_str(),
       [&param](const std::string& value)
@@ -127,15 +127,15 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const typename std::enable_if<!
-                    std::is_same<T, bool>::value>::type* = 0,
-                const typename std::enable_if<!
-                    arma::is_arma_type<T>::value>::type* = 0,
-                const typename std::enable_if<!
-                    data::HasSerialize<T>::value>::type* = 0,
-                const typename std::enable_if<!std::is_same<T,
+                const std::enable_if_t<!
+                    std::is_same_v<T, bool>>* = 0,
+                const std::enable_if_t<!
+                    arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<!
+                    data::HasSerialize<T>::value>* = 0,
+                const std::enable_if_t<!std::is_same_v<T,
                     std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>::value>::type* = 0)
+                    arma::mat>>>* = 0)
 {
   app.add_option_function<T>(cliName.c_str(),
       [&param](const T& value)
@@ -157,15 +157,15 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const typename std::enable_if<
-                    std::is_same<T, bool>::value>::type* = 0,
-                const typename std::enable_if<!
-                    arma::is_arma_type<T>::value>::type* = 0,
-                const typename std::enable_if<!
-                    data::HasSerialize<T>::value>::type* = 0,
-                const typename std::enable_if<!std::is_same<T,
+                const std::enable_if_t<
+                    std::is_same_v<T, bool>>* = 0,
+                const std::enable_if_t<!
+                    arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<!
+                    data::HasSerialize<T>::value>* = 0,
+                const std::enable_if_t<!std::is_same_v<T,
                     std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>::value>::type* = 0)
+                    arma::mat>>>* = 0)
 {
   app.add_flag_function(cliName.c_str(),
       [&param](const T& value)
@@ -194,14 +194,14 @@ void AddToCLI11(util::ParamData& param,
 
   // Generate the name to be given to CLI11.
   const std::string mappedName =
-      MapParameterName<typename std::remove_pointer<T>::type>(param.name);
+      MapParameterName<std::remove_pointer_t<T>>(param.name);
   std::string cliName = (param.alias != '\0') ?
       "-" + std::string(1, param.alias) + ",--" + mappedName :
       "--" + mappedName;
 
   // Note that we have to add the option as type equal to the mapped type, not
   // the true type of the option.
-  AddToCLI11<typename std::remove_pointer<T>::type>(
+  AddToCLI11<std::remove_pointer_t<T>>(
       cliName, param, *app);
 }
 
diff --git a/src/mlpack/bindings/cli/cli_option.hpp b/src/mlpack/bindings/cli/cli_option.hpp
index 52c41474ce..a1c1032be5 100644
--- a/src/mlpack/bindings/cli/cli_option.hpp
+++ b/src/mlpack/bindings/cli/cli_option.hpp
@@ -91,21 +91,21 @@ class CLIOption
     data.cppType = cppName;
 
     // Apply default value.
-    if (std::is_same<typename std::remove_pointer<N>::type,
-                     typename ParameterType<typename
-                         std::remove_pointer<N>::type>::type>::value)
+    if (std::is_same_v<std::remove_pointer_t<N>,
+                     typename ParameterType<
+                         std::remove_pointer_t<N>>::type>)
     {
       data.value = defaultValue;
     }
     else
     {
-      typename ParameterType<typename std::remove_pointer<N>::type>::type tmp;
+      typename ParameterType<std::remove_pointer_t<N>>::type tmp;
       data.value = std::tuple<N, decltype(tmp)>(defaultValue, tmp);
     }
 
     const std::string tname = data.tname;
     const std::string cliName = MapParameterName<
-        typename std::remove_pointer<N>::type>(identifier);
+        std::remove_pointer_t<N>>(identifier);
     std::string progOptId = (alias[0] != '\0') ?
         "-" + std::string(1, alias[0]) + ",--" + cliName : "--" + cliName;
 
diff --git a/src/mlpack/bindings/cli/default_param.hpp b/src/mlpack/bindings/cli/default_param.hpp
index f8d97bdc1c..256afdbc51 100644
--- a/src/mlpack/bindings/cli/default_param.hpp
+++ b/src/mlpack/bindings/cli/default_param.hpp
@@ -26,13 +26,13 @@ namespace cli {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::string>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::string>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return the default value of a vector option.
@@ -40,7 +40,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return the default value of a string option.
@@ -48,8 +48,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value
-        >::type* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>
+        >* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -59,10 +59,10 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* /* junk */ = 0);
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* /* junk */ = 0);
 
 /**
  * Return the default value of a model option (this returns the default
@@ -71,8 +71,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Return the default value of an option.  This is the function that will be
@@ -84,7 +84,7 @@ void DefaultParam(util::ParamData& data,
                   void* output)
 {
   std::string* outstr = (std::string*) output;
-  *outstr = DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+  *outstr = DefaultParamImpl<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/default_param_impl.hpp b/src/mlpack/bindings/cli/default_param_impl.hpp
index 498f950ff8..d7e0506d1e 100644
--- a/src/mlpack/bindings/cli/default_param_impl.hpp
+++ b/src/mlpack/bindings/cli/default_param_impl.hpp
@@ -24,16 +24,16 @@ namespace cli {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::string>>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*)
 {
   std::ostringstream oss;
-  if (!std::is_same<T, bool>::value)
+  if (!std::is_same_v<T, bool>)
     oss << std::any_cast<T>(data.value);
 
   return oss.str();
@@ -45,13 +45,13 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
   // Print each element in an array delimited by square brackets.
   std::ostringstream oss;
   const T& vector = std::any_cast<T>(data.value);
   oss << "[";
-  if (std::is_same<T, std::vector<std::string>>::value)
+  if (std::is_same_v<T, std::vector<std::string>>)
   {
     if (vector.size() > 0)
     {
@@ -89,7 +89,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T, std::string>>*)
 {
   const std::string& s = *std::any_cast<std::string>(&data.value);
   return "'" + s + "'";
@@ -101,10 +101,10 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* /* junk */)
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* /* junk */)
 {
   // The filename will always be empty.
   return "''";
@@ -116,8 +116,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "''";
 }
diff --git a/src/mlpack/bindings/cli/delete_allocated_memory.hpp b/src/mlpack/bindings/cli/delete_allocated_memory.hpp
index d6c8c2f814..d73715fa59 100644
--- a/src/mlpack/bindings/cli/delete_allocated_memory.hpp
+++ b/src/mlpack/bindings/cli/delete_allocated_memory.hpp
@@ -21,8 +21,8 @@ namespace cli {
 template<typename T>
 void DeleteAllocatedMemoryImpl(
     util::ParamData& /* d */,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0)
 {
   // Do nothing.
 }
@@ -30,7 +30,7 @@ void DeleteAllocatedMemoryImpl(
 template<typename T>
 void DeleteAllocatedMemoryImpl(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Do nothing.
 }
@@ -38,8 +38,8 @@ void DeleteAllocatedMemoryImpl(
 template<typename T>
 void DeleteAllocatedMemoryImpl(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Delete the allocated memory (hopefully we actually own it).
   typedef std::tuple<T*, std::string> TupleType;
@@ -52,7 +52,7 @@ void DeleteAllocatedMemory(
     const void* /* input */,
     void* /* output */)
 {
-  DeleteAllocatedMemoryImpl<typename std::remove_pointer<T>::type>(d);
+  DeleteAllocatedMemoryImpl<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/get_allocated_memory.hpp b/src/mlpack/bindings/cli/get_allocated_memory.hpp
index 426cf350cb..989dab1535 100644
--- a/src/mlpack/bindings/cli/get_allocated_memory.hpp
+++ b/src/mlpack/bindings/cli/get_allocated_memory.hpp
@@ -22,8 +22,8 @@ namespace cli {
 template<typename T>
 void* GetAllocatedMemory(
     util::ParamData& /* d */,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0)
 {
   return NULL;
 }
@@ -31,7 +31,7 @@ void* GetAllocatedMemory(
 template<typename T>
 void* GetAllocatedMemory(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   return NULL;
 }
@@ -39,8 +39,8 @@ void* GetAllocatedMemory(
 template<typename T>
 void* GetAllocatedMemory(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Here we have a model, which is a tuple, and we need the address of the
   // memory.
@@ -54,7 +54,7 @@ void GetAllocatedMemory(util::ParamData& d,
                         void* output)
 {
   *((void**) output) =
-      GetAllocatedMemory<typename std::remove_pointer<T>::type>(d);
+      GetAllocatedMemory<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/get_param.hpp b/src/mlpack/bindings/cli/get_param.hpp
index 528f0f8753..a768a2902a 100644
--- a/src/mlpack/bindings/cli/get_param.hpp
+++ b/src/mlpack/bindings/cli/get_param.hpp
@@ -28,10 +28,10 @@ namespace cli {
 template<typename T>
 T& GetParam(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0)
 {
   // No mapping is needed, so just cast it directly.
   return *std::any_cast<T>(&d.value);
@@ -45,7 +45,7 @@ T& GetParam(
 template<typename T>
 T& GetParam(
     util::ParamData& d,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // If the matrix is an input matrix, we have to load the matrix.  'value'
   // contains the filename.  It's possible we could load empty matrices many
@@ -80,8 +80,8 @@ T& GetParam(
 template<typename T>
 T& GetParam(
     util::ParamData& d,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0)
 {
   // If this is an input parameter, we need to load both the matrix and the
   // dataset info.
@@ -110,8 +110,8 @@ T& GetParam(
 template<typename T>
 T*& GetParam(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // If the model is an input model, we have to load it from file.  'value'
   // contains the filename.
@@ -140,7 +140,7 @@ template<typename T>
 void GetParam(util::ParamData& d, const void* /* input */, void* output)
 {
   // Cast to the correct type.
-  *((T**) output) = &GetParam<typename std::remove_pointer<T>::type>(d);
+  *((T**) output) = &GetParam<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/get_printable_param.hpp b/src/mlpack/bindings/cli/get_printable_param.hpp
index 2cd2221101..bffe499f37 100644
--- a/src/mlpack/bindings/cli/get_printable_param.hpp
+++ b/src/mlpack/bindings/cli/get_printable_param.hpp
@@ -27,11 +27,11 @@ namespace cli {
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print a vector option, with spaces between it.
@@ -39,7 +39,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Print a matrix/tuple option (this just prints the filename).
@@ -47,9 +47,9 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value ||
-                                  std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value ||
+                                  std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print a model option (this just prints the filename).
@@ -57,8 +57,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Print an option into a std::string.  This should print a short, one-line
@@ -71,7 +71,7 @@ void GetPrintableParam(util::ParamData& data,
                        void* output)
 {
   *((std::string*) output) =
-      GetPrintableParam<typename std::remove_pointer<T>::type>(data);
+      GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/get_printable_param_impl.hpp b/src/mlpack/bindings/cli/get_printable_param_impl.hpp
index 6e7ae18c42..d9dadfecde 100644
--- a/src/mlpack/bindings/cli/get_printable_param_impl.hpp
+++ b/src/mlpack/bindings/cli/get_printable_param_impl.hpp
@@ -23,11 +23,11 @@ namespace cli {
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::ostringstream oss;
   oss << std::any_cast<T>(data.value);
@@ -38,7 +38,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*
+    const std::enable_if_t<util::IsStdVector<T>::value>*
         /* junk */)
 {
   const T& t = std::any_cast<T>(data.value);
@@ -53,7 +53,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetMatrixSize(
     T& matrix,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   std::ostringstream oss;
   oss << matrix.n_rows << "x" << matrix.n_cols << " matrix";
@@ -64,8 +64,8 @@ std::string GetMatrixSize(
 template<typename T>
 std::string GetMatrixSize(
     T& matrixAndInfo,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   return GetMatrixSize(std::get<1>(matrixAndInfo));
 }
@@ -74,9 +74,9 @@ std::string GetMatrixSize(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value ||
-                                  std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* /* junk */)
+    const std::enable_if_t<arma::is_arma_type<T>::value ||
+                                  std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* /* junk */)
 {
   // Extract the string from the tuple that's being held.
   typedef std::tuple<T, typename ParameterType<T>::type> TupleType;
@@ -103,8 +103,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   // Extract the string from the tuple that's being held.
   typedef std::tuple<T*, typename ParameterType<T>::type> TupleType;
diff --git a/src/mlpack/bindings/cli/get_printable_param_name.hpp b/src/mlpack/bindings/cli/get_printable_param_name.hpp
index b875d2f72d..f5619ca377 100644
--- a/src/mlpack/bindings/cli/get_printable_param_name.hpp
+++ b/src/mlpack/bindings/cli/get_printable_param_name.hpp
@@ -26,10 +26,10 @@ namespace cli {
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Get the parameter name for a matrix type (where the user has to pass the file
@@ -38,7 +38,7 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Get the parameter name for a serializable model type (where the user has to
@@ -47,8 +47,8 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Get the parameter name for a mapped matrix type (where the user has to pass
@@ -57,8 +57,8 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Get the parameter's name as seen by the user.
@@ -70,7 +70,7 @@ void GetPrintableParamName(
     void* output)
 {
   *((std::string*) output) =
-      GetPrintableParamName<typename std::remove_pointer<T>::type>(d);
+      GetPrintableParamName<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/get_printable_param_name_impl.hpp b/src/mlpack/bindings/cli/get_printable_param_name_impl.hpp
index 7c355c3dbc..3d21f56b2a 100644
--- a/src/mlpack/bindings/cli/get_printable_param_name_impl.hpp
+++ b/src/mlpack/bindings/cli/get_printable_param_name_impl.hpp
@@ -26,10 +26,10 @@ namespace cli {
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "--" + data.name;
 }
@@ -41,7 +41,7 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
   return "--" + data.name + "_file";
 }
@@ -53,8 +53,8 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "--" + data.name + "_file";
 }
@@ -66,8 +66,8 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "--" + data.name + "_file";
 }
diff --git a/src/mlpack/bindings/cli/get_printable_param_value.hpp b/src/mlpack/bindings/cli/get_printable_param_value.hpp
index 621640b3c1..f7be9a7b7b 100644
--- a/src/mlpack/bindings/cli/get_printable_param_value.hpp
+++ b/src/mlpack/bindings/cli/get_printable_param_value.hpp
@@ -27,10 +27,10 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& data,
     const std::string& value,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Get the parameter name for a matrix type (where the user has to pass the file
@@ -40,7 +40,7 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& data,
     const std::string& value,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Get the parameter name for a serializable model type (where the user has to
@@ -50,8 +50,8 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& data,
     const std::string& value,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Get the parameter name for a mapped matrix type (where the user has to pass
@@ -61,8 +61,8 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& data,
     const std::string& value,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Get the parameter's name as seen by the user.
@@ -74,7 +74,7 @@ void GetPrintableParamValue(
     void* output)
 {
   *((std::string*) output) =
-      GetPrintableParamValue<typename std::remove_pointer<T>::type>(d,
+      GetPrintableParamValue<std::remove_pointer_t<T>>(d,
       *((std::string*) input));
 }
 
diff --git a/src/mlpack/bindings/cli/get_printable_param_value_impl.hpp b/src/mlpack/bindings/cli/get_printable_param_value_impl.hpp
index 3bb42b01b1..96785cc5d8 100644
--- a/src/mlpack/bindings/cli/get_printable_param_value_impl.hpp
+++ b/src/mlpack/bindings/cli/get_printable_param_value_impl.hpp
@@ -28,10 +28,10 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& /* data */,
     const std::string& input,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return input;
 }
@@ -44,7 +44,7 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& /* data */,
     const std::string& input,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
   return input + ".csv";
 }
@@ -57,8 +57,8 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& /* data */,
     const std::string& input,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return input + ".bin";
 }
@@ -71,8 +71,8 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& /* data */,
     const std::string& input,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return input + ".arff";
 }
diff --git a/src/mlpack/bindings/cli/get_printable_type.hpp b/src/mlpack/bindings/cli/get_printable_type.hpp
index 07fd10609a..328e8f1055 100644
--- a/src/mlpack/bindings/cli/get_printable_type.hpp
+++ b/src/mlpack/bindings/cli/get_printable_type.hpp
@@ -23,11 +23,11 @@ namespace cli {
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a vector.
@@ -35,7 +35,7 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix option.
@@ -43,7 +43,7 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix tuple option.
@@ -51,8 +51,8 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a model.
@@ -60,8 +60,8 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Print the command-line type of an option into a string.
@@ -72,7 +72,7 @@ void GetPrintableType(util::ParamData& data,
                        void* output)
 {
   *((std::string*) output) =
-      GetPrintableType<typename std::remove_pointer<T>::type>(data);
+      GetPrintableType<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/get_printable_type_impl.hpp b/src/mlpack/bindings/cli/get_printable_type_impl.hpp
index 14a259b8b6..d3dbbf5050 100644
--- a/src/mlpack/bindings/cli/get_printable_type_impl.hpp
+++ b/src/mlpack/bindings/cli/get_printable_type_impl.hpp
@@ -25,19 +25,19 @@ namespace cli {
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     return "flag";
-  else if (std::is_same<T, int>::value)
+  else if (std::is_same_v<T, int>)
     return "int";
-  else if (std::is_same<T, double>::value)
+  else if (std::is_same_v<T, double>)
     return "double";
-  else if (std::is_same<T, std::string>::value)
+  else if (std::is_same_v<T, std::string>)
     return "string";
   else
     throw std::invalid_argument("unknown parameter type" + data.cppType);
@@ -49,11 +49,11 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
-  if (std::is_same<T, std::vector<int>>::value)
+  if (std::is_same_v<T, std::vector<int>>)
     return "int vector";
-  else if (std::is_same<T, std::vector<std::string>>::value)
+  else if (std::is_same_v<T, std::vector<std::string>>)
     return "string vector";
   else
     throw std::invalid_argument("unknown vector type " + data.cppType);
@@ -65,19 +65,19 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
-  if (std::is_same<T, arma::mat>::value)
+  if (std::is_same_v<T, arma::mat>)
     return "2-d matrix file";
-  else if (std::is_same<T, arma::Mat<size_t>>::value)
+  else if (std::is_same_v<T, arma::Mat<size_t>>)
     return "2-d index matrix file";
-  else if (std::is_same<T, arma::rowvec>::value)
+  else if (std::is_same_v<T, arma::rowvec>)
     return "1-d matrix file";
-  else if (std::is_same<T, arma::Row<size_t>>::value)
+  else if (std::is_same_v<T, arma::Row<size_t>>)
     return "1-d index matrix file";
-  else if (std::is_same<T, arma::vec>::value)
+  else if (std::is_same_v<T, arma::vec>)
     return "1-d matrix file";
-  else if (std::is_same<T, arma::Col<size_t>>::value)
+  else if (std::is_same_v<T, arma::Col<size_t>>)
     return "1-d index matrix file";
   else
     throw std::invalid_argument("unknown Armadillo type" + data.cppType);
@@ -89,8 +89,8 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& /* data */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "2-d categorical matrix file";
 }
@@ -101,8 +101,8 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return data.cppType + " file";
 }
diff --git a/src/mlpack/bindings/cli/get_raw_param.hpp b/src/mlpack/bindings/cli/get_raw_param.hpp
index 0724a542f3..acd2788e79 100644
--- a/src/mlpack/bindings/cli/get_raw_param.hpp
+++ b/src/mlpack/bindings/cli/get_raw_param.hpp
@@ -27,10 +27,10 @@ namespace cli {
 template<typename T>
 T& GetRawParam(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0)
 {
   // No mapping is needed, so just cast it directly.
   return *std::any_cast<T>(&d.value);
@@ -42,10 +42,10 @@ T& GetRawParam(
 template<typename T>
 T& GetRawParam(
     util::ParamData& d,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* = 0)
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* = 0)
 {
   // Don't load the matrix.
   typedef std::tuple<T, std::tuple<std::string, size_t, size_t>> TupleType;
@@ -59,8 +59,8 @@ T& GetRawParam(
 template<typename T>
 T*& GetRawParam(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Don't load the model.
   typedef std::tuple<T*, std::string> TupleType;
@@ -82,7 +82,7 @@ void GetRawParam(util::ParamData& d,
                  void* output)
 {
   // Cast to the correct type.
-  *((T**) output) = &GetRawParam<typename std::remove_pointer<T>::type>(
+  *((T**) output) = &GetRawParam<std::remove_pointer_t<T>>(
       const_cast<util::ParamData&>(d));
 }
 
diff --git a/src/mlpack/bindings/cli/in_place_copy.hpp b/src/mlpack/bindings/cli/in_place_copy.hpp
index 4ffbb0e03d..861e1e2729 100644
--- a/src/mlpack/bindings/cli/in_place_copy.hpp
+++ b/src/mlpack/bindings/cli/in_place_copy.hpp
@@ -31,10 +31,10 @@ template<typename T>
 void InPlaceCopyInternal(
     util::ParamData& /* d */,
     util::ParamData& /* input */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0)
 {
   // Nothing to do.
 }
@@ -50,11 +50,11 @@ template<typename T>
 void InPlaceCopyInternal(
     util::ParamData& d,
     util::ParamData& input,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T,
-                     std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value
-                 >::type* = 0)
+        std::is_same_v<T,
+                     std::tuple<mlpack::data::DatasetInfo, arma::mat>>
+                 >* = 0)
 {
   // Make the output filename the same as the input filename.
   typedef std::tuple<T, typename ParameterType<T>::type> TupleType;
@@ -76,8 +76,8 @@ template<typename T>
 void InPlaceCopyInternal(
     util::ParamData& d,
     util::ParamData& input,
-    const typename std::enable_if<
-        data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<
+        data::HasSerialize<T>::value>* = 0)
 {
   // Make the output filename the same as the input filename.
   typedef std::tuple<T*, typename ParameterType<T>::type> TupleType;
@@ -102,7 +102,7 @@ void InPlaceCopy(util::ParamData& d,
                  void* /* output */)
 {
   // Cast to the correct type.
-  InPlaceCopyInternal<typename std::remove_pointer<T>::type>(
+  InPlaceCopyInternal<std::remove_pointer_t<T>>(
       const_cast<util::ParamData&>(d), *((util::ParamData*) input));
 }
 
diff --git a/src/mlpack/bindings/cli/map_parameter_name.hpp b/src/mlpack/bindings/cli/map_parameter_name.hpp
index 74f20a6431..a4e9416b83 100644
--- a/src/mlpack/bindings/cli/map_parameter_name.hpp
+++ b/src/mlpack/bindings/cli/map_parameter_name.hpp
@@ -27,10 +27,10 @@ namespace cli {
 template<typename T>
 std::string MapParameterName(
     const std::string& identifier,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0)
 {
   return identifier;
 }
@@ -43,11 +43,11 @@ std::string MapParameterName(
 template<typename T>
 std::string MapParameterName(
     const std::string& identifier,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value ||
-        data::HasSerialize<T>::value>::type* /* junk */ = 0)
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>> ||
+        data::HasSerialize<T>::value>* /* junk */ = 0)
 {
   return identifier + "_file";
 }
@@ -67,7 +67,7 @@ void MapParameterName(util::ParamData& d,
   // Store the mapped name in the output pointer, which is actually a string
   // pointer.
   *((std::string*) output) =
-      MapParameterName<typename std::remove_pointer<T>::type>(d.name);
+      MapParameterName<std::remove_pointer_t<T>>(d.name);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/output_param.hpp b/src/mlpack/bindings/cli/output_param.hpp
index bef23ed43e..9fd335caab 100644
--- a/src/mlpack/bindings/cli/output_param.hpp
+++ b/src/mlpack/bindings/cli/output_param.hpp
@@ -26,11 +26,11 @@ namespace cli {
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Output a vector option (print to stdout).
@@ -38,7 +38,7 @@ void OutputParamImpl(
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Output a matrix option (this saves it to the given file).
@@ -46,7 +46,7 @@ void OutputParamImpl(
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Output a serializable class option (this saves it to the given file).
@@ -54,8 +54,8 @@ void OutputParamImpl(
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Output a mapped dataset.
@@ -63,8 +63,8 @@ void OutputParamImpl(
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Output an option.  This is the function that will be called by the IO
@@ -75,7 +75,7 @@ void OutputParam(util::ParamData& data,
                  const void* /* input */,
                  void* /* output */)
 {
-  OutputParamImpl<typename std::remove_pointer<T>::type>(data);
+  OutputParamImpl<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/output_param_impl.hpp b/src/mlpack/bindings/cli/output_param_impl.hpp
index 1725a2e890..0addc718b8 100644
--- a/src/mlpack/bindings/cli/output_param_impl.hpp
+++ b/src/mlpack/bindings/cli/output_param_impl.hpp
@@ -24,11 +24,11 @@ namespace cli {
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::cout << data.name << ": " << *std::any_cast<T>(&data.value)
       << std::endl;
@@ -38,7 +38,7 @@ void OutputParamImpl(
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
   std::cout << data.name << ": ";
   const T& t = *std::any_cast<T>(&data.value);
@@ -51,7 +51,7 @@ void OutputParamImpl(
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
   typedef std::tuple<T, std::tuple<std::string, size_t, size_t>> TupleType;
   const T& output = std::get<0>(*std::any_cast<TupleType>(&data.value));
@@ -71,8 +71,8 @@ void OutputParamImpl(
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   // The const cast is necessary here because Serialize() can't ever be marked
   // const.  In this case we can assume it though, since we will be saving and
@@ -91,8 +91,8 @@ void OutputParamImpl(
 template<typename T>
 void OutputParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* /* junk */)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* /* junk */)
 {
   // Output the matrix with the mappings.
   typedef std::tuple<T, std::tuple<std::string, size_t, size_t>> TupleType;
diff --git a/src/mlpack/bindings/cli/print_type_doc.hpp b/src/mlpack/bindings/cli/print_type_doc.hpp
index 10acab4f5b..52b4e01f6e 100644
--- a/src/mlpack/bindings/cli/print_type_doc.hpp
+++ b/src/mlpack/bindings/cli/print_type_doc.hpp
@@ -25,11 +25,11 @@ namespace cli {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a vector.
@@ -37,7 +37,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix option.
@@ -45,7 +45,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix tuple option.
@@ -53,8 +53,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a model.
@@ -62,8 +62,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Print the command-line type of an option into a string.
@@ -74,7 +74,7 @@ void PrintTypeDoc(util::ParamData& data,
                   void* output)
 {
   *((std::string*) output) =
-      PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+      PrintTypeDoc<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/print_type_doc_impl.hpp b/src/mlpack/bindings/cli/print_type_doc_impl.hpp
index 1836732bf8..8a95d8666f 100644
--- a/src/mlpack/bindings/cli/print_type_doc_impl.hpp
+++ b/src/mlpack/bindings/cli/print_type_doc_impl.hpp
@@ -24,30 +24,30 @@ namespace cli {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   // A flag type.
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
   {
     return "A boolean flag option.  If not specified, it is false; if "
         "specified, it is true.";
   }
   // An integer.
-  else if (std::is_same<T, int>::value)
+  else if (std::is_same_v<T, int>)
   {
     return "An integer (i.e., \"1\").";
   }
   // A floating point value.
-  else if (std::is_same<T, double>::value)
+  else if (std::is_same_v<T, double>)
   {
     return "A floating-point number (i.e., \"0.5\").";
   }
   // A string.
-  else if (std::is_same<T, std::string>::value)
+  else if (std::is_same_v<T, std::string>)
   {
     return "A character string (i.e., \"hello\").";
   }
@@ -64,13 +64,13 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
-  if (std::is_same<T, std::vector<int>>::value)
+  if (std::is_same_v<T, std::vector<int>>)
   {
     return "A vector of integers, separated by commas (i.e., \"1,2,3\").";
   }
-  else if (std::is_same<T, std::vector<std::string>>::value)
+  else if (std::is_same_v<T, std::vector<std::string>>)
   {
     return "A vector of strings, separated by commas (i.e., "
         "\"hello\",\"goodbye\").";
@@ -87,9 +87,9 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
-  if (std::is_same<T, arma::mat>::value)
+  if (std::is_same_v<T, arma::mat>)
   {
     return "A data matrix filename.  The file can be CSV (.csv), TSV (.csv), "
         "ASCII (space-separated values, .txt), Armadillo ASCII (.txt), PGM "
@@ -102,7 +102,7 @@ std::string PrintTypeDoc(
         "is found, the first row will be loaded as a data point.  All values of"
         " the matrix will be loaded as double-precision floating point data.";
   }
-  else if (std::is_same<T, arma::Mat<size_t>>::value)
+  else if (std::is_same_v<T, arma::Mat<size_t>>)
   {
     return "A data matrix filename, where the matrix holds only non-negative "
         "integer values.  This type is often used for labels or indices.  The "
@@ -117,15 +117,15 @@ std::string PrintTypeDoc(
         " loaded as a data point.  All values of the matrix will be loaded as "
         "unsigned integers.";
   }
-  else if (std::is_same<T, arma::rowvec>::value ||
-           std::is_same<T, arma::vec>::value)
+  else if (std::is_same_v<T, arma::rowvec> ||
+           std::is_same_v<T, arma::vec>)
   {
     return "A one-dimensional vector filename.  This file can take the same "
         "formats as the data matrix filenames; however, it must either contain "
         "one row and many columns, or one column and many rows.";
   }
-  else if (std::is_same<T, arma::Row<size_t>>::value ||
-           std::is_same<T, arma::Col<size_t>>::value)
+  else if (std::is_same_v<T, arma::Row<size_t>> ||
+           std::is_same_v<T, arma::Col<size_t>>)
   {
     return "A one-dimensional vector filename, where the matrix holds only non-"
         "negative integer values.  This type is typically used for labels or "
@@ -145,8 +145,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "A filename for a data matrix that can contain categorical "
       "(non-numeric) data.  If the file contains only numeric data, then the "
@@ -165,8 +165,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "A filename containing an mlpack model.  These can have one of three "
       "formats: binary (.bin), text (.txt), and XML (.xml).  The XML format "
diff --git a/src/mlpack/bindings/cli/set_param.hpp b/src/mlpack/bindings/cli/set_param.hpp
index df2fb85bcd..6ff35afb80 100644
--- a/src/mlpack/bindings/cli/set_param.hpp
+++ b/src/mlpack/bindings/cli/set_param.hpp
@@ -27,11 +27,11 @@ template<typename T>
 void SetParam(
     util::ParamData& d,
     const std::any& value,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T, bool>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T, bool>>* = 0)
 {
   // No mapping is needed.
   d.value = *std::any_cast<T>(&value);
@@ -44,7 +44,7 @@ template<typename T>
 void SetParam(
     util::ParamData& d,
     const std::any& /* value */,
-    const typename std::enable_if<std::is_same<T, bool>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T, bool>>* = 0)
 {
   // Force set to the value of whether or not this was passed.
   d.value = d.wasPassed;
@@ -58,9 +58,9 @@ template<typename T>
 void SetParam(
     util::ParamData& d,
     const std::any& value,
-    const typename std::enable_if<arma::is_arma_type<T>::value ||
-                                  std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value ||
+                                  std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // We're setting the string filename.
   typedef std::tuple<T, typename ParameterType<T>::type> TupleType;
@@ -76,8 +76,8 @@ template<typename T>
 void SetParam(
     util::ParamData& d,
     const std::any& value,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // We're setting the string filename.
   typedef std::tuple<T*, typename ParameterType<T>::type> TupleType;
@@ -96,7 +96,7 @@ void SetParam(
 template<typename T>
 void SetParam(util::ParamData& d, const void* input, void* /* output */)
 {
-  SetParam<typename std::remove_pointer<T>::type>(
+  SetParam<std::remove_pointer_t<T>>(
       const_cast<util::ParamData&>(d), *((std::any*) input));
 }
 
diff --git a/src/mlpack/bindings/cli/string_type_param.hpp b/src/mlpack/bindings/cli/string_type_param.hpp
index decf9e794d..bd9e2c81ef 100644
--- a/src/mlpack/bindings/cli/string_type_param.hpp
+++ b/src/mlpack/bindings/cli/string_type_param.hpp
@@ -26,22 +26,22 @@ namespace cli {
  */
 template<typename T>
 std::string StringTypeParamImpl(
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0);
 
 /**
  * Return a string containing the type of the parameter, for vector options.
  */
 template<typename T>
 std::string StringTypeParamImpl(
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return a string containing the type of the parameter,
  */
 template<typename T>
 std::string StringTypeParamImpl(
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Return a string containing the type of a parameter.  This overload is used if
diff --git a/src/mlpack/bindings/cli/string_type_param_impl.hpp b/src/mlpack/bindings/cli/string_type_param_impl.hpp
index f0fc89a34c..5bc52703cb 100644
--- a/src/mlpack/bindings/cli/string_type_param_impl.hpp
+++ b/src/mlpack/bindings/cli/string_type_param_impl.hpp
@@ -23,8 +23,8 @@ namespace cli {
  */
 template<typename T>
 std::string StringTypeParamImpl(
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*)
 {
   // Don't know what type this is.
   return "unknown";
@@ -35,7 +35,7 @@ std::string StringTypeParamImpl(
  */
 template<typename T>
 std::string StringTypeParamImpl(
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
   return "vector";
 }
@@ -45,7 +45,7 @@ std::string StringTypeParamImpl(
  */
 template<typename T>
 std::string StringTypeParamImpl(
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "string";
 }
diff --git a/src/mlpack/bindings/go/default_param.hpp b/src/mlpack/bindings/go/default_param.hpp
index 38c7272a00..9c749759f4 100644
--- a/src/mlpack/bindings/go/default_param.hpp
+++ b/src/mlpack/bindings/go/default_param.hpp
@@ -26,13 +26,13 @@ namespace go {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::string>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::string>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return the default value of a vector option.
@@ -40,7 +40,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return the default value of a string option.
@@ -48,8 +48,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value
-        >::type* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>
+        >* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -59,10 +59,10 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* = 0);
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* = 0);
 
 /**
  * Return the default value of a model option (this returns the default
@@ -71,8 +71,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Return the default value of an option.  This is the function that will be
@@ -84,7 +84,7 @@ void DefaultParam(util::ParamData& data,
                   void* output)
 {
   std::string* outstr = (std::string*) output;
-  *outstr = DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+  *outstr = DefaultParamImpl<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/default_param_impl.hpp b/src/mlpack/bindings/go/default_param_impl.hpp
index 12a80f1f2b..a4abee84ea 100644
--- a/src/mlpack/bindings/go/default_param_impl.hpp
+++ b/src/mlpack/bindings/go/default_param_impl.hpp
@@ -24,16 +24,16 @@ namespace go {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::string>>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*)
 {
   std::ostringstream oss;
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     oss << "false";
   else
     oss << std::any_cast<T>(data.value);
@@ -47,12 +47,12 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
   // Print each element in an array delimited by square brackets.
   std::ostringstream oss;
   const T& vector = std::any_cast<T>(data.value);
-  if (std::is_same<T, std::vector<std::string>>::value)
+  if (std::is_same_v<T, std::vector<std::string>>)
   {
     oss << "[]string{";
     if (vector.size() > 0)
@@ -67,7 +67,7 @@ std::string DefaultParamImpl(
 
     oss << "}";
   }
-  else if (std::is_same<T, std::vector<int>>::value)
+  else if (std::is_same_v<T, std::vector<int>>)
   {
     oss << "[]int{";
     if (vector.size() > 0)
@@ -91,7 +91,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T, std::string>>*)
 {
   const std::string& s = *std::any_cast<std::string>(&data.value);
   return "\"" + s + "\"";
@@ -103,23 +103,23 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* /* junk */)
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* /* junk */)
 {
   // Get the filename and return it, or return an empty string.
-  if (std::is_same<T, arma::rowvec>::value ||
-      std::is_same<T, arma::vec>::value)
+  if (std::is_same_v<T, arma::rowvec> ||
+      std::is_same_v<T, arma::vec>)
   {
     return "mat.NewDense(1, 1, nil)";
   }
-  else if (std::is_same<T, arma::Col<size_t>>::value ||
-           std::is_same<T, arma::Row<size_t>>::value)
+  else if (std::is_same_v<T, arma::Col<size_t>> ||
+           std::is_same_v<T, arma::Row<size_t>>)
   {
     return "mat.NewDense(1, 1, nil)";
   }
-  else if (std::is_same<T, arma::Mat<size_t>>::value)
+  else if (std::is_same_v<T, arma::Mat<size_t>>)
   {
     return "mat.NewDense(1, 1, nil)";
   }
@@ -135,8 +135,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "nil";
 }
diff --git a/src/mlpack/bindings/go/get_go_type.hpp b/src/mlpack/bindings/go/get_go_type.hpp
index 4fc800ecbf..b4db78e753 100644
--- a/src/mlpack/bindings/go/get_go_type.hpp
+++ b/src/mlpack/bindings/go/get_go_type.hpp
@@ -25,11 +25,11 @@ namespace go {
 template<typename T>
 inline std::string GetGoType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   return "unknown";
 }
@@ -37,11 +37,11 @@ inline std::string GetGoType(
 template<>
 inline std::string GetGoType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "int";
 }
@@ -49,11 +49,11 @@ inline std::string GetGoType<int>(
 template<>
 inline std::string GetGoType<float>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<float>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<float>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<float>::value>::type*,
-    const typename std::enable_if<!std::is_same<float,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<float>::value>*,
+    const std::enable_if_t<!data::HasSerialize<float>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<float>::value>*,
+    const std::enable_if_t<!std::is_same_v<float,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "float32";
 }
@@ -61,11 +61,11 @@ inline std::string GetGoType<float>(
 template<>
 inline std::string GetGoType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "float64";
 }
@@ -73,14 +73,14 @@ inline std::string GetGoType<double>(
 template<>
 inline std::string GetGoType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<std::string,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!std::is_same_v<std::string,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "string";
 }
@@ -88,11 +88,11 @@ inline std::string GetGoType<std::string>(
 template<>
 inline std::string GetGoType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "bool";
 }
@@ -100,7 +100,7 @@ inline std::string GetGoType<bool>(
 template<typename T>
 inline std::string GetGoType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   return "[]" + GetGoType<typename T::value_type>(d);
 }
@@ -108,9 +108,9 @@ inline std::string GetGoType(
 template<typename T>
 inline std::string GetGoType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0,
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   return "mat.Dense";
 }
@@ -118,8 +118,8 @@ inline std::string GetGoType(
 template<typename T>
 inline std::string GetGoType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   return "matrixWithInfo";
 }
@@ -127,8 +127,8 @@ inline std::string GetGoType(
 template<typename T>
 inline std::string GetGoType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   std::string goStrippedType, strippedType, printedType, defaultsType;
   StripType(d.cppType, goStrippedType, strippedType, printedType, defaultsType);
diff --git a/src/mlpack/bindings/go/get_printable_param.hpp b/src/mlpack/bindings/go/get_printable_param.hpp
index 107e7203c3..057d5c24d6 100644
--- a/src/mlpack/bindings/go/get_printable_param.hpp
+++ b/src/mlpack/bindings/go/get_printable_param.hpp
@@ -25,11 +25,11 @@ namespace go {
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   std::ostringstream oss;
   oss << std::any_cast<T>(data.value);
@@ -42,7 +42,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   const T& t = std::any_cast<T>(data.value);
 
@@ -58,7 +58,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Get the matrix.
   const T& matrix = std::any_cast<T>(data.value);
@@ -74,8 +74,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   std::ostringstream oss;
   oss << data.cppType << " model at " << std::any_cast<T*>(data.value);
@@ -88,8 +88,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // Get the matrix.
   const T& tuple = std::any_cast<T>(data.value);
@@ -116,7 +116,7 @@ void GetPrintableParam(util::ParamData& data,
                        void* output)
 {
   *((std::string*) output) =
-      GetPrintableParam<typename std::remove_pointer<T>::type>(data);
+      GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/get_printable_type.hpp b/src/mlpack/bindings/go/get_printable_type.hpp
index 5b2cadece3..6316b69e3a 100644
--- a/src/mlpack/bindings/go/get_printable_type.hpp
+++ b/src/mlpack/bindings/go/get_printable_type.hpp
@@ -23,78 +23,78 @@ namespace go {
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<>
 inline std::string GetPrintableType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<std::string,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!std::is_same_v<std::string,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 void GetPrintableType(util::ParamData& d,
@@ -102,7 +102,7 @@ void GetPrintableType(util::ParamData& d,
                       void* output)
 {
   *((std::string*) output) =
-      GetPrintableType<typename std::remove_pointer<T>::type>(d);
+      GetPrintableType<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/get_printable_type_impl.hpp b/src/mlpack/bindings/go/get_printable_type_impl.hpp
index cdbfe9feb5..0c01ccbe83 100644
--- a/src/mlpack/bindings/go/get_printable_type_impl.hpp
+++ b/src/mlpack/bindings/go/get_printable_type_impl.hpp
@@ -23,11 +23,11 @@ namespace go {
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "unknown";
 }
@@ -35,11 +35,11 @@ inline std::string GetPrintableType(
 template<>
 inline std::string GetPrintableType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "int";
 }
@@ -47,11 +47,11 @@ inline std::string GetPrintableType<int>(
 template<>
 inline std::string GetPrintableType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "float64";
 }
@@ -59,14 +59,14 @@ inline std::string GetPrintableType<double>(
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<std::string,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!std::is_same_v<std::string,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "string";
 }
@@ -74,11 +74,11 @@ inline std::string GetPrintableType<std::string>(
 template<>
 inline std::string GetPrintableType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "bool";
 }
@@ -86,9 +86,9 @@ inline std::string GetPrintableType<bool>(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "array of " + GetPrintableType<typename T::value_type>(d) + "s";
 }
@@ -96,9 +96,9 @@ inline std::string GetPrintableType(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::string type = "*mat.Dense";
   if (T::is_row || T::is_col)
@@ -110,8 +110,8 @@ inline std::string GetPrintableType(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "matrixWithInfo";
 }
@@ -119,10 +119,10 @@ inline std::string GetPrintableType(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::string goStrippedType, strippedType, printedType, defaultsType;
   StripType(d.cppType, goStrippedType, strippedType, printedType, defaultsType);
diff --git a/src/mlpack/bindings/go/get_type.hpp b/src/mlpack/bindings/go/get_type.hpp
index 828085d375..ac60755f31 100644
--- a/src/mlpack/bindings/go/get_type.hpp
+++ b/src/mlpack/bindings/go/get_type.hpp
@@ -24,9 +24,9 @@ namespace go {
 template<typename T>
 inline std::string GetType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0)
 {
   return "unknown";
 }
@@ -34,9 +34,9 @@ inline std::string GetType(
 template<>
 inline std::string GetType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*)
 {
   return "Int";
 }
@@ -44,9 +44,9 @@ inline std::string GetType<int>(
 template<>
 inline std::string GetType<float>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<float>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<float>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<float>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<float>::value>*,
+    const std::enable_if_t<!data::HasSerialize<float>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<float>::value>*)
 {
   return "Float";
 }
@@ -54,9 +54,9 @@ inline std::string GetType<float>(
 template<>
 inline std::string GetType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*)
 {
   return "Double";
 }
@@ -64,12 +64,12 @@ inline std::string GetType<double>(
 template<>
 inline std::string GetType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*)
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*)
 {
   return "String";
 }
@@ -77,9 +77,9 @@ inline std::string GetType<std::string>(
 template<>
 inline std::string GetType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*)
 {
   return "Bool";
 }
@@ -87,7 +87,7 @@ inline std::string GetType<bool>(
 template<typename T>
 inline std::string GetType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   return "Vec" + GetType<typename T::value_type>(d);
 }
@@ -95,10 +95,10 @@ inline std::string GetType(
 template<typename T>
 inline std::string GetType(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   std::string type = "";
-  if (std::is_same<typename T::elem_type, double>::value)
+  if (std::is_same_v<typename T::elem_type, double>)
   {
     if (T::is_row)
       type = "Row";
@@ -107,7 +107,7 @@ inline std::string GetType(
     else
       type = "Mat";
   }
-  else if (std::is_same<typename T::elem_type, size_t>::value)
+  else if (std::is_same_v<typename T::elem_type, size_t>)
   {
     if (T::is_row)
       type = "Urow";
@@ -123,8 +123,8 @@ inline std::string GetType(
 template<typename T>
 inline std::string GetType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   return d.cppType + "*";
 }
@@ -145,7 +145,7 @@ void GetType(util::ParamData& d,
              void* output)
 {
   *((std::string*) output) =
-      GetType<typename std::remove_pointer<T>::type>(d);
+      GetType<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/print_defn_input.hpp b/src/mlpack/bindings/go/print_defn_input.hpp
index c51dfa110b..e021b1ec19 100644
--- a/src/mlpack/bindings/go/print_defn_input.hpp
+++ b/src/mlpack/bindings/go/print_defn_input.hpp
@@ -28,10 +28,10 @@ namespace go {
 template<typename T>
 void PrintDefnInput(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   if (d.required)
   {
@@ -46,7 +46,7 @@ void PrintDefnInput(
 template<typename T>
 void PrintDefnInput(
     util::ParamData& d,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // param_name *mat.Dense
   if (d.required)
@@ -62,8 +62,8 @@ void PrintDefnInput(
 template<typename T>
 void PrintDefnInput(
     util::ParamData& d,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // param_name *DataWithInfo
   if (d.required)
@@ -79,8 +79,8 @@ void PrintDefnInput(
 template<typename T>
 void PrintDefnInput(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Get the type names we need to use.
   std::string goStrippedType, strippedType, printedType, defaultsType;
@@ -113,7 +113,7 @@ void PrintDefnInput(util::ParamData& d,
                     const void* /* input */,
                     void* /* output */)
 {
-  PrintDefnInput<typename std::remove_pointer<T>::type>(d);
+  PrintDefnInput<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/print_defn_output.hpp b/src/mlpack/bindings/go/print_defn_output.hpp
index b18233d1d0..0207c4ea88 100644
--- a/src/mlpack/bindings/go/print_defn_output.hpp
+++ b/src/mlpack/bindings/go/print_defn_output.hpp
@@ -27,10 +27,10 @@ namespace go {
 template<typename T>
 void PrintDefnOutput(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   std::cout << GetGoType<T>(d);
 }
@@ -41,7 +41,7 @@ void PrintDefnOutput(
 template<typename T>
 void PrintDefnOutput(
     util::ParamData& d,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // *mat.Dense
   std::cout << "*" << GetGoType<T>(d);
@@ -53,8 +53,8 @@ void PrintDefnOutput(
 template<typename T>
 void PrintDefnOutput(
     util::ParamData& d,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // *mat.Dense
   std::cout << "*" << GetGoType<T>(d);
@@ -66,8 +66,8 @@ void PrintDefnOutput(
 template<typename T>
 void PrintDefnOutput(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Get the type names we need to use.
   std::string goStrippedType, strippedType, printedType, defaultsType;
@@ -94,7 +94,7 @@ void PrintDefnOutput(util::ParamData& d,
                      const void* /* input */,
                      void* /* output */)
 {
-  PrintDefnOutput<typename std::remove_pointer<T>::type>(d);
+  PrintDefnOutput<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/print_doc.hpp b/src/mlpack/bindings/go/print_doc.hpp
index 86f3bbe813..2ba21e0f5c 100644
--- a/src/mlpack/bindings/go/print_doc.hpp
+++ b/src/mlpack/bindings/go/print_doc.hpp
@@ -45,7 +45,7 @@ void PrintDoc(util::ParamData& d,
   std::ostringstream oss;
   oss << " - ";
   oss << util::CamelCase(d.name, Lower) << " (";
-  oss << GetGoType<typename std::remove_pointer<T>::type>(d) << "): "
+  oss << GetGoType<std::remove_pointer_t<T>>(d) << "): "
       << d.desc;
 
   // Print a default, if possible.
diff --git a/src/mlpack/bindings/go/print_input_processing.hpp b/src/mlpack/bindings/go/print_input_processing.hpp
index f46936ea3e..c64e5ed4e2 100644
--- a/src/mlpack/bindings/go/print_input_processing.hpp
+++ b/src/mlpack/bindings/go/print_input_processing.hpp
@@ -29,15 +29,15 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
   std::string def = "nil";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "false";
 
   // Capitalize the first letter of parameter name so it is
@@ -131,7 +131,7 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -206,8 +206,8 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -268,8 +268,8 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // First, get the correct classparamName if needed.
   std::string goStrippedType, strippedType, printedType, defaultsType;
@@ -340,7 +340,7 @@ void PrintInputProcessing(util::ParamData& d,
                           const void* input,
                           void* /* output */)
 {
-  PrintInputProcessing<typename std::remove_pointer<T>::type>(d,
+  PrintInputProcessing<std::remove_pointer_t<T>>(d,
       *((size_t*) input));
 }
 
diff --git a/src/mlpack/bindings/go/print_method_config.hpp b/src/mlpack/bindings/go/print_method_config.hpp
index 6a51d7205d..5d6d1d5fd6 100644
--- a/src/mlpack/bindings/go/print_method_config.hpp
+++ b/src/mlpack/bindings/go/print_method_config.hpp
@@ -29,15 +29,15 @@ template<typename T>
 void PrintMethodConfig(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
   std::string def = "nil";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "false";
 
   // Capitalize the first letter of parameter name so it is
@@ -64,12 +64,12 @@ template<typename T>
 void PrintMethodConfig(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   const std::string prefix(indent, ' ');
 
   std::string def = "nil";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "false";
 
   // Capitalize the first letter of parameter name so it is
@@ -96,13 +96,13 @@ template<typename T>
 void PrintMethodConfig(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
   std::string def = "nil";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "false";
 
   // Capitalize the first letter of parameter name so it is
@@ -129,13 +129,13 @@ template<typename T>
 void PrintMethodConfig(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   const std::string prefix(indent, ' ');
 
   std::string def = "nil";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "false";
 
   // Capitalize the first letter of parameter name so it is
@@ -171,7 +171,7 @@ void PrintMethodConfig(util::ParamData& d,
                        const void* input,
                        void* /* output */)
 {
-  PrintMethodConfig<typename std::remove_pointer<T>::type>(d,
+  PrintMethodConfig<std::remove_pointer_t<T>>(d,
       *((size_t*) input));
 }
 
diff --git a/src/mlpack/bindings/go/print_method_init.hpp b/src/mlpack/bindings/go/print_method_init.hpp
index ef766f2536..6448874dee 100644
--- a/src/mlpack/bindings/go/print_method_init.hpp
+++ b/src/mlpack/bindings/go/print_method_init.hpp
@@ -29,15 +29,15 @@ template<typename T>
 void PrintMethodInit(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
   std::string def = "nil";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "false";
 
   // Capitalize the first letter of parameter name so it is
@@ -86,12 +86,12 @@ template<typename T>
 void PrintMethodInit(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   const std::string prefix(indent, ' ');
 
   std::string def = "nil";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "false";
 
   // Capitalize the first letter of parameter name so it is
@@ -118,13 +118,13 @@ template<typename T>
 void PrintMethodInit(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
   std::string def = "nil";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "false";
 
   // Capitalize the first letter of parameter name so it is
@@ -151,13 +151,13 @@ template<typename T>
 void PrintMethodInit(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   const std::string prefix(indent, ' ');
 
   std::string def = "nil";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "false";
 
   // Capitalize the first letter of parameter name so it is
@@ -193,7 +193,7 @@ void PrintMethodInit(util::ParamData& d,
                      const void* input,
                      void* /* output */)
 {
-  PrintMethodInit<typename std::remove_pointer<T>::type>(d,
+  PrintMethodInit<std::remove_pointer_t<T>>(d,
       *((size_t*) input));
 }
 
diff --git a/src/mlpack/bindings/go/print_output_processing.hpp b/src/mlpack/bindings/go/print_output_processing.hpp
index 563b45125f..90dcdd7b4a 100644
--- a/src/mlpack/bindings/go/print_output_processing.hpp
+++ b/src/mlpack/bindings/go/print_output_processing.hpp
@@ -29,10 +29,10 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -56,9 +56,9 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -84,8 +84,8 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -111,8 +111,8 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Get the type names we need to use.
   std::string goStrippedType, strippedType, printedType, defaultsType;
@@ -144,7 +144,7 @@ void PrintOutputProcessing(util::ParamData& d,
                            const void* /*input*/,
                            void* /* output */)
 {
-  PrintOutputProcessing<typename std::remove_pointer<T>::type>(d, 2);
+  PrintOutputProcessing<std::remove_pointer_t<T>>(d, 2);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/print_type_doc.hpp b/src/mlpack/bindings/go/print_type_doc.hpp
index b5dde90fa0..f8550dc9e5 100644
--- a/src/mlpack/bindings/go/print_type_doc.hpp
+++ b/src/mlpack/bindings/go/print_type_doc.hpp
@@ -25,11 +25,11 @@ namespace go {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a vector.
@@ -37,7 +37,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix option.
@@ -45,7 +45,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix tuple option.
@@ -53,8 +53,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a model.
@@ -62,8 +62,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Print the command-line type of an option into a string.
@@ -74,7 +74,7 @@ void PrintTypeDoc(util::ParamData& data,
                   void* output)
 {
   *((std::string*) output) =
-      PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+      PrintTypeDoc<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/print_type_doc_impl.hpp b/src/mlpack/bindings/go/print_type_doc_impl.hpp
index 568ef9b059..d97667503c 100644
--- a/src/mlpack/bindings/go/print_type_doc_impl.hpp
+++ b/src/mlpack/bindings/go/print_type_doc_impl.hpp
@@ -24,29 +24,29 @@ namespace go {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   // A flag type.
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
   {
     return "A boolean flag option (`true` or `false`).";
   }
   // An integer.
-  else if (std::is_same<T, int>::value)
+  else if (std::is_same_v<T, int>)
   {
     return "An integer (i.e., `1`).";
   }
   // A floating point value.
-  else if (std::is_same<T, double>::value)
+  else if (std::is_same_v<T, double>)
   {
     return "A floating-point number (i.e., `0.5`).";
   }
   // A string.
-  else if (std::is_same<T, std::string>::value)
+  else if (std::is_same_v<T, std::string>)
   {
     return "A character string (i.e., `\"hello\"`).";
   }
@@ -63,13 +63,13 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
-  if (std::is_same<T, std::vector<int>>::value)
+  if (std::is_same_v<T, std::vector<int>>)
   {
     return "An array of integers; i.e., `[]int{0, 1, 2}`.";
   }
-  else if (std::is_same<T, std::vector<std::string>>::value)
+  else if (std::is_same_v<T, std::vector<std::string>>)
   {
     return "An array of strings; i.e., `[]string{\"hello\", \"goodbye\"}`.";
   }
@@ -85,7 +85,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
   if (T::is_col || T::is_row)
   {
@@ -105,8 +105,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "A Tuple(matrixWithInfo) containing `float64` data (Data) along with a"
      " boolean array (Categoricals) indicating which dimensions are categorical"
@@ -122,8 +122,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "An mlpack model pointer.  This type holds a pointer to C++ memory "
       "containing the mlpack model.  Note that this means the mlpack model "
diff --git a/src/mlpack/bindings/julia/default_param.hpp b/src/mlpack/bindings/julia/default_param.hpp
index b466d0135a..d6a96c2237 100644
--- a/src/mlpack/bindings/julia/default_param.hpp
+++ b/src/mlpack/bindings/julia/default_param.hpp
@@ -26,13 +26,13 @@ namespace julia {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::string>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::string>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return the default value of a vector option.
@@ -40,7 +40,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return the default value of a string option.
@@ -48,8 +48,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value
-        >::type* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>
+        >* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -59,10 +59,10 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* = 0);
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* = 0);
 
 /**
  * Return the default value of a model option (this returns the default
@@ -71,8 +71,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Return the default value of an option.  This is the function that will be
@@ -84,7 +84,7 @@ void DefaultParam(util::ParamData& data,
                   void* output)
 {
   std::string* outstr = (std::string*) output;
-  *outstr = DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+  *outstr = DefaultParamImpl<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/default_param_impl.hpp b/src/mlpack/bindings/julia/default_param_impl.hpp
index 94224814c4..9812a1990f 100644
--- a/src/mlpack/bindings/julia/default_param_impl.hpp
+++ b/src/mlpack/bindings/julia/default_param_impl.hpp
@@ -24,16 +24,16 @@ namespace julia {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::string>>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*)
 {
   std::ostringstream oss;
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     oss << "false";
   else
     oss << std::any_cast<T>(data.value);
@@ -47,13 +47,13 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
   // Print each element in an array delimited by square brackets.
   std::ostringstream oss;
   const T& vector = std::any_cast<T>(data.value);
   oss << "[";
-  if (std::is_same<T, std::vector<std::string>>::value)
+  if (std::is_same_v<T, std::vector<std::string>>)
   {
     if (vector.size() > 0)
     {
@@ -90,7 +90,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T, std::string>>*)
 {
   const std::string& s = *std::any_cast<std::string>(&data.value);
   return "\"" + s + "\"";
@@ -103,23 +103,23 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* /* junk */)
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* /* junk */)
 {
   // Get the filename and return it, or return an empty string.
-  if (std::is_same<T, arma::rowvec>::value ||
-      std::is_same<T, arma::vec>::value)
+  if (std::is_same_v<T, arma::rowvec> ||
+      std::is_same_v<T, arma::vec>)
   {
     return "Float64[]";
   }
-  else if (std::is_same<T, arma::Col<size_t>>::value ||
-           std::is_same<T, arma::Row<size_t>>::value)
+  else if (std::is_same_v<T, arma::Col<size_t>> ||
+           std::is_same_v<T, arma::Row<size_t>>)
   {
     return "Int[]";
   }
-  else if (std::is_same<T, arma::Mat<size_t>>::value)
+  else if (std::is_same_v<T, arma::Mat<size_t>>)
   {
     return "zeros(Int, 0, 0)";
   }
@@ -135,8 +135,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "nothing";
 }
diff --git a/src/mlpack/bindings/julia/get_julia_type.hpp b/src/mlpack/bindings/julia/get_julia_type.hpp
index a3fa2c863a..464934d5e3 100644
--- a/src/mlpack/bindings/julia/get_julia_type.hpp
+++ b/src/mlpack/bindings/julia/get_julia_type.hpp
@@ -21,11 +21,11 @@ namespace julia {
 template<typename T>
 inline std::string GetJuliaType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0)
 {
   return "unknown_"; // This will cause an error most likely...
 }
@@ -33,11 +33,11 @@ inline std::string GetJuliaType(
 template<>
 inline std::string GetJuliaType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*)
 {
   return "Bool";
 }
@@ -45,11 +45,11 @@ inline std::string GetJuliaType<bool>(
 template<>
 inline std::string GetJuliaType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*)
 {
   return "Int";
 }
@@ -57,11 +57,11 @@ inline std::string GetJuliaType<int>(
 template<>
 inline std::string GetJuliaType<size_t>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<size_t>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<size_t>::value>::type*,
-    const typename std::enable_if<!std::is_same<size_t,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<size_t>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<size_t>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<size_t>::value>*,
+    const std::enable_if_t<!std::is_same_v<size_t,
+        std::tuple<data::DatasetInfo, arma::mat>>>*,
+    const std::enable_if_t<!data::HasSerialize<size_t>::value>*)
 {
   return "UInt";
 }
@@ -69,11 +69,11 @@ inline std::string GetJuliaType<size_t>(
 template<>
 inline std::string GetJuliaType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*)
 {
   // I suppose on some systems this may not be 64 bit.
   return "Float64";
@@ -82,14 +82,14 @@ inline std::string GetJuliaType<double>(
 template<>
 inline std::string GetJuliaType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<std::string,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*)
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!std::is_same_v<std::string,
+        std::tuple<data::DatasetInfo, arma::mat>>>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*)
 {
   return "String";
 }
@@ -97,10 +97,10 @@ inline std::string GetJuliaType<std::string>(
 template<typename T>
 inline std::string GetJuliaType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0)
 {
   return "Vector{" + GetJuliaType<typename T::value_type>(d) + "}";
 }
@@ -108,14 +108,14 @@ inline std::string GetJuliaType(
 template<typename T>
 inline std::string GetJuliaType(
     util::ParamData& d,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0,
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // size_t matrices are special: we want to represent them in Julia as
   // Array{Int, X} not UInt because Julia displays UInts strangely.
-  if (std::is_same<typename T::elem_type, size_t>::value)
+  if (std::is_same_v<typename T::elem_type, size_t>)
     return std::string("Array{Int, ") + (T::is_col || T::is_row ? "1" : "2")
         + "}";
   else
@@ -126,8 +126,8 @@ inline std::string GetJuliaType(
 template<typename T>
 inline std::string GetJuliaType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   return "Tuple{Array{Bool, 1}, Array{Float64, 2}}";
 }
@@ -136,9 +136,9 @@ inline std::string GetJuliaType(
 template<typename T>
 inline std::string GetJuliaType(
     util::ParamData& d,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Serializable types are just held as a pointer to nothing, but they're
   // wrapped in a struct.
diff --git a/src/mlpack/bindings/julia/get_printable_param.hpp b/src/mlpack/bindings/julia/get_printable_param.hpp
index 99ef72726d..25783d8910 100644
--- a/src/mlpack/bindings/julia/get_printable_param.hpp
+++ b/src/mlpack/bindings/julia/get_printable_param.hpp
@@ -25,11 +25,11 @@ namespace julia {
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   std::ostringstream oss;
   oss << std::any_cast<T>(data.value);
@@ -42,7 +42,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   const T& t = std::any_cast<T>(data.value);
 
@@ -58,7 +58,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Get the matrix.
   const T& matrix = std::any_cast<T>(data.value);
@@ -74,8 +74,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   std::ostringstream oss;
   oss << data.cppType << " model at " << std::any_cast<T*>(data.value);
@@ -88,8 +88,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // Get the matrix.
   const T& tuple = std::any_cast<T>(data.value);
@@ -116,7 +116,7 @@ void GetPrintableParam(util::ParamData& data,
                        void* output)
 {
   *((std::string*) output) =
-      GetPrintableParam<typename std::remove_pointer<T>::type>(data);
+      GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/get_printable_type.hpp b/src/mlpack/bindings/julia/get_printable_type.hpp
index 9fa2a03fec..751928eacc 100644
--- a/src/mlpack/bindings/julia/get_printable_type.hpp
+++ b/src/mlpack/bindings/julia/get_printable_type.hpp
@@ -23,11 +23,11 @@ namespace julia {
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a vector.
@@ -35,7 +35,7 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix option.
@@ -43,7 +43,7 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix tuple option.
@@ -51,8 +51,8 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a model.
@@ -60,8 +60,8 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Print the command-line type of an option into a string.
@@ -72,7 +72,7 @@ void GetPrintableType(util::ParamData& data,
                        void* output)
 {
   *((std::string*) output) =
-      GetPrintableType<typename std::remove_pointer<T>::type>(data);
+      GetPrintableType<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/get_printable_type_impl.hpp b/src/mlpack/bindings/julia/get_printable_type_impl.hpp
index bbf32869b2..dca8dc981e 100644
--- a/src/mlpack/bindings/julia/get_printable_type_impl.hpp
+++ b/src/mlpack/bindings/julia/get_printable_type_impl.hpp
@@ -26,19 +26,19 @@ namespace julia {
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     return "Bool";
-  else if (std::is_same<T, int>::value)
+  else if (std::is_same_v<T, int>)
     return "Int";
-  else if (std::is_same<T, double>::value)
+  else if (std::is_same_v<T, double>)
     return "Float64";
-  else if (std::is_same<T, std::string>::value)
+  else if (std::is_same_v<T, std::string>)
     return "String";
   else
     throw std::invalid_argument("unknown parameter type " + data.cppType);
@@ -50,11 +50,11 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
-  if (std::is_same<T, std::vector<int>>::value)
+  if (std::is_same_v<T, std::vector<int>>)
     return "Array{Int, 1}";
-  else if (std::is_same<T, std::vector<std::string>>::value)
+  else if (std::is_same_v<T, std::vector<std::string>>)
     return "Array{String, 1}";
   else
     throw std::invalid_argument("unknown vector type " + data.cppType);
@@ -66,19 +66,19 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
-  if (std::is_same<T, arma::mat>::value)
+  if (std::is_same_v<T, arma::mat>)
     return "Float64 matrix-like";
-  else if (std::is_same<T, arma::Mat<size_t>>::value)
+  else if (std::is_same_v<T, arma::Mat<size_t>>)
     return "Int matrix-like";
-  else if (std::is_same<T, arma::rowvec>::value)
+  else if (std::is_same_v<T, arma::rowvec>)
     return "Float64 vector-like";
-  else if (std::is_same<T, arma::Row<size_t>>::value)
+  else if (std::is_same_v<T, arma::Row<size_t>>)
     return "Int vector-like";
-  else if (std::is_same<T, arma::vec>::value)
+  else if (std::is_same_v<T, arma::vec>)
     return "Float64 vector-like";
-  else if (std::is_same<T, arma::Col<size_t>>::value)
+  else if (std::is_same_v<T, arma::Col<size_t>>)
     return "Int vector-like";
   else
     throw std::invalid_argument("unknown Armadillo type " + data.cppType);
@@ -90,8 +90,8 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& /* data */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "Tuple{Array{Bool, 1}, Array{Float64, 2}}";
 }
@@ -102,8 +102,8 @@ std::string GetPrintableType(
 template<typename T>
 std::string GetPrintableType(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   std::string type = util::StripType(data.cppType);
   if (type == "mlpackModel")
diff --git a/src/mlpack/bindings/julia/print_input_param.hpp b/src/mlpack/bindings/julia/print_input_param.hpp
index 9091747b49..e46d3bf42b 100644
--- a/src/mlpack/bindings/julia/print_input_param.hpp
+++ b/src/mlpack/bindings/julia/print_input_param.hpp
@@ -39,12 +39,12 @@ void PrintInputParam(util::ParamData& d,
     // If it's required, then we need the type.
     if (d.required)
     {
-      std::cout << GetJuliaType<typename std::remove_pointer<T>::type>(d);
+      std::cout << GetJuliaType<std::remove_pointer_t<T>>(d);
     }
     else
     {
       std::cout << "Union{"
-          << GetJuliaType<typename std::remove_pointer<T>::type>(d)
+          << GetJuliaType<std::remove_pointer_t<T>>(d)
           << ", Missing} = missing";
     }
   }
diff --git a/src/mlpack/bindings/julia/print_input_processing.hpp b/src/mlpack/bindings/julia/print_input_processing.hpp
index cd19359fd3..d6339c3016 100644
--- a/src/mlpack/bindings/julia/print_input_processing.hpp
+++ b/src/mlpack/bindings/julia/print_input_processing.hpp
@@ -24,10 +24,10 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print the input processing for an Armadillo type.
@@ -36,9 +36,9 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print the input processing for a serializable type.
@@ -47,10 +47,10 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print the input processing (basically calling params.Get<>()) for a
@@ -60,8 +60,8 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print the input processing (basically calling params.Get<>()) for a type.
@@ -72,7 +72,7 @@ void PrintInputProcessing(util::ParamData& d,
                           void* /* output */)
 {
   // Call out to the right overload.
-  PrintInputProcessing<typename std::remove_pointer<T>::type>(d,
+  PrintInputProcessing<std::remove_pointer_t<T>>(d,
       *((std::string*) input));
 }
 
diff --git a/src/mlpack/bindings/julia/print_input_processing_impl.hpp b/src/mlpack/bindings/julia/print_input_processing_impl.hpp
index ec9299b540..e6078fb905 100644
--- a/src/mlpack/bindings/julia/print_input_processing_impl.hpp
+++ b/src/mlpack/bindings/julia/print_input_processing_impl.hpp
@@ -27,10 +27,10 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const std::string& /* functionName */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   // "type" is a reserved keyword or function.
   const std::string juliaName = (d.name == "type") ? "type_" : d.name;
@@ -66,9 +66,9 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const std::string& /* functionName */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   // "type" is a reserved keyword or function.
   const std::string juliaName = (d.name == "type") ? "type_" : d.name;
@@ -83,7 +83,7 @@ void PrintInputProcessing(
 
   // For an Armadillo type, we have to call a different overload for columns and
   // rows than for regular matrices.
-  std::string uChar = (std::is_same<typename T::elem_type, size_t>::value) ?
+  std::string uChar = (std::is_same_v<typename T::elem_type, size_t>) ?
       "U" : "";
   std::string indent(extraIndent + 2, ' ');
   std::string matTypeModifier = "";
@@ -125,10 +125,10 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   // "type" is a reserved keyword or function.
   const std::string juliaName = (d.name == "type") ? "type_" : d.name;
@@ -151,11 +151,11 @@ void PrintInputProcessing(
   std::string indent(extraIndent + 2, ' ');
   std::string type = util::StripType(d.cppType);
   std::cout << indent << "push!(modelPtrs, convert("
-      << GetJuliaType<typename std::remove_pointer<T>::type>(d) << ", "
+      << GetJuliaType<std::remove_pointer_t<T>>(d) << ", "
       << juliaName << ").ptr)" << std::endl;
   std::cout << indent << functionName << "_internal.SetParam" << type
       << "(p, \"" << d.name << "\", convert("
-      << GetJuliaType<typename std::remove_pointer<T>::type>(d) << ", "
+      << GetJuliaType<std::remove_pointer_t<T>>(d) << ", "
       << juliaName << "))" << std::endl;
 
   if (!d.required)
@@ -172,8 +172,8 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const std::string& /* functionName */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   // "type" is a reserved keyword or function.
   const std::string juliaName = (d.name == "type") ? "type_" : d.name;
diff --git a/src/mlpack/bindings/julia/print_model_type_import.hpp b/src/mlpack/bindings/julia/print_model_type_import.hpp
index 8b10454750..9630fb05f5 100644
--- a/src/mlpack/bindings/julia/print_model_type_import.hpp
+++ b/src/mlpack/bindings/julia/print_model_type_import.hpp
@@ -25,8 +25,8 @@ namespace julia {
 template<typename T>
 void PrintModelTypeImport(
     util::ParamData& /* d */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0)
 {
   // Do nothing.
 }
@@ -37,7 +37,7 @@ void PrintModelTypeImport(
 template<typename T>
 void PrintModelTypeImport(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Do nothing.
 }
@@ -48,8 +48,8 @@ void PrintModelTypeImport(
 template<typename T>
 void PrintModelTypeImport(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // We need to print, e.g.,
   // import ..<type>
@@ -67,7 +67,7 @@ void PrintModelTypeImport(util::ParamData& d,
                           const void* /* input */,
                           void* /* output */)
 {
-  PrintModelTypeImport<typename std::remove_pointer<T>::type>(d);
+  PrintModelTypeImport<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/print_output_processing.hpp b/src/mlpack/bindings/julia/print_output_processing.hpp
index e4f72ede36..c44184e8c2 100644
--- a/src/mlpack/bindings/julia/print_output_processing.hpp
+++ b/src/mlpack/bindings/julia/print_output_processing.hpp
@@ -26,10 +26,10 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print the output processing for an Armadillo type.
@@ -38,9 +38,9 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print the output processing for a serializable type.
@@ -49,10 +49,10 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print the output processing for a mat/DatasetInfo tuple type.
@@ -61,8 +61,8 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print the output processing (basically calling params.Get<>()) for a type.
@@ -73,7 +73,7 @@ void PrintOutputProcessing(util::ParamData& d,
                            void* /* output */)
 {
   // Call out to the right overload.
-  PrintOutputProcessing<typename std::remove_pointer<T>::type>(d,
+  PrintOutputProcessing<std::remove_pointer_t<T>>(d,
       *((std::string*) input));
 }
 
diff --git a/src/mlpack/bindings/julia/print_output_processing_impl.hpp b/src/mlpack/bindings/julia/print_output_processing_impl.hpp
index b3de0f688a..6bfa6e10af 100644
--- a/src/mlpack/bindings/julia/print_output_processing_impl.hpp
+++ b/src/mlpack/bindings/julia/print_output_processing_impl.hpp
@@ -29,34 +29,34 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const std::string& /* functionName */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::string type;
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     type = "Bool";
-  else if (std::is_same<T, int>::value)
+  else if (std::is_same_v<T, int>)
     type = "Int";
-  else if (std::is_same<T, double>::value)
+  else if (std::is_same_v<T, double>)
     type = "Double";
-  else if (std::is_same<T, std::string>::value)
+  else if (std::is_same_v<T, std::string>)
     type = "String";
-  else if (std::is_same<T, std::vector<std::string>>::value)
+  else if (std::is_same_v<T, std::vector<std::string>>)
     type = "VectorStr";
-  else if (std::is_same<T, std::vector<int>>::value)
+  else if (std::is_same_v<T, std::vector<int>>)
     type = "VectorInt";
   else
     type = "Unknown";
 
   // Strings need a little special handling.
-  if (std::is_same<T, std::string>::value)
+  if (std::is_same_v<T, std::string>)
     std::cout << "Base.unsafe_string(";
 
   std::cout << "GetParam" << type << "(p, \"" << d.name << "\")";
 
-  if (std::is_same<T, std::string>::value)
+  if (std::is_same_v<T, std::string>)
     std::cout << ")";
 }
 
@@ -67,11 +67,11 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const std::string& /* functionName */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
-  std::string uChar = (std::is_same<typename T::elem_type, size_t>::value) ?
+  std::string uChar = (std::is_same_v<typename T::elem_type, size_t>) ?
       "U" : "";
   std::string matTypeSuffix = "";
   std::string extra = "";
@@ -100,10 +100,10 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const std::string& functionName,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::string type = util::StripType(d.cppType);
   std::cout << functionName << "_internal.GetParam"
@@ -117,8 +117,8 @@ template<typename T>
 void PrintOutputProcessing(
     util::ParamData& d,
     const std::string& /* functionName */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::cout << "GetParamMatWithInfo(p, \"" << d.name << "\", juliaOwnedMemory)";
 }
diff --git a/src/mlpack/bindings/julia/print_param_defn.hpp b/src/mlpack/bindings/julia/print_param_defn.hpp
index df862c2aac..7883a4d8ff 100644
--- a/src/mlpack/bindings/julia/print_param_defn.hpp
+++ b/src/mlpack/bindings/julia/print_param_defn.hpp
@@ -26,8 +26,8 @@ template<typename T>
 void PrintParamDefn(
     util::ParamData& /* d */,
     const std::string& /* programName */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0)
 {
   // Do nothing.
 }
@@ -39,7 +39,7 @@ template<typename T>
 void PrintParamDefn(
     util::ParamData& /* d */,
     const std::string& /* programName */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Do nothing.
 }
@@ -51,8 +51,8 @@ template<typename T>
 void PrintParamDefn(
     util::ParamData& d,
     const std::string& programName,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // We need to print something of the form below:
   //
@@ -171,7 +171,7 @@ void PrintParamDefn(util::ParamData& d,
                     const void* input,
                     void* /* output */)
 {
-  PrintParamDefn<typename std::remove_pointer<T>::type>(d,
+  PrintParamDefn<std::remove_pointer_t<T>>(d,
       *(std::string*) input);
 }
 
diff --git a/src/mlpack/bindings/julia/print_type_doc.hpp b/src/mlpack/bindings/julia/print_type_doc.hpp
index eabda5a067..a007ac88d8 100644
--- a/src/mlpack/bindings/julia/print_type_doc.hpp
+++ b/src/mlpack/bindings/julia/print_type_doc.hpp
@@ -25,11 +25,11 @@ namespace julia {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a vector.
@@ -37,7 +37,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix option.
@@ -45,7 +45,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix tuple option.
@@ -53,8 +53,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a model.
@@ -62,8 +62,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Print the command-line type of an option into a string.
@@ -74,7 +74,7 @@ void PrintTypeDoc(util::ParamData& data,
                   void* output)
 {
   *((std::string*) output) =
-      PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+      PrintTypeDoc<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/print_type_doc_impl.hpp b/src/mlpack/bindings/julia/print_type_doc_impl.hpp
index 378147f13c..1f1a5eb971 100644
--- a/src/mlpack/bindings/julia/print_type_doc_impl.hpp
+++ b/src/mlpack/bindings/julia/print_type_doc_impl.hpp
@@ -24,29 +24,29 @@ namespace julia {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   // A flag type.
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
   {
     return "A boolean flag option (`true` or `false`).";
   }
   // An integer.
-  else if (std::is_same<T, int>::value)
+  else if (std::is_same_v<T, int>)
   {
     return "An integer (i.e., `1`).";
   }
   // A floating point value.
-  else if (std::is_same<T, double>::value)
+  else if (std::is_same_v<T, double>)
   {
     return "A floating-point number (i.e., `0.5`).";
   }
   // A string.
-  else if (std::is_same<T, std::string>::value)
+  else if (std::is_same_v<T, std::string>)
   {
     return "A character string (i.e., `\"hello\"`).";
   }
@@ -63,13 +63,13 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
-  if (std::is_same<T, std::vector<int>>::value)
+  if (std::is_same_v<T, std::vector<int>>)
   {
     return "A vector of integers; i.e., `[0, 1, 2]`.";
   }
-  else if (std::is_same<T, std::vector<std::string>>::value)
+  else if (std::is_same_v<T, std::vector<std::string>>)
   {
     return "A vector of strings; i.e., `[\"hello\", \"goodbye\"]`.";
   }
@@ -85,9 +85,9 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
-  if (std::is_same<typename T::elem_type, double>::value)
+  if (std::is_same_v<typename T::elem_type, double>)
   {
     if (T::is_col || T::is_row)
     {
@@ -104,7 +104,7 @@ std::string PrintTypeDoc(
           "`false` when calling mlpack bindings.";
     }
   }
-  else if (std::is_same<typename T::elem_type, size_t>::value)
+  else if (std::is_same_v<typename T::elem_type, size_t>)
   {
     if (T::is_col || T::is_row)
     {
@@ -135,8 +135,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "A 2-d array containing `Float64` data along with a boolean array "
       "indicating which dimensions are categorical (represented by `true`) and "
@@ -154,8 +154,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "An mlpack model pointer.  `<Model>` refers to the type of model that "
       "is being stored, so, e.g., for `CF()`, the type will be `CFModel`. "
diff --git a/src/mlpack/bindings/markdown/default_param.hpp b/src/mlpack/bindings/markdown/default_param.hpp
index cf4a175a29..130d89049b 100644
--- a/src/mlpack/bindings/markdown/default_param.hpp
+++ b/src/mlpack/bindings/markdown/default_param.hpp
@@ -38,27 +38,27 @@ void DefaultParam(util::ParamData& data,
   if (BindingInfo::Language() == "cli")
   {
     *((std::string*) output) =
-        cli::DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+        cli::DefaultParamImpl<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "python")
   {
     *((std::string*) output) =
-        python::DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+        python::DefaultParamImpl<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "julia")
   {
     *((std::string*) output) =
-        julia::DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+        julia::DefaultParamImpl<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "go")
   {
     *((std::string*) output) =
-        go::DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+        go::DefaultParamImpl<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "r")
   {
     *((std::string*) output) =
-        r::DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+        r::DefaultParamImpl<std::remove_pointer_t<T>>(data);
   }
   else
   {
diff --git a/src/mlpack/bindings/markdown/get_printable_param.hpp b/src/mlpack/bindings/markdown/get_printable_param.hpp
index 0bc5b37f7c..f2d8d13d22 100644
--- a/src/mlpack/bindings/markdown/get_printable_param.hpp
+++ b/src/mlpack/bindings/markdown/get_printable_param.hpp
@@ -25,11 +25,11 @@ namespace markdown {
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   std::ostringstream oss;
   oss << std::any_cast<T>(data.value);
@@ -42,7 +42,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   const T& t = std::any_cast<T>(data.value);
 
@@ -58,7 +58,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Get the matrix.
   const T& matrix = std::any_cast<T>(data.value);
@@ -74,8 +74,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   std::ostringstream oss;
   oss << data.cppType << " model at " << std::any_cast<T*>(data.value);
@@ -88,8 +88,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // Get the matrix.
   const T& tuple = std::any_cast<T>(data.value);
@@ -116,7 +116,7 @@ void GetPrintableParam(util::ParamData& data,
                        void* output)
 {
   *((std::string*) output) =
-      GetPrintableParam<typename std::remove_pointer<T>::type>(data);
+      GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace markdown
diff --git a/src/mlpack/bindings/markdown/get_printable_param_name.hpp b/src/mlpack/bindings/markdown/get_printable_param_name.hpp
index c222ea10fd..8243b2fcc7 100644
--- a/src/mlpack/bindings/markdown/get_printable_param_name.hpp
+++ b/src/mlpack/bindings/markdown/get_printable_param_name.hpp
@@ -26,10 +26,10 @@ namespace markdown {
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Get the parameter name for a matrix type (where the user has to pass the file
@@ -38,7 +38,7 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Get the parameter name for a serializable model type (where the user has to
@@ -47,8 +47,8 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Get the parameter name for a mapped matrix type (where the user has to pass
@@ -57,8 +57,8 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Get the parameter's name as seen by the user.
@@ -70,7 +70,7 @@ void GetPrintableParamName(
     void* output)
 {
   *((std::string*) output) =
-      GetPrintableParamName<typename std::remove_pointer<T>::type>(d);
+      GetPrintableParamName<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace markdown
diff --git a/src/mlpack/bindings/markdown/get_printable_param_name_impl.hpp b/src/mlpack/bindings/markdown/get_printable_param_name_impl.hpp
index b7e9f91fac..41b739692f 100644
--- a/src/mlpack/bindings/markdown/get_printable_param_name_impl.hpp
+++ b/src/mlpack/bindings/markdown/get_printable_param_name_impl.hpp
@@ -26,10 +26,10 @@ namespace markdown {
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "--" + data.name;
 }
@@ -41,7 +41,7 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
   return "--" + data.name + "_file";
 }
@@ -53,8 +53,8 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "--" + data.name + "_file";
 }
@@ -66,8 +66,8 @@ std::string GetPrintableParamName(
 template<typename T>
 std::string GetPrintableParamName(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "--" + data.name + "_file";
 }
diff --git a/src/mlpack/bindings/markdown/get_printable_param_value.hpp b/src/mlpack/bindings/markdown/get_printable_param_value.hpp
index a0708fc2af..ddaac3e2d9 100644
--- a/src/mlpack/bindings/markdown/get_printable_param_value.hpp
+++ b/src/mlpack/bindings/markdown/get_printable_param_value.hpp
@@ -27,10 +27,10 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& data,
     const std::string& value,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Get the parameter name for a matrix type (where the user has to pass the file
@@ -40,7 +40,7 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& data,
     const std::string& value,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Get the parameter name for a serializable model type (where the user has to
@@ -50,8 +50,8 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& data,
     const std::string& value,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Get the parameter name for a mapped matrix type (where the user has to pass
@@ -61,8 +61,8 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& data,
     const std::string& value,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Get the parameter's name as seen by the user.
@@ -74,7 +74,7 @@ void GetPrintableParamValue(
     void* output)
 {
   *((std::string*) output) =
-      GetPrintableParamValue<typename std::remove_pointer<T>::type>(d,
+      GetPrintableParamValue<std::remove_pointer_t<T>>(d,
       *((std::string*) input));
 }
 
diff --git a/src/mlpack/bindings/markdown/get_printable_param_value_impl.hpp b/src/mlpack/bindings/markdown/get_printable_param_value_impl.hpp
index 0753a7b03e..3c4e6110a6 100644
--- a/src/mlpack/bindings/markdown/get_printable_param_value_impl.hpp
+++ b/src/mlpack/bindings/markdown/get_printable_param_value_impl.hpp
@@ -28,10 +28,10 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& /* data */,
     const std::string& input,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return input;
 }
@@ -44,7 +44,7 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& /* data */,
     const std::string& input,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
   return input + ".csv";
 }
@@ -57,8 +57,8 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& /* data */,
     const std::string& input,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return input + ".bin";
 }
@@ -71,8 +71,8 @@ template<typename T>
 std::string GetPrintableParamValue(
     util::ParamData& /* data */,
     const std::string& input,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return input + ".arff";
 }
diff --git a/src/mlpack/bindings/markdown/get_printable_type.hpp b/src/mlpack/bindings/markdown/get_printable_type.hpp
index 2848947b54..b4316b036a 100644
--- a/src/mlpack/bindings/markdown/get_printable_type.hpp
+++ b/src/mlpack/bindings/markdown/get_printable_type.hpp
@@ -37,27 +37,27 @@ void GetPrintableType(util::ParamData& data,
   if (BindingInfo::Language() == "cli")
   {
     *((std::string*) output) =
-        cli::GetPrintableType<typename std::remove_pointer<T>::type>(data);
+        cli::GetPrintableType<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "python")
   {
     *((std::string*) output) =
-        python::GetPrintableType<typename std::remove_pointer<T>::type>(data);
+        python::GetPrintableType<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "julia")
   {
     *((std::string*) output) =
-        julia::GetPrintableType<typename std::remove_pointer<T>::type>(data);
+        julia::GetPrintableType<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "go")
   {
     *((std::string*) output) =
-        go::GetPrintableType<typename std::remove_pointer<T>::type>(data);
+        go::GetPrintableType<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "r")
   {
     *((std::string*) output) =
-        r::GetPrintableType<typename std::remove_pointer<T>::type>(data);
+        r::GetPrintableType<std::remove_pointer_t<T>>(data);
   }
   else
   {
diff --git a/src/mlpack/bindings/markdown/is_serializable.hpp b/src/mlpack/bindings/markdown/is_serializable.hpp
index fa66d53f08..bd2c738528 100644
--- a/src/mlpack/bindings/markdown/is_serializable.hpp
+++ b/src/mlpack/bindings/markdown/is_serializable.hpp
@@ -25,7 +25,7 @@ namespace markdown {
  */
 template<typename T>
 bool IsSerializable(
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0)
 {
   return false;
 }
@@ -35,8 +35,8 @@ bool IsSerializable(
  */
 template<typename T>
 bool IsSerializable(
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0)
 {
   return true;
 }
@@ -49,7 +49,7 @@ void IsSerializable(util::ParamData& /* data */,
                     const void* /* input */,
                     void* output)
 {
-  *((bool*) output) = IsSerializable<typename std::remove_pointer<T>::type>();
+  *((bool*) output) = IsSerializable<std::remove_pointer_t<T>>();
 }
 
 } // namespace markdown
diff --git a/src/mlpack/bindings/markdown/print_type_doc.hpp b/src/mlpack/bindings/markdown/print_type_doc.hpp
index 34a1906fa0..0e4f750979 100644
--- a/src/mlpack/bindings/markdown/print_type_doc.hpp
+++ b/src/mlpack/bindings/markdown/print_type_doc.hpp
@@ -34,23 +34,23 @@ std::string PrintTypeDoc(util::ParamData& data)
 {
   if (BindingInfo::Language() == "cli")
   {
-    return cli::PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+    return cli::PrintTypeDoc<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "python")
   {
-    return python::PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+    return python::PrintTypeDoc<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "julia")
   {
-    return julia::PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+    return julia::PrintTypeDoc<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "go")
   {
-    return go::PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+    return go::PrintTypeDoc<std::remove_pointer_t<T>>(data);
   }
   else if (BindingInfo::Language() == "r")
   {
-    return r::PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+    return r::PrintTypeDoc<std::remove_pointer_t<T>>(data);
   }
   else
   {
diff --git a/src/mlpack/bindings/python/default_param.hpp b/src/mlpack/bindings/python/default_param.hpp
index d7d92283d9..2482ed0f75 100644
--- a/src/mlpack/bindings/python/default_param.hpp
+++ b/src/mlpack/bindings/python/default_param.hpp
@@ -26,13 +26,13 @@ namespace python {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::string>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::string>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return the default value of a vector option.
@@ -40,7 +40,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return the default value of a string option.
@@ -48,8 +48,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value
-        >::type* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>
+        >* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -59,10 +59,10 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* = 0);
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* = 0);
 
 /**
  * Return the default value of a model option (this returns the default
@@ -71,8 +71,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Return the default value of an option.  This is the function that will be
@@ -84,7 +84,7 @@ void DefaultParam(util::ParamData& data,
                   void* output)
 {
   std::string* outstr = (std::string*) output;
-  *outstr = DefaultParamImpl<typename std::remove_pointer<T>::type>(data);
+  *outstr = DefaultParamImpl<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/default_param_impl.hpp b/src/mlpack/bindings/python/default_param_impl.hpp
index 1e1cab95d5..1153574181 100644
--- a/src/mlpack/bindings/python/default_param_impl.hpp
+++ b/src/mlpack/bindings/python/default_param_impl.hpp
@@ -24,16 +24,16 @@ namespace python {
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<mlpack::data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::string>>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*)
 {
   std::ostringstream oss;
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     oss << "False";
   else
     oss << std::any_cast<T>(data.value);
@@ -47,13 +47,13 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
   // Print each element in an array delimited by square brackets.
   std::ostringstream oss;
   const T& vector = std::any_cast<T>(data.value);
   oss << "[";
-  if (std::is_same<T, std::vector<std::string>>::value)
+  if (std::is_same_v<T, std::vector<std::string>>)
   {
     if (vector.size() > 0)
     {
@@ -90,7 +90,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T, std::string>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T, std::string>>*)
 {
   const std::string& s = *std::any_cast<std::string>(&data.value);
   return "'" + s + "'";
@@ -103,23 +103,23 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<
+    const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>::value>::type* /* junk */)
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
+                                   arma::mat>>>* /* junk */)
 {
   // Get the filename and return it, or return an empty string.
-  if (std::is_same<T, arma::rowvec>::value ||
-      std::is_same<T, arma::vec>::value)
+  if (std::is_same_v<T, arma::rowvec> ||
+      std::is_same_v<T, arma::vec>)
   {
     return "np.empty([0])";
   }
-  else if (std::is_same<T, arma::Col<size_t>>::value ||
-           std::is_same<T, arma::Row<size_t>>::value)
+  else if (std::is_same_v<T, arma::Col<size_t>> ||
+           std::is_same_v<T, arma::Row<size_t>>)
   {
     return "np.empty([0], dtype=np.uint64)";
   }
-  else if (std::is_same<T, arma::Mat<size_t>>::value)
+  else if (std::is_same_v<T, arma::Mat<size_t>>)
   {
     return "np.empty([0, 0], dtype=np.uint64)";
   }
@@ -135,8 +135,8 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "None";
 }
diff --git a/src/mlpack/bindings/python/get_cython_type.hpp b/src/mlpack/bindings/python/get_cython_type.hpp
index fd6682832e..a1b12abcda 100644
--- a/src/mlpack/bindings/python/get_cython_type.hpp
+++ b/src/mlpack/bindings/python/get_cython_type.hpp
@@ -23,9 +23,9 @@ namespace python {
 template<typename T>
 inline std::string GetCythonType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0)
 {
   return "unknown";
 }
@@ -33,9 +33,9 @@ inline std::string GetCythonType(
 template<>
 inline std::string GetCythonType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*)
 {
   return "int";
 }
@@ -43,9 +43,9 @@ inline std::string GetCythonType<int>(
 template<>
 inline std::string GetCythonType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*)
 {
   return "double";
 }
@@ -53,12 +53,12 @@ inline std::string GetCythonType<double>(
 template<>
 inline std::string GetCythonType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*)
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*)
 {
   return "string";
 }
@@ -66,9 +66,9 @@ inline std::string GetCythonType<std::string>(
 template<>
 inline std::string GetCythonType<size_t>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<size_t>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<size_t>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<size_t>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<size_t>::value>*,
+    const std::enable_if_t<!data::HasSerialize<size_t>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<size_t>::value>*)
 {
   return "size_t";
 }
@@ -76,9 +76,9 @@ inline std::string GetCythonType<size_t>(
 template<>
 inline std::string GetCythonType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*)
 {
   return "cbool";
 }
@@ -86,7 +86,7 @@ inline std::string GetCythonType<bool>(
 template<typename T>
 inline std::string GetCythonType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   return "vector[" + GetCythonType<typename T::value_type>(d) + "]";
 }
@@ -94,7 +94,7 @@ inline std::string GetCythonType(
 template<typename T>
 inline std::string GetCythonType(
     util::ParamData& d,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   std::string type = "Mat";
   if (T::is_row)
@@ -108,8 +108,8 @@ inline std::string GetCythonType(
 template<typename T>
 inline std::string GetCythonType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   return d.cppType + "*";
 }
diff --git a/src/mlpack/bindings/python/get_printable_param.hpp b/src/mlpack/bindings/python/get_printable_param.hpp
index bfbb386e87..db87a6ae72 100644
--- a/src/mlpack/bindings/python/get_printable_param.hpp
+++ b/src/mlpack/bindings/python/get_printable_param.hpp
@@ -25,11 +25,11 @@ namespace python {
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   std::ostringstream oss;
   oss << std::any_cast<T>(data.value);
@@ -42,7 +42,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   const T& t = std::any_cast<T>(data.value);
 
@@ -58,7 +58,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Get the matrix.
   const T& matrix = std::any_cast<T>(data.value);
@@ -74,8 +74,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   std::ostringstream oss;
   oss << data.cppType << " model at " << std::any_cast<T*>(data.value);
@@ -88,8 +88,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // Get the matrix.
   const T& tuple = std::any_cast<T>(data.value);
@@ -116,7 +116,7 @@ void GetPrintableParam(util::ParamData& data,
                        void* output)
 {
   *((std::string*) output) =
-      GetPrintableParam<typename std::remove_pointer<T>::type>(data);
+      GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/get_printable_type.hpp b/src/mlpack/bindings/python/get_printable_type.hpp
index 1d454b172a..741dd68061 100644
--- a/src/mlpack/bindings/python/get_printable_type.hpp
+++ b/src/mlpack/bindings/python/get_printable_type.hpp
@@ -23,87 +23,87 @@ namespace python {
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<>
 inline std::string GetPrintableType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<std::string,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!std::is_same_v<std::string,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<size_t>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<size_t>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<size_t>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<size_t>::value>::type*,
-    const typename std::enable_if<!std::is_same<size_t,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<size_t>::value>*,
+    const std::enable_if_t<!data::HasSerialize<size_t>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<size_t>::value>*,
+    const std::enable_if_t<!std::is_same_v<size_t,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<>
 inline std::string GetPrintableType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*);
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 template<typename T>
 void GetPrintableType(util::ParamData& d,
@@ -111,7 +111,7 @@ void GetPrintableType(util::ParamData& d,
                       void* output)
 {
   *((std::string*) output) =
-      GetPrintableType<typename std::remove_pointer<T>::type>(d);
+      GetPrintableType<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/get_printable_type_impl.hpp b/src/mlpack/bindings/python/get_printable_type_impl.hpp
index 5a903af575..fab3255956 100644
--- a/src/mlpack/bindings/python/get_printable_type_impl.hpp
+++ b/src/mlpack/bindings/python/get_printable_type_impl.hpp
@@ -22,11 +22,11 @@ namespace python {
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "unknown";
 }
@@ -34,11 +34,11 @@ inline std::string GetPrintableType(
 template<>
 inline std::string GetPrintableType<int>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<int>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<int>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<int>::value>::type*,
-    const typename std::enable_if<!std::is_same<int,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<int>::value>*,
+    const std::enable_if_t<!data::HasSerialize<int>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<int>::value>*,
+    const std::enable_if_t<!std::is_same_v<int,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "int";
 }
@@ -46,11 +46,11 @@ inline std::string GetPrintableType<int>(
 template<>
 inline std::string GetPrintableType<double>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<double>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<double>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<double>::value>::type*,
-    const typename std::enable_if<!std::is_same<double,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<double>::value>*,
+    const std::enable_if_t<!data::HasSerialize<double>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<double>::value>*,
+    const std::enable_if_t<!std::is_same_v<double,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "float";
 }
@@ -58,14 +58,14 @@ inline std::string GetPrintableType<double>(
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const typename std::enable_if<
-        !util::IsStdVector<std::string>::value>::type*,
-    const typename std::enable_if<
-        !data::HasSerialize<std::string>::value>::type*,
-    const typename std::enable_if<
-        !arma::is_arma_type<std::string>::value>::type*,
-    const typename std::enable_if<!std::is_same<std::string,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<
+        !util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<
+        !data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<
+        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!std::is_same_v<std::string,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "str";
 }
@@ -73,11 +73,11 @@ inline std::string GetPrintableType<std::string>(
 template<>
 inline std::string GetPrintableType<size_t>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<size_t>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<size_t>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<size_t>::value>::type*,
-    const typename std::enable_if<!std::is_same<size_t,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<size_t>::value>*,
+    const std::enable_if_t<!data::HasSerialize<size_t>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<size_t>::value>*,
+    const std::enable_if_t<!std::is_same_v<size_t,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "int";
 }
@@ -85,11 +85,11 @@ inline std::string GetPrintableType<size_t>(
 template<>
 inline std::string GetPrintableType<bool>(
     util::ParamData& /* d */,
-    const typename std::enable_if<!util::IsStdVector<bool>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<bool>::value>::type*,
-    const typename std::enable_if<!arma::is_arma_type<bool>::value>::type*,
-    const typename std::enable_if<!std::is_same<bool,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!util::IsStdVector<bool>::value>*,
+    const std::enable_if_t<!data::HasSerialize<bool>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<bool>::value>*,
+    const std::enable_if_t<!std::is_same_v<bool,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "bool";
 }
@@ -97,9 +97,9 @@ inline std::string GetPrintableType<bool>(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "list of " + GetPrintableType<typename T::value_type>(d) + "s";
 }
@@ -107,17 +107,17 @@ inline std::string GetPrintableType(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::string type = "matrix";
-  if (std::is_same<typename T::elem_type, double>::value)
+  if (std::is_same_v<typename T::elem_type, double>)
   {
     if (T::is_row || T::is_col)
       type = "vector";
   }
-  else if (std::is_same<typename T::elem_type, size_t>::value)
+  else if (std::is_same_v<typename T::elem_type, size_t>)
   {
     type = "int matrix";
     if (T::is_row || T::is_col)
@@ -130,8 +130,8 @@ inline std::string GetPrintableType(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& /* d */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "categorical matrix";
 }
@@ -139,10 +139,10 @@ inline std::string GetPrintableType(
 template<typename T>
 inline std::string GetPrintableType(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return d.cppType + "Type";
 }
diff --git a/src/mlpack/bindings/python/import_decl.hpp b/src/mlpack/bindings/python/import_decl.hpp
index e6518ce461..66edbc388f 100644
--- a/src/mlpack/bindings/python/import_decl.hpp
+++ b/src/mlpack/bindings/python/import_decl.hpp
@@ -26,8 +26,8 @@ template<typename T>
 void ImportDecl(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // First, we have to parse the type.  If we have something like, e.g.,
   // 'LogisticRegression<>', we must convert this to 'LogisticRegression[T=*].'
@@ -53,8 +53,8 @@ template<typename T>
 void ImportDecl(
     util::ParamData& /* d */,
     const size_t /* indent */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0)
 {
   // Print nothing.
 }
@@ -66,7 +66,7 @@ template<typename T>
 void ImportDecl(
     util::ParamData& /* d */,
     const size_t /* indent */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Print nothing.
 }
@@ -84,7 +84,7 @@ void ImportDecl(util::ParamData& d,
                 const void* indent,
                 void* /* output */)
 {
-  ImportDecl<typename std::remove_pointer<T>::type>(d, *((size_t*) indent));
+  ImportDecl<std::remove_pointer_t<T>>(d, *((size_t*) indent));
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/is_serializable.hpp b/src/mlpack/bindings/python/is_serializable.hpp
index 83197e87f3..0c326dd81c 100644
--- a/src/mlpack/bindings/python/is_serializable.hpp
+++ b/src/mlpack/bindings/python/is_serializable.hpp
@@ -21,7 +21,7 @@ namespace python {
 template<typename T>
 inline bool IsSerializable(
     util::ParamData& /* d */,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0)
 {
   return false;
 }
@@ -29,7 +29,7 @@ inline bool IsSerializable(
 template<typename T>
 inline bool IsSerializable(
     util::ParamData& /* d */,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   return true;
 }
@@ -40,7 +40,7 @@ void IsSerializable(util::ParamData& data,
                     void* output)
 {
   *((bool*) output) =
-      IsSerializable<typename std::remove_pointer<T>::type>(data);
+      IsSerializable<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/print_class_defn.hpp b/src/mlpack/bindings/python/print_class_defn.hpp
index b3938c4ff1..cd4a0b19a6 100644
--- a/src/mlpack/bindings/python/print_class_defn.hpp
+++ b/src/mlpack/bindings/python/print_class_defn.hpp
@@ -25,8 +25,8 @@ namespace python {
 template<typename T>
 void PrintClassDefn(
     util::ParamData& /* d */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0)
 {
   // Do nothing.
 }
@@ -37,7 +37,7 @@ void PrintClassDefn(
 template<typename T>
 void PrintClassDefn(
     util::ParamData& /* d */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   // Do nothing.
 }
@@ -48,8 +48,8 @@ void PrintClassDefn(
 template<typename T>
 void PrintClassDefn(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // First, we have to parse the type.  If we have something like, e.g.,
   // 'LogisticRegression<>', we must convert this to 'LogisticRegression[].'
@@ -153,7 +153,7 @@ void PrintClassDefn(util::ParamData& d,
                     const void* /* input */,
                     void* /* output */)
 {
-  PrintClassDefn<typename std::remove_pointer<T>::type>(d);
+  PrintClassDefn<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/print_defn.hpp b/src/mlpack/bindings/python/print_defn.hpp
index 06d1108352..7039510cb5 100644
--- a/src/mlpack/bindings/python/print_defn.hpp
+++ b/src/mlpack/bindings/python/print_defn.hpp
@@ -32,7 +32,7 @@ void PrintDefn(util::ParamData& d,
   std::string name = GetValidName(d.name);
 
   std::cout << name;
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     std::cout << "=False";
   else if (!d.required)
     std::cout << "=None";
diff --git a/src/mlpack/bindings/python/print_doc.hpp b/src/mlpack/bindings/python/print_doc.hpp
index eaf142b8bc..d9410c3a44 100644
--- a/src/mlpack/bindings/python/print_doc.hpp
+++ b/src/mlpack/bindings/python/print_doc.hpp
@@ -42,7 +42,7 @@ void PrintDoc(util::ParamData& d,
   oss << " - ";
   oss << GetValidName(d.name);
   oss << " (";
-  oss << GetPrintableType<typename std::remove_pointer<T>::type>(d) << "): "
+  oss << GetPrintableType<std::remove_pointer_t<T>>(d) << "): "
       << d.desc;
 
   // Print a default, if possible.
diff --git a/src/mlpack/bindings/python/print_input_processing.hpp b/src/mlpack/bindings/python/print_input_processing.hpp
index 86c163d489..e20a28503d 100644
--- a/src/mlpack/bindings/python/print_input_processing.hpp
+++ b/src/mlpack/bindings/python/print_input_processing.hpp
@@ -32,11 +32,11 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // The copy_all_inputs parameter must be handled first, and therefore is
   // outside the scope of this code.
@@ -46,7 +46,7 @@ void PrintInputProcessing(
   const std::string prefix(indent, ' ');
 
   std::string def = "None";
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
     def = "False";
 
   // Make sure that we don't use names that are Python keywords.
@@ -165,11 +165,11 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0,
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -255,8 +255,8 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -383,9 +383,9 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // First, get the correct class name if needed.
   std::string strippedType, printedType, defaultsType;
@@ -458,9 +458,9 @@ template<typename T>
 void PrintInputProcessing(
     util::ParamData& d,
     const size_t indent,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   std::string name = GetValidName(d.name);
 
@@ -550,7 +550,7 @@ void PrintInputProcessing(util::ParamData& d,
                           const void* input,
                           void* /* output */)
 {
-  PrintInputProcessing<typename std::remove_pointer<T>::type>(d,
+  PrintInputProcessing<std::remove_pointer_t<T>>(d,
       *((size_t*) input));
 }
 
diff --git a/src/mlpack/bindings/python/print_output_processing.hpp b/src/mlpack/bindings/python/print_output_processing.hpp
index 8082190013..01a1c13b0d 100644
--- a/src/mlpack/bindings/python/print_output_processing.hpp
+++ b/src/mlpack/bindings/python/print_output_processing.hpp
@@ -31,10 +31,10 @@ void PrintOutputProcessing(
     util::ParamData& d,
     const size_t indent,
     const bool onlyOutput,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -88,7 +88,7 @@ void PrintOutputProcessing(
     util::ParamData& d,
     const size_t indent,
     const bool onlyOutput,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -129,8 +129,8 @@ void PrintOutputProcessing(
     util::ParamData& d,
     const size_t indent,
     const bool onlyOutput,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   const std::string prefix(indent, ' ');
 
@@ -171,8 +171,8 @@ void PrintOutputProcessing(
     util::ParamData& d,
     const size_t indent,
     const bool onlyOutput,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Get the type names we need to use.
   std::string strippedType, printedType, defaultsType;
@@ -305,7 +305,7 @@ void PrintOutputProcessing(util::ParamData& d,
   typedef std::tuple<util::Params, std::tuple<size_t, bool>> TupleType;
   TupleType* tuple = (TupleType*) input;
 
-  PrintOutputProcessing<typename std::remove_pointer<T>::type>(
+  PrintOutputProcessing<std::remove_pointer_t<T>>(
       std::get<0>(*tuple), d, std::get<0>(std::get<1>(*tuple)),
       std::get<1>(std::get<1>(*tuple)));
 }
diff --git a/src/mlpack/bindings/python/print_type_doc.hpp b/src/mlpack/bindings/python/print_type_doc.hpp
index aad90ee4b7..2f4b906b8c 100644
--- a/src/mlpack/bindings/python/print_type_doc.hpp
+++ b/src/mlpack/bindings/python/print_type_doc.hpp
@@ -25,11 +25,11 @@ namespace python {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a vector.
@@ -37,7 +37,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix option.
@@ -45,7 +45,7 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Return a string representing the command-line type of a matrix tuple option.
@@ -53,8 +53,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Return a string representing the command-line type of a model.
@@ -62,8 +62,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Print the command-line type of an option into a string.
@@ -74,7 +74,7 @@ void PrintTypeDoc(util::ParamData& data,
                   void* output)
 {
   *((std::string*) output) =
-      PrintTypeDoc<typename std::remove_pointer<T>::type>(data);
+      PrintTypeDoc<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/print_type_doc_impl.hpp b/src/mlpack/bindings/python/print_type_doc_impl.hpp
index 7e50d24e85..fef2c61b95 100644
--- a/src/mlpack/bindings/python/print_type_doc_impl.hpp
+++ b/src/mlpack/bindings/python/print_type_doc_impl.hpp
@@ -24,29 +24,29 @@ namespace python {
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   // A flag type.
-  if (std::is_same<T, bool>::value)
+  if (std::is_same_v<T, bool>)
   {
     return "A boolean flag option (True or False).";
   }
   // An integer.
-  else if (std::is_same<T, int>::value)
+  else if (std::is_same_v<T, int>)
   {
     return "An integer (i.e., \"1\").";
   }
   // A floating point value.
-  else if (std::is_same<T, double>::value)
+  else if (std::is_same_v<T, double>)
   {
     return "A floating-point number (i.e., \"0.5\").";
   }
   // A string.
-  else if (std::is_same<T, std::string>::value)
+  else if (std::is_same_v<T, std::string>)
   {
     return "A character string (i.e., \"hello\").";
   }
@@ -63,13 +63,13 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
-  if (std::is_same<T, std::vector<int>>::value)
+  if (std::is_same_v<T, std::vector<int>>)
   {
     return "A list of integers; i.e., `[0, 1, 2]`.";
   }
-  else if (std::is_same<T, std::vector<std::string>>::value)
+  else if (std::is_same_v<T, std::vector<std::string>>)
   {
     return "A list of strings; i.e., `[\"hello\", \"goodbye\"]`.";
   }
@@ -85,9 +85,9 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
-  if (std::is_same<typename T::elem_type, double>::value)
+  if (std::is_same_v<typename T::elem_type, double>)
   {
     if (T::is_col || T::is_row)
     {
@@ -103,7 +103,7 @@ std::string PrintTypeDoc(
           "float64, it will be converted.";
     }
   }
-  else if (std::is_same<typename T::elem_type, size_t>::value)
+  else if (std::is_same_v<typename T::elem_type, size_t>)
   {
     if (T::is_col || T::is_row)
     {
@@ -131,8 +131,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   return "A 2-d arraylike containing data.  Like the regular 2-d matrices, this"
       " can be a list of lists, a numpy ndarray, or a pandas DataFrame. "
@@ -150,8 +150,8 @@ std::string PrintTypeDoc(
 template<typename T>
 std::string PrintTypeDoc(
     util::ParamData& /* data */,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   return "An mlpack model pointer.  This type can be pickled to or from disk, "
       "and internally holds a pointer to C++ memory containing the mlpack "
diff --git a/src/mlpack/bindings/tests/delete_allocated_memory.hpp b/src/mlpack/bindings/tests/delete_allocated_memory.hpp
index 033a7527a0..e882159b45 100644
--- a/src/mlpack/bindings/tests/delete_allocated_memory.hpp
+++ b/src/mlpack/bindings/tests/delete_allocated_memory.hpp
@@ -21,8 +21,8 @@ namespace tests {
 template<typename T>
 void DeleteAllocatedMemoryImpl(
     util::ParamData& /* d */,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0)
 {
   // Do nothing.
 }
@@ -30,7 +30,7 @@ void DeleteAllocatedMemoryImpl(
 template<typename T>
 void DeleteAllocatedMemoryImpl(
     util::ParamData& d,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   (*std::any_cast<T>(&d.value)).clear();
 }
@@ -38,8 +38,8 @@ void DeleteAllocatedMemoryImpl(
 template<typename T>
 void DeleteAllocatedMemoryImpl(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Delete the allocated memory (hopefully we actually own it).
   delete *std::any_cast<T*>(&d.value);
@@ -51,7 +51,7 @@ void DeleteAllocatedMemory(
     const void* /* input */,
     void* /* output */)
 {
-  DeleteAllocatedMemoryImpl<typename std::remove_pointer<T>::type>(d);
+  DeleteAllocatedMemoryImpl<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace tests
diff --git a/src/mlpack/bindings/tests/get_allocated_memory.hpp b/src/mlpack/bindings/tests/get_allocated_memory.hpp
index fc936c48d9..dccf4f2a6c 100644
--- a/src/mlpack/bindings/tests/get_allocated_memory.hpp
+++ b/src/mlpack/bindings/tests/get_allocated_memory.hpp
@@ -22,8 +22,8 @@ namespace tests {
 template<typename T>
 void* GetAllocatedMemory(
     util::ParamData& /* d */,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0)
 {
   return NULL;
 }
@@ -31,7 +31,7 @@ void* GetAllocatedMemory(
 template<typename T>
 void* GetAllocatedMemory(
     util::ParamData& d,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0)
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
 {
   return (*std::any_cast<T>(&d.value)).memptr();
 }
@@ -39,8 +39,8 @@ void* GetAllocatedMemory(
 template<typename T>
 void* GetAllocatedMemory(
     util::ParamData& d,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Here we have a model; return its memory location.
   return *std::any_cast<T*>(&d.value);
@@ -52,7 +52,7 @@ void GetAllocatedMemory(util::ParamData& d,
                         void* output)
 {
   *((void**) output) =
-      GetAllocatedMemory<typename std::remove_pointer<T>::type>(d);
+      GetAllocatedMemory<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace tests
diff --git a/src/mlpack/bindings/tests/get_printable_param.hpp b/src/mlpack/bindings/tests/get_printable_param.hpp
index 0bf5e2ff24..c7f12cd08f 100644
--- a/src/mlpack/bindings/tests/get_printable_param.hpp
+++ b/src/mlpack/bindings/tests/get_printable_param.hpp
@@ -27,11 +27,11 @@ namespace tests {
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type* = 0,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type* = 0,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
+    const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print a vector option, with spaces between it.
@@ -39,7 +39,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type* = 0);
+    const std::enable_if_t<util::IsStdVector<T>::value>* = 0);
 
 /**
  * Print a matrix option (this just prints the filename).
@@ -47,7 +47,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type* = 0);
+    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0);
 
 /**
  * Print a serializable class option (this just prints the filename).
@@ -55,8 +55,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type* = 0,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type* = 0);
+    const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0);
 
 /**
  * Print a mapped matrix option (this just prints the filename).
@@ -64,8 +64,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* = 0);
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
  * Print an option into a std::string.  This should print a short, one-line
@@ -78,7 +78,7 @@ void GetPrintableParam(util::ParamData& data,
                        void* output)
 {
   *((std::string*) output) =
-      GetPrintableParam<typename std::remove_pointer<T>::type>(data);
+      GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace tests
diff --git a/src/mlpack/bindings/tests/get_printable_param_impl.hpp b/src/mlpack/bindings/tests/get_printable_param_impl.hpp
index c800a0aa7a..5015fffca3 100644
--- a/src/mlpack/bindings/tests/get_printable_param_impl.hpp
+++ b/src/mlpack/bindings/tests/get_printable_param_impl.hpp
@@ -22,11 +22,11 @@ namespace tests {
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<!util::IsStdVector<T>::value>::type*,
-    const typename std::enable_if<!data::HasSerialize<T>::value>::type*,
-    const typename std::enable_if<!std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<!util::IsStdVector<T>::value>*,
+    const std::enable_if_t<!data::HasSerialize<T>::value>*,
+    const std::enable_if_t<!std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
   std::ostringstream oss;
   oss << std::any_cast<T>(data.value);
@@ -37,7 +37,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<util::IsStdVector<T>::value>::type*)
+    const std::enable_if_t<util::IsStdVector<T>::value>*)
 {
   const T& t = std::any_cast<T>(data.value);
 
@@ -51,7 +51,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& /* data */,
-    const typename std::enable_if<arma::is_arma_type<T>::value>::type*)
+    const std::enable_if_t<arma::is_arma_type<T>::value>*)
 {
   return "matrix type";
 }
@@ -60,8 +60,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const typename std::enable_if<!arma::is_arma_type<T>::value>::type*,
-    const typename std::enable_if<data::HasSerialize<T>::value>::type*)
+    const std::enable_if_t<!arma::is_arma_type<T>::value>*,
+    const std::enable_if_t<data::HasSerialize<T>::value>*)
 {
   // Extract the string from the tuple that's being held.
   std::ostringstream oss;
@@ -73,8 +73,8 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& /* data */,
-    const typename std::enable_if<std::is_same<T,
-        std::tuple<data::DatasetInfo, arma::mat>>::value>::type* /* junk */)
+    const std::enable_if_t<std::is_same_v<T,
+        std::tuple<data::DatasetInfo, arma::mat>>>* /* junk */)
 {
   return "matrix/DatatsetInfo tuple";
 }
diff --git a/src/mlpack/core/cereal/is_loading.hpp b/src/mlpack/core/cereal/is_loading.hpp
index 085358b2f4..3be9d12426 100644
--- a/src/mlpack/core/cereal/is_loading.hpp
+++ b/src/mlpack/core/cereal/is_loading.hpp
@@ -28,26 +28,26 @@ struct is_cereal_archive
 {
   // Archive::is_loading is not implemented yet, so we can use std::is_same<>
   // to check if it is a loading archive.
-  constexpr static bool value = std::is_same<Archive,
-      cereal::BinaryInputArchive>::value ||
+  constexpr static bool value = std::is_same_v<Archive,
+      cereal::BinaryInputArchive> ||
 // #if (BINDING_TYPE != BINDING_TYPE_R)
-      std::is_same<Archive, cereal::JSONInputArchive>::value ||
+      std::is_same_v<Archive, cereal::JSONInputArchive> ||
 // #endif
-      std::is_same<Archive, cereal::XMLInputArchive>::value;
+      std::is_same_v<Archive, cereal::XMLInputArchive>;
 };
 
 template<typename Archive>
 bool is_loading(
-    const typename std::enable_if<
-        is_cereal_archive<Archive>::value, Archive>::type* = 0)
+    const std::enable_if_t<
+        is_cereal_archive<Archive>::value, Archive>* = 0)
 {
   return true;
 }
 
 template<typename Archive>
 bool is_loading(
-    const typename std::enable_if<
-      !is_cereal_archive<Archive>::value, Archive>::type* = 0)
+    const std::enable_if_t<
+      !is_cereal_archive<Archive>::value, Archive>* = 0)
 {
   return false;
 }
diff --git a/src/mlpack/core/cereal/is_saving.hpp b/src/mlpack/core/cereal/is_saving.hpp
index e54362913f..6a23333a7f 100644
--- a/src/mlpack/core/cereal/is_saving.hpp
+++ b/src/mlpack/core/cereal/is_saving.hpp
@@ -29,26 +29,26 @@ struct is_cereal_archive_saving
 {
   // Archive::is_saving is not implemented yet, so we can use std::is_same<>
   // to check if it is a loading archive.
-  constexpr static bool value = std::is_same<Archive,
-      cereal::BinaryOutputArchive>::value ||
+  constexpr static bool value = std::is_same_v<Archive,
+      cereal::BinaryOutputArchive> ||
 // #if (BINDING_TYPE != BINDING_TYPE_R)
-      std::is_same<Archive, cereal::JSONOutputArchive>::value ||
+      std::is_same_v<Archive, cereal::JSONOutputArchive> ||
 // #endif
-      std::is_same<Archive, cereal::XMLOutputArchive>::value;
+      std::is_same_v<Archive, cereal::XMLOutputArchive>;
 };
 
 template<typename Archive>
 bool is_saving(
-    const typename std::enable_if<
-        is_cereal_archive_saving<Archive>::value, Archive>::type* = 0)
+    const std::enable_if_t<
+        is_cereal_archive_saving<Archive>::value, Archive>* = 0)
 {
   return true;
 }
 
 template<typename Archive>
 bool is_saving(
-    const typename std::enable_if<
-      !is_cereal_archive_saving<Archive>::value, Archive>::type* = 0)
+    const std::enable_if_t<
+      !is_cereal_archive_saving<Archive>::value, Archive>* = 0)
 {
   return false;
 }
diff --git a/src/mlpack/core/cv/cv_base.hpp b/src/mlpack/core/cv/cv_base.hpp
index 02166eb4e0..832f65a694 100644
--- a/src/mlpack/core/cv/cv_base.hpp
+++ b/src/mlpack/core/cv/cv_base.hpp
@@ -126,7 +126,7 @@ class CVBase
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = !MIE::TakesNumClasses,
-           typename = typename std::enable_if<Enabled>::type>
+           typename = std::enable_if_t<Enabled>>
   MLAlgorithm TrainModel(const MatType& xs,
                          const PredictionsType& ys,
                          const MLAlgorithmArgs&... args);
@@ -137,7 +137,7 @@ class CVBase
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = MIE::TakesNumClasses & !MIE::TakesDatasetInfo,
-           typename = typename std::enable_if<Enabled>::type,
+           typename = std::enable_if_t<Enabled>,
            typename = void>
   MLAlgorithm TrainModel(const MatType& xs,
                          const PredictionsType& ys,
@@ -149,7 +149,7 @@ class CVBase
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = MIE::TakesNumClasses & MIE::TakesDatasetInfo,
-           typename = typename std::enable_if<Enabled>::type,
+           typename = std::enable_if_t<Enabled>,
            typename = void,
            typename = void>
   MLAlgorithm TrainModel(const MatType& xs,
@@ -162,7 +162,7 @@ class CVBase
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = !MIE::TakesNumClasses,
-           typename = typename std::enable_if<Enabled>::type>
+           typename = std::enable_if_t<Enabled>>
   MLAlgorithm TrainModel(const MatType& xs,
                          const PredictionsType& ys,
                          const WeightsType& weights,
@@ -174,7 +174,7 @@ class CVBase
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = MIE::TakesNumClasses & !MIE::TakesDatasetInfo,
-           typename = typename std::enable_if<Enabled>::type,
+           typename = std::enable_if_t<Enabled>,
            typename = void>
   MLAlgorithm TrainModel(const MatType& xs,
                          const PredictionsType& ys,
@@ -187,7 +187,7 @@ class CVBase
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = MIE::TakesNumClasses & MIE::TakesDatasetInfo,
-           typename = typename std::enable_if<Enabled>::type,
+           typename = std::enable_if_t<Enabled>,
            typename = void,
            typename = void>
   MLAlgorithm TrainModel(const MatType& xs,
@@ -207,7 +207,7 @@ class CVBase
   template<bool ConstructableWithoutDatasetInfo,
            typename... MLAlgorithmArgs,
            typename =
-               typename std::enable_if<ConstructableWithoutDatasetInfo>::type>
+               std::enable_if_t<ConstructableWithoutDatasetInfo>>
   MLAlgorithm TrainModel(const MatType& xs,
                          const PredictionsType& ys,
                          const MLAlgorithmArgs&... args);
@@ -219,7 +219,7 @@ class CVBase
   template<bool ConstructableWithoutDatasetInfo,
            typename... MLAlgorithmArgs,
            typename =
-               typename std::enable_if<!ConstructableWithoutDatasetInfo>::type,
+               std::enable_if_t<!ConstructableWithoutDatasetInfo>,
            typename = void>
   MLAlgorithm TrainModel(const MatType& xs,
                          const PredictionsType& ys,
diff --git a/src/mlpack/core/cv/cv_base_impl.hpp b/src/mlpack/core/cv/cv_base_impl.hpp
index d5e5acc7b0..33d48a68cb 100644
--- a/src/mlpack/core/cv/cv_base_impl.hpp
+++ b/src/mlpack/core/cv/cv_base_impl.hpp
@@ -141,8 +141,8 @@ MLAlgorithm CVBase<MLAlgorithm,
                                             const MLAlgorithmArgs&... args)
 {
   static_assert(
-      std::is_constructible<MLAlgorithm, const MatType&, const PredictionsType&,
-          MLAlgorithmArgs...>::value,
+      std::is_constructible_v<MLAlgorithm,
+          const MatType&, const PredictionsType&, MLAlgorithmArgs...>,
       "The given MLAlgorithm is not constructible from the passed arguments");
 
   return MLAlgorithm(xs, ys, args...);
@@ -161,8 +161,9 @@ MLAlgorithm CVBase<MLAlgorithm,
                                             const MLAlgorithmArgs&... args)
 {
   static_assert(
-      std::is_constructible<MLAlgorithm, const MatType&, const PredictionsType&,
-          const size_t, MLAlgorithmArgs...>::value,
+      std::is_constructible_v<MLAlgorithm,
+          const MatType&, const PredictionsType&,
+          const size_t, MLAlgorithmArgs...>,
       "The given MLAlgorithm is not constructible from the passed arguments");
 
   return MLAlgorithm(xs, ys, numClasses, args...);
@@ -182,15 +183,16 @@ MLAlgorithm CVBase<MLAlgorithm,
                                             const MLAlgorithmArgs&... args)
 {
   static_assert(
-      std::is_constructible<MLAlgorithm, const MatType&,
+      std::is_constructible_v<MLAlgorithm, const MatType&,
           const data::DatasetInfo, const PredictionsType&, const size_t,
-              MLAlgorithmArgs...>::value,
+              MLAlgorithmArgs...>,
       "The given MLAlgorithm is not constructible with a data::DatasetInfo "
       "parameter and the passed arguments");
 
   static const bool constructableWithoutDatasetInfo =
-      std::is_constructible<MLAlgorithm, const MatType&, const PredictionsType&,
-          const size_t, MLAlgorithmArgs...>::value;
+      std::is_constructible_v<MLAlgorithm,
+          const MatType&, const PredictionsType&,
+          const size_t, MLAlgorithmArgs...>;
   return TrainModel<constructableWithoutDatasetInfo>(xs, ys, args...);
 }
 
@@ -208,8 +210,9 @@ MLAlgorithm CVBase<MLAlgorithm,
                                             const MLAlgorithmArgs&... args)
 {
   static_assert(
-      std::is_constructible<MLAlgorithm, const MatType&, const PredictionsType&,
-          const WeightsType&, MLAlgorithmArgs...>::value,
+      std::is_constructible_v<MLAlgorithm,
+          const MatType&, const PredictionsType&,
+          const WeightsType&, MLAlgorithmArgs...>,
       "The given MLAlgorithm is not constructible from the passed arguments");
 
   return MLAlgorithm(xs, ys, weights, args...);
@@ -229,8 +232,9 @@ MLAlgorithm CVBase<MLAlgorithm,
                                             const MLAlgorithmArgs&... args)
 {
   static_assert(
-      std::is_constructible<MLAlgorithm, const MatType&, const PredictionsType&,
-          const size_t, const WeightsType&, MLAlgorithmArgs...>::value,
+      std::is_constructible_v<MLAlgorithm,
+          const MatType&, const PredictionsType&,
+          const size_t, const WeightsType&, MLAlgorithmArgs...>,
       "The given MLAlgorithm is not constructible from the passed arguments");
 
   return MLAlgorithm(xs, ys, numClasses, weights, args...);
@@ -251,15 +255,16 @@ MLAlgorithm CVBase<MLAlgorithm,
                                            const MLAlgorithmArgs&... args)
 {
   static_assert(
-      std::is_constructible<MLAlgorithm, const MatType&,
+      std::is_constructible_v<MLAlgorithm, const MatType&,
           const data::DatasetInfo, const PredictionsType&, const size_t,
-              const WeightsType&, MLAlgorithmArgs...>::value,
+              const WeightsType&, MLAlgorithmArgs...>,
       "The given MLAlgorithm is not constructible with a data::DatasetInfo "
       "parameter and the passed arguments");
 
   static const bool constructableWithoutDatasetInfo =
-      std::is_constructible<MLAlgorithm, const MatType&, const PredictionsType&,
-          const size_t, const WeightsType&, MLAlgorithmArgs...>::value;
+      std::is_constructible_v<MLAlgorithm,
+          const MatType&, const PredictionsType&,
+          const size_t, const WeightsType&, MLAlgorithmArgs...>;
   return TrainModel<constructableWithoutDatasetInfo>(xs, ys, weights, args...);
 }
 
diff --git a/src/mlpack/core/cv/k_fold_cv.hpp b/src/mlpack/core/cv/k_fold_cv.hpp
index 652975cbaf..3538236180 100644
--- a/src/mlpack/core/cv/k_fold_cv.hpp
+++ b/src/mlpack/core/cv/k_fold_cv.hpp
@@ -189,7 +189,7 @@ class KFoldCV
    * the model type.
    */
   template<bool Enabled = !Base::MIE::SupportsWeights,
-           typename = typename std::enable_if<Enabled>::type>
+           typename = std::enable_if_t<Enabled>>
   void Shuffle();
 
   /**
@@ -197,7 +197,7 @@ class KFoldCV
    * model type.
    */
   template<bool Enabled = Base::MIE::SupportsWeights,
-           typename = typename std::enable_if<Enabled>::type,
+           typename = std::enable_if_t<Enabled>,
            typename = void>
   void Shuffle();
 
@@ -257,7 +257,7 @@ class KFoldCV
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = !Base::MIE::SupportsWeights,
-           typename = typename std::enable_if<Enabled>::type>
+           typename = std::enable_if_t<Enabled>>
   double TrainAndEvaluate(const MLAlgorithmArgs& ...mlAlgorithmArgs);
 
   /**
@@ -265,7 +265,7 @@ class KFoldCV
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = Base::MIE::SupportsWeights,
-           typename = typename std::enable_if<Enabled>::type,
+           typename = std::enable_if_t<Enabled>,
            typename = void>
   double TrainAndEvaluate(const MLAlgorithmArgs& ...mlAlgorithmArgs);
 
diff --git a/src/mlpack/core/cv/meta_info_extractor.hpp b/src/mlpack/core/cv/meta_info_extractor.hpp
index 936501da40..704bb62842 100644
--- a/src/mlpack/core/cv/meta_info_extractor.hpp
+++ b/src/mlpack/core/cv/meta_info_extractor.hpp
@@ -217,11 +217,11 @@ struct SelectMethodForm<MLAlgorithm, HasMethodForm, HMFs...>
     template<typename Form, typename... RemainingForms>
     struct Implementation<Form, RemainingForms...>
     {
-      using Type = typename std::conditional<
+      using Type = std::conditional_t<
           HasMethodForm<MLAlgorithm, Form::template Type,
               Form::MinNumberOfAdditionalArgs>::value,
           Form,
-          typename Implementation<RemainingForms...>::Type>::type;
+          typename Implementation<RemainingForms...>::Type>;
     };
 
    public:
@@ -305,9 +305,9 @@ class MetaInfoExtractor
 
   /* An indication whether a method form is selected */
   template<typename... MFs /* MethodForms */>
-  using Selects = typename std::conditional<
-      std::is_same<typename Select<MFs...>::Type, NotFoundMethodForm>::value,
-      std::false_type, std::true_type>::type;
+  using Selects = std::conditional_t<
+      std::is_same_v<typename Select<MFs...>::Type, NotFoundMethodForm>,
+      std::false_type, std::true_type>;
 
  public:
   /**
@@ -328,12 +328,12 @@ class MetaInfoExtractor
    * An indication whether PredictionsType has been identified (i.e. MLAlgorithm
    * is supported by MetaInfoExtractor).
    */
-  static const bool IsSupported = !std::is_same<PredictionsType, void*>::value;
+  static const bool IsSupported = !std::is_same_v<PredictionsType, void*>;
 
   /**
    * An indication whether MLAlgorithm supports weighted learning.
    */
-  static const bool SupportsWeights = !std::is_same<WeightsType, void*>::value;
+  static const bool SupportsWeights = !std::is_same_v<WeightsType, void*>;
 
   /**
    * An indication whether MLAlgorithm takes a data::DatasetInfo parameter.
diff --git a/src/mlpack/core/cv/simple_cv.hpp b/src/mlpack/core/cv/simple_cv.hpp
index fa2c985b86..573b6006ce 100644
--- a/src/mlpack/core/cv/simple_cv.hpp
+++ b/src/mlpack/core/cv/simple_cv.hpp
@@ -289,7 +289,7 @@ class SimpleCV
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = !Base::MIE::SupportsWeights,
-           typename = typename std::enable_if<Enabled>::type>
+           typename = std::enable_if_t<Enabled>>
   double TrainAndEvaluate(const MLAlgorithmArgs&... args);
 
   /**
@@ -297,7 +297,7 @@ class SimpleCV
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = Base::MIE::SupportsWeights,
-           typename = typename std::enable_if<Enabled>::type,
+           typename = std::enable_if_t<Enabled>,
            typename = void>
   double TrainAndEvaluate(const MLAlgorithmArgs&... args);
 };
diff --git a/src/mlpack/core/data/dataset_mapper_impl.hpp b/src/mlpack/core/data/dataset_mapper_impl.hpp
index 7422adc673..46c8c61ca9 100644
--- a/src/mlpack/core/data/dataset_mapper_impl.hpp
+++ b/src/mlpack/core/data/dataset_mapper_impl.hpp
@@ -52,7 +52,7 @@ void CallMapFirstPass(
     const InputType& input,
     const size_t dimension,
     std::vector<Datatype>& types,
-    const typename std::enable_if<PolicyType::NeedsFirstPass>::type* = 0)
+    const std::enable_if_t<PolicyType::NeedsFirstPass>* = 0)
 {
   policy.template MapFirstPass<T>(input, dimension, types);
 }
@@ -64,7 +64,7 @@ void CallMapFirstPass(
     const InputType& /* input */,
     const size_t /* dimension */,
     std::vector<Datatype>& /* types */,
-    const typename std::enable_if<!PolicyType::NeedsFirstPass>::type* = 0)
+    const std::enable_if_t<!PolicyType::NeedsFirstPass>* = 0)
 {
   // Nothing to do here.
 }
diff --git a/src/mlpack/core/data/has_serialize.hpp b/src/mlpack/core/data/has_serialize.hpp
index 7c2c3d114a..8eee0813ce 100644
--- a/src/mlpack/core/data/has_serialize.hpp
+++ b/src/mlpack/core/data/has_serialize.hpp
@@ -52,7 +52,7 @@ struct HasSerialize
   template<typename U, typename V, typename W> struct check;
   template<typename U> static yes& chk( // This matches classes.
       check<U,
-            typename std::enable_if_t<std::is_class<U>::value>*,
+            typename std::enable_if_t<std::is_class_v<U>>*,
             typename std::enable_if_t<HasSerializeFunction<U>::value>*>*);
   template<typename  > static no&  chk(...); // This matches non-classes.
 
diff --git a/src/mlpack/core/data/load_numeric_csv.hpp b/src/mlpack/core/data/load_numeric_csv.hpp
index 7fba6e6498..c8bfdb3735 100644
--- a/src/mlpack/core/data/load_numeric_csv.hpp
+++ b/src/mlpack/core/data/load_numeric_csv.hpp
@@ -24,7 +24,7 @@ namespace data {
 template<typename eT>
 inline eT SafeNegInf(
     const bool neg,
-    const typename std::enable_if<std::is_unsigned<eT>::value>::type* = 0)
+    const std::enable_if_t<std::is_unsigned_v<eT>>* = 0)
 {
   // For an unsigned type, we cannot return negative infinity, so instead return
   // 0.
@@ -34,7 +34,7 @@ inline eT SafeNegInf(
 template<typename eT>
 inline eT SafeNegInf(
     const bool neg,
-    const typename std::enable_if<!std::is_unsigned<eT>::value>::type* = 0)
+    const std::enable_if_t<!std::is_unsigned_v<eT>>* = 0)
 {
   return neg ? -(std::numeric_limits<eT>::infinity()) :
       std::numeric_limits<eT>::infinity();
@@ -88,13 +88,13 @@ bool LoadCSV::ConvertToken(eT& val,
   // Convert the token into correct type.
   // If we have a eT as unsigned int,
   // it will convert all negative numbers to 0.
-  if (std::is_floating_point<eT>::value)
+  if (std::is_floating_point_v<eT>)
   {
     val = eT(std::strtod(str, &endptr));
   }
-  else if (std::is_integral<eT>::value)
+  else if (std::is_integral_v<eT>)
   {
-    if (std::is_signed<eT>::value)
+    if (std::is_signed_v<eT>)
       val = eT(std::strtoll(str, &endptr, 10));
     else
     {
diff --git a/src/mlpack/core/data/string_encoding.hpp b/src/mlpack/core/data/string_encoding.hpp
index 95067de79f..8edc498d5b 100644
--- a/src/mlpack/core/data/string_encoding.hpp
+++ b/src/mlpack/core/data/string_encoding.hpp
@@ -198,8 +198,8 @@ class StringEncoding
                     std::vector<std::vector<ElemType>>& output,
                     const TokenizerType& tokenizer,
                     PolicyType& policy,
-                    typename std::enable_if<StringEncodingPolicyTraits<
-                        PolicyType>::onePassEncoding>::type* = 0);
+                    std::enable_if_t<StringEncodingPolicyTraits<
+                        PolicyType>::onePassEncoding>* = 0);
 
  private:
   //! The encoding policy object.
diff --git a/src/mlpack/core/data/string_encoding_impl.hpp b/src/mlpack/core/data/string_encoding_impl.hpp
index cee7a5665f..2a0f091161 100644
--- a/src/mlpack/core/data/string_encoding_impl.hpp
+++ b/src/mlpack/core/data/string_encoding_impl.hpp
@@ -70,9 +70,9 @@ void StringEncoding<EncodingPolicyType, DictionaryType>::CreateMap(
   auto token = tokenizer(strView);
 
   static_assert(
-      std::is_same<typename std::remove_reference<decltype(token)>::type,
-                   typename std::remove_reference<typename DictionaryType::
-                      TokenType>::type>::value,
+      std::is_same_v<std::remove_reference_t<decltype(token)>,
+                   std::remove_reference_t<typename DictionaryType::
+                      TokenType>>,
       "The dictionary token type doesn't match the return value type "
       "of the tokenizer.");
 
@@ -116,9 +116,9 @@ EncodeHelper(const std::vector<std::string>& input,
     auto token = tokenizer(strView);
 
     static_assert(
-        std::is_same<typename std::remove_reference<decltype(token)>::type,
-                     typename std::remove_reference<typename DictionaryType::
-                        TokenType>::type>::value,
+        std::is_same_v<std::remove_reference_t<decltype(token)>,
+                     std::remove_reference_t<typename DictionaryType::
+                        TokenType>>,
         "The dictionary token type doesn't match the return value type "
         "of the tokenizer.");
 
@@ -163,8 +163,8 @@ EncodeHelper(const std::vector<std::string>& input,
              std::vector<std::vector<ElemType>>& output,
              const TokenizerType& tokenizer,
              PolicyType& policy,
-             typename std::enable_if<StringEncodingPolicyTraits<
-                 PolicyType>::onePassEncoding>::type*)
+             std::enable_if_t<StringEncodingPolicyTraits<
+                 PolicyType>::onePassEncoding>*)
 {
   policy.Reset();
 
@@ -176,9 +176,9 @@ EncodeHelper(const std::vector<std::string>& input,
     auto token = tokenizer(strView);
 
     static_assert(
-        std::is_same<typename std::remove_reference<decltype(token)>::type,
-                     typename std::remove_reference<typename DictionaryType::
-                        TokenType>::type>::value,
+        std::is_same_v<std::remove_reference_t<decltype(token)>,
+                     std::remove_reference_t<typename DictionaryType::
+                        TokenType>>,
         "The dictionary token type doesn't match the return value type "
         "of the tokenizer.");
 
diff --git a/src/mlpack/core/distributions/discrete_distribution.hpp b/src/mlpack/core/distributions/discrete_distribution.hpp
index 3821cafa72..c309ece04d 100644
--- a/src/mlpack/core/distributions/discrete_distribution.hpp
+++ b/src/mlpack/core/distributions/discrete_distribution.hpp
@@ -153,7 +153,7 @@ class DiscreteDistribution
     {
       // Adding 0.5 helps ensure that we cast the floating point to a size_t
       // correctly.
-      const size_t obs = (std::is_floating_point<ObsType>::value) ?
+      const size_t obs = (std::is_floating_point_v<ObsType>) ?
           size_t(observation(dimension) + 0.5) : size_t(observation(dimension));
 
       // Ensure that the observation is within the bounds.
diff --git a/src/mlpack/core/distributions/discrete_distribution_impl.hpp b/src/mlpack/core/distributions/discrete_distribution_impl.hpp
index 360c382a94..1c232501be 100644
--- a/src/mlpack/core/distributions/discrete_distribution_impl.hpp
+++ b/src/mlpack/core/distributions/discrete_distribution_impl.hpp
@@ -83,7 +83,7 @@ inline void DiscreteDistribution<MatType, ObsMatType>::Train(
       // Add the probability of each observation.  The addition of 0.5 to the
       // observation is to turn the default flooring operation of the size_t
       // cast into a rounding observation.
-      const size_t obs = (std::is_floating_point<ObsType>::value) ?
+      const size_t obs = (std::is_floating_point_v<ObsType>) ?
           size_t(observations(i, r) + 0.5) : size_t(observations(i, r));
 
       // Ensure that the observation is within the bounds.
@@ -141,7 +141,7 @@ inline void DiscreteDistribution<MatType, ObsMatType>::Train(
       // Add the probability of each observation. The addition of 0.5
       // to the observation is to turn the default flooring operation
       // of the size_t cast into a rounding observation.
-      const size_t obs = (std::is_floating_point<ObsType>::value) ?
+      const size_t obs = (std::is_floating_point_v<ObsType>) ?
           size_t(observations(i, r) + 0.5) : size_t(observations(i, r));
 
       // Ensure that the observation is within the bounds.
diff --git a/src/mlpack/core/distributions/gamma_distribution.hpp b/src/mlpack/core/distributions/gamma_distribution.hpp
index b1b8079a99..f9364b3899 100644
--- a/src/mlpack/core/distributions/gamma_distribution.hpp
+++ b/src/mlpack/core/distributions/gamma_distribution.hpp
@@ -75,7 +75,7 @@ class GammaDistribution
    */
   GammaDistribution(const MatType& data,
                     const ElemType tol =
-                        std::is_same<ElemType, float>::value ? 1e-4 : 1e-8);
+                        std::is_same_v<ElemType, float> ? 1e-4 : 1e-8);
 
   /**
    * Construct the Gamma distribution given two vectors alpha and beta.
@@ -101,7 +101,7 @@ class GammaDistribution
    */
   void Train(const MatType& rdata,
              const ElemType tol =
-                 std::is_same<ElemType, float>::value ? 1e-4 : 1e-8);
+                 std::is_same_v<ElemType, float> ? 1e-4 : 1e-8);
 
   /**
    * Fits an alpha and beta parameter according to observation probabilities.
@@ -117,7 +117,7 @@ class GammaDistribution
   void Train(const MatType& observations,
              const VecType& probabilities,
              const ElemType tol =
-                 std::is_same<ElemType, float>::value ? 1e-4 : 1e-8);
+                 std::is_same_v<ElemType, float> ? 1e-4 : 1e-8);
 
   /**
    * This function trains (fits distribution parameters) to a dataset with
@@ -136,7 +136,7 @@ class GammaDistribution
              const VecType& meanLogxVec,
              const VecType& meanxVec,
              const ElemType tol =
-                 std::is_same<ElemType, float>::value ? 1e-4 : 1e-8);
+                 std::is_same_v<ElemType, float> ? 1e-4 : 1e-8);
 
   /**
    * This function returns the probability of a group of observations.
diff --git a/src/mlpack/core/hpt/cv_function.hpp b/src/mlpack/core/hpt/cv_function.hpp
index 9fef73a7a4..264b878d7d 100644
--- a/src/mlpack/core/hpt/cv_function.hpp
+++ b/src/mlpack/core/hpt/cv_function.hpp
@@ -130,8 +130,8 @@ class CVFunction
   template<size_t BoundArgIndex,
            size_t ParamIndex,
            typename... Args,
-           typename = typename
-               std::enable_if<(BoundArgIndex + ParamIndex < TotalArgs)>::type>
+           typename = 
+               std::enable_if_t<(BoundArgIndex + ParamIndex < TotalArgs)>>
   inline double Evaluate(const arma::mat& parameters, const Args&... args);
 
   /**
@@ -140,8 +140,8 @@ class CVFunction
   template<size_t BoundArgIndex,
            size_t ParamIndex,
            typename... Args,
-           typename = typename
-               std::enable_if<BoundArgIndex + ParamIndex == TotalArgs>::type,
+           typename = 
+               std::enable_if_t<BoundArgIndex + ParamIndex == TotalArgs>,
            typename = void>
   inline double Evaluate(const arma::mat& parameters, const Args&... args);
 
@@ -151,8 +151,8 @@ class CVFunction
   template<size_t BoundArgIndex,
            size_t ParamIndex,
            typename... Args,
-           typename = typename std::enable_if<
-               UseBoundArg<BoundArgIndex, ParamIndex>::value>::type>
+           typename = std::enable_if_t<
+               UseBoundArg<BoundArgIndex, ParamIndex>::value>>
   inline double PutNextArg(const arma::mat& parameters, const Args&... args);
 
   /**
@@ -162,8 +162,8 @@ class CVFunction
   template<size_t BoundArgIndex,
            size_t ParamIndex,
            typename... Args,
-           typename = typename std::enable_if<
-               !UseBoundArg<BoundArgIndex, ParamIndex>::value>::type,
+           typename = std::enable_if_t<
+               !UseBoundArg<BoundArgIndex, ParamIndex>::value>,
            typename = void>
   inline double PutNextArg(const arma::mat& parameters, const Args&... args);
 };
diff --git a/src/mlpack/core/hpt/deduce_hp_types.hpp b/src/mlpack/core/hpt/deduce_hp_types.hpp
index d48c9da280..e4f0e903f6 100644
--- a/src/mlpack/core/hpt/deduce_hp_types.hpp
+++ b/src/mlpack/core/hpt/deduce_hp_types.hpp
@@ -51,7 +51,7 @@ struct DeduceHyperParameterTypes<T, Args...>
    * A type function to deduce the result hyper-parameter type for ArgumentType.
    */
   template<typename ArgumentType,
-           bool IsArithmetic = std::is_arithmetic<ArgumentType>::value>
+           bool IsArithmetic = std::is_arithmetic_v<ArgumentType>>
   struct ResultHPType;
 
   template<typename ArithmeticType>
diff --git a/src/mlpack/core/hpt/fixed.hpp b/src/mlpack/core/hpt/fixed.hpp
index d8f6a3df35..55bf2adc6b 100644
--- a/src/mlpack/core/hpt/fixed.hpp
+++ b/src/mlpack/core/hpt/fixed.hpp
@@ -101,7 +101,7 @@ class IsPreFixedArg
   struct Implementation<PreFixedArg<Type>> : std::true_type {};
 
  public:
-  static const bool value = Implementation<typename std::decay<T>::type>::value;
+  static const bool value = Implementation<std::decay_t<T>>::value;
 };
 
 } // namespace mlpack
diff --git a/src/mlpack/core/hpt/hpt.hpp b/src/mlpack/core/hpt/hpt.hpp
index c9d8dee829..9f20b7deb7 100644
--- a/src/mlpack/core/hpt/hpt.hpp
+++ b/src/mlpack/core/hpt/hpt.hpp
@@ -199,10 +199,10 @@ class HyperParameterTuner
   };
 
   //! A short alias for the full type of the cross-validation.
-  using CVType = typename std::conditional<Metric::NeedsMinimization,
+  using CVType = std::conditional_t<Metric::NeedsMinimization,
       CV<MLAlgorithm, Metric, MatType, PredictionsType, WeightsType>,
       CV<MLAlgorithm, Negated<Metric>, MatType, PredictionsType,
-          WeightsType>>::type;
+          WeightsType>>;
 
 
   //! The cross-validation object for assessing sets of hyper-parameters.
@@ -234,15 +234,15 @@ class HyperParameterTuner
    * PreFixedArg.
    */
   template<typename Tuple, size_t I>
-  using IsPreFixed = IsPreFixedArg<typename std::tuple_element<I, Tuple>::type>;
+  using IsPreFixed = IsPreFixedArg<std::tuple_element_t<I, Tuple>>;
 
   /**
    * A type function to check whether the element I of the tuple type is an
    * arithmetic type.
    */
   template<typename Tuple, size_t I>
-  using IsArithmetic = std::is_arithmetic<typename std::remove_reference<
-      typename std::tuple_element<I, Tuple>::type>::type>;
+  using IsArithmetic = std::is_arithmetic<std::remove_reference_t<
+      std::tuple_element_t<I, Tuple>>>;
 
   /**
    * The set of methods to initialize auxiliary objects (a CVFunction object and
diff --git a/src/mlpack/core/hpt/hpt_impl.hpp b/src/mlpack/core/hpt/hpt_impl.hpp
index 596f58e0ab..019598c09c 100644
--- a/src/mlpack/core/hpt/hpt_impl.hpp
+++ b/src/mlpack/core/hpt/hpt_impl.hpp
@@ -130,8 +130,8 @@ void HyperParameterTuner<MLAlgorithm,
     data::DatasetMapper<data::IncrementPolicy, double>& datasetInfo,
     FixedArgs... fixedArgs)
 {
-  using PreFixedArgT = typename std::remove_reference<
-      typename std::tuple_element<I, ArgsTuple>::type>::type;
+  using PreFixedArgT = std::remove_reference_t<
+      std::tuple_element_t<I, ArgsTuple>>;
   using FixedArgT = FixedArg<typename PreFixedArgT::Type, I>;
 
   InitAndOptimize<I + 1>(args, bestParams, datasetInfo, fixedArgs...,
diff --git a/src/mlpack/core/math/digamma.hpp b/src/mlpack/core/math/digamma.hpp
index 3a252ce5db..ecb1be9a41 100644
--- a/src/mlpack/core/math/digamma.hpp
+++ b/src/mlpack/core/math/digamma.hpp
@@ -27,7 +27,7 @@ namespace mlpack {
  * @param x Input for which digamma will be calculated.
  */
 template<std::size_t N, typename T>
-typename std::enable_if<N == 8, T>::type
+std::enable_if_t<N == 8, T>
 EvaluatePolyLarge(const T(&a)[N], const T& x)
 {
   T x2 = x * x;
@@ -60,7 +60,7 @@ EvaluatePolyLarge(const T(&a)[N], const T& x)
  * @param x Input for which digamma will be calculated.
  */
 template<std::size_t N, typename T>
-typename std::enable_if<N == 7, T>::type
+std::enable_if_t<N == 7, T>
 EvaluatePoly12(const T(&a)[N], const T& x)
 {
   T x2 = x * x;
@@ -91,7 +91,7 @@ EvaluatePoly12(const T(&a)[N], const T& x)
  * @param x Input for which digamma will be calculated.
  */
 template<std::size_t N, typename T>
-typename std::enable_if<N == 6, T>::type
+std::enable_if_t<N == 6, T>
 EvaluatePoly12(const T(&a)[N], const T& x)
 {
   T x2 = x * x;
diff --git a/src/mlpack/core/math/trigamma.hpp b/src/mlpack/core/math/trigamma.hpp
index 5cab44654d..70a6a1910b 100644
--- a/src/mlpack/core/math/trigamma.hpp
+++ b/src/mlpack/core/math/trigamma.hpp
@@ -30,7 +30,7 @@ namespace mlpack {
  * @param x Input for which we have to calculate trigamma.
  */
 template<std::size_t N, typename T>
-typename std::enable_if<N == 6, T>::type
+std::enable_if_t<N == 6, T>
 EvaluatePolyPrec(const T(&a)[N], const T& x)
 {
   T x2 = x * x;
@@ -60,7 +60,7 @@ EvaluatePolyPrec(const T(&a)[N], const T& x)
  * @param x Input for which we have to calculate trigamma.
  */
 template<std::size_t N, typename T>
-typename std::enable_if<N == 7, T>::type
+std::enable_if_t<N == 7, T>
 EvaluatePolyPrec(const T(&a)[N], const T& x)
 {
   T x2 = x * x;
diff --git a/src/mlpack/core/tree/address.hpp b/src/mlpack/core/tree/address.hpp
index bd3b6c3538..e999e01144 100644
--- a/src/mlpack/core/tree/address.hpp
+++ b/src/mlpack/core/tree/address.hpp
@@ -56,12 +56,12 @@ void PointToAddress(AddressType& address, const VecType& point)
 {
   typedef typename VecType::elem_type VecElemType;
   // Check that the arguments are compatible.
-  typedef typename std::conditional<sizeof(VecElemType) * CHAR_BIT <= 32,
+  typedef std::conditional_t<sizeof(VecElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>::type AddressElemType;
+                                    uint64_t>AddressElemType;
 
-  static_assert(std::is_same<typename AddressType::elem_type,
-      AddressElemType>::value == true, "The vector element type does not "
+  static_assert(std::is_same_v<typename AddressType::elem_type,
+      AddressElemType> == true, "The vector element type does not "
       "correspond to the address element type.");
   arma::Col<AddressElemType> result(point.n_elem);
 
@@ -152,12 +152,12 @@ void AddressToPoint(VecType& point, const AddressType& address)
 {
   typedef typename VecType::elem_type VecElemType;
   // Check that the arguments are compatible.
-  typedef typename std::conditional<sizeof(VecElemType) * CHAR_BIT <= 32,
+  typedef std::conditional_t<sizeof(VecElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>::type AddressElemType;
+                                    uint64_t>AddressElemType;
 
-  static_assert(std::is_same<typename AddressType::elem_type,
-      AddressElemType>::value == true, "The vector element type does not "
+  static_assert(std::is_same_v<typename AddressType::elem_type,
+      AddressElemType> == true, "The vector element type does not "
       "correspond to the address element type.");
 
   constexpr size_t order = sizeof(AddressElemType) * CHAR_BIT;
@@ -230,8 +230,8 @@ void AddressToPoint(VecType& point, const AddressType& address)
 template<typename AddressType1, typename AddressType2>
 int CompareAddresses(const AddressType1& addr1, const AddressType2& addr2)
 {
-  static_assert(std::is_same<typename AddressType1::elem_type,
-      typename AddressType2::elem_type>::value == true, "Can't compare "
+  static_assert(std::is_same_v<typename AddressType1::elem_type,
+      typename AddressType2::elem_type> == true, "Can't compare "
       "addresses of distinct types");
 
   assert(addr1.n_elem == addr2.n_elem);
diff --git a/src/mlpack/core/tree/binary_space_tree/ub_tree_split.hpp b/src/mlpack/core/tree/binary_space_tree/ub_tree_split.hpp
index 68a7e4ec68..59d8add197 100644
--- a/src/mlpack/core/tree/binary_space_tree/ub_tree_split.hpp
+++ b/src/mlpack/core/tree/binary_space_tree/ub_tree_split.hpp
@@ -29,10 +29,10 @@ class UBTreeSplit
 {
  public:
   //! The type of an address element.
-  typedef typename std::conditional<
+  typedef std::conditional_t<
       sizeof(typename MatType::elem_type) * CHAR_BIT <= 32,
       uint32_t,
-      uint64_t>::type AddressElemType;
+      uint64_t>AddressElemType;
 
   //! An information about the partition.
   struct SplitInfo
diff --git a/src/mlpack/core/tree/build_tree.hpp b/src/mlpack/core/tree/build_tree.hpp
index d6ac3b63bd..3042684fd3 100644
--- a/src/mlpack/core/tree/build_tree.hpp
+++ b/src/mlpack/core/tree/build_tree.hpp
@@ -21,8 +21,8 @@ template<typename TreeType, typename MatType>
 TreeType* BuildTree(
     MatType&& dataset,
     std::vector<size_t>& oldFromNew,
-    const typename std::enable_if<
-        TreeTraits<TreeType>::RearrangesDataset>::type* = 0)
+    const std::enable_if_t<
+        TreeTraits<TreeType>::RearrangesDataset>* = 0)
 {
   return new TreeType(std::forward<MatType>(dataset), oldFromNew);
 }
@@ -32,8 +32,8 @@ template<typename TreeType, typename MatType>
 TreeType* BuildTree(
     MatType&& dataset,
     const std::vector<size_t>& /* oldFromNew */,
-    const typename std::enable_if<
-        !TreeTraits<TreeType>::RearrangesDataset>::type* = 0)
+    const std::enable_if_t<
+        !TreeTraits<TreeType>::RearrangesDataset>* = 0)
 {
   return new TreeType(std::forward<MatType>(dataset));
 }
diff --git a/src/mlpack/core/tree/cellbound.hpp b/src/mlpack/core/tree/cellbound.hpp
index 40b78ebe1f..3fb2bfbb09 100644
--- a/src/mlpack/core/tree/cellbound.hpp
+++ b/src/mlpack/core/tree/cellbound.hpp
@@ -76,9 +76,9 @@ class CellBound
  public:
   //! Depending on the precision of the tree element type, we may need to use
   //! uint32_t or uint64_t.
-  typedef typename std::conditional<sizeof(ElemType) * CHAR_BIT <= 32,
+  typedef std::conditional_t<sizeof(ElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>::type AddressElemType;
+                                    uint64_t>AddressElemType;
 
   /**
    * Empty constructor; creates a bound of dimensionality 0.
diff --git a/src/mlpack/core/tree/rectangle_tree/discrete_hilbert_value.hpp b/src/mlpack/core/tree/rectangle_tree/discrete_hilbert_value.hpp
index 9ecb85ed86..3ccd204a75 100644
--- a/src/mlpack/core/tree/rectangle_tree/discrete_hilbert_value.hpp
+++ b/src/mlpack/core/tree/rectangle_tree/discrete_hilbert_value.hpp
@@ -30,9 +30,9 @@ class DiscreteHilbertValue
  public:
   //! Depending on the precision of the tree element type, we may need to use
   //! uint32_t or uint64_t.
-  typedef typename std::conditional<sizeof(TreeElemType) * CHAR_BIT <= 32,
+  typedef std::conditional_t<sizeof(TreeElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>::type HilbertElemType;
+                                    uint64_t>HilbertElemType;
 
   //! Default constructor.
   DiscreteHilbertValue();
diff --git a/src/mlpack/core/tree/rectangle_tree/rectangle_tree.hpp b/src/mlpack/core/tree/rectangle_tree/rectangle_tree.hpp
index 8978bcb9ff..6d382b822a 100644
--- a/src/mlpack/core/tree/rectangle_tree/rectangle_tree.hpp
+++ b/src/mlpack/core/tree/rectangle_tree/rectangle_tree.hpp
@@ -53,7 +53,7 @@ template<typename DistanceType = EuclideanDistance,
 class RectangleTree
 {
   // The distance metric *must* be the euclidean distance.
-  static_assert(std::is_same<DistanceType, EuclideanDistance>::value,
+  static_assert(std::is_same_v<DistanceType, EuclideanDistance>,
       "RectangleTree: DistanceType must be EuclideanDistance.");
 
  public:
diff --git a/src/mlpack/core/util/ens_traits.hpp b/src/mlpack/core/util/ens_traits.hpp
index 79c1635c3c..cade7a7069 100644
--- a/src/mlpack/core/util/ens_traits.hpp
+++ b/src/mlpack/core/util/ens_traits.hpp
@@ -45,7 +45,7 @@ struct IsEnsOptimizer
       OptimizerType,
       FunctionType,
       MatType,
-      std::is_class<OptimizerType>::value
+      std::is_class_v<OptimizerType>
   >::value;
 };
 
@@ -55,8 +55,8 @@ struct IsEnsOptimizerInternal<OptimizerType, FunctionType, MatType, true>
 {
   // If OptimizerType is a reference type, then forming the types below will
   // fail.  So we need to strip the reference (and the const for good measure).
-  typedef typename std::remove_cv<
-      typename std::remove_reference<OptimizerType>::type>::type
+  typedef std::remove_cv_t<
+      std::remove_reference_t<OptimizerType>>
       SafeOptimizerType;
 
   using OptimizeElemReturnForm =
@@ -85,9 +85,9 @@ template<typename CallbackType, typename... CallbackTypes>
 struct IsEnsCallbackTypes<CallbackType, CallbackTypes...>
 {
   constexpr static bool value =
-      std::is_class<typename std::remove_cv<
-          typename std::remove_reference<CallbackType>::type
-      >::type>::value && IsEnsCallbackTypes<CallbackTypes...>::value;
+      std::is_class_v<std::remove_cv_t<
+          std::remove_reference_t<CallbackType>
+      >> && IsEnsCallbackTypes<CallbackTypes...>::value;
 };
 
 template<>
diff --git a/src/mlpack/core/util/first_element_is_arma.hpp b/src/mlpack/core/util/first_element_is_arma.hpp
index d5828dcb5a..7bec0f54e7 100644
--- a/src/mlpack/core/util/first_element_is_arma.hpp
+++ b/src/mlpack/core/util/first_element_is_arma.hpp
@@ -39,9 +39,9 @@ template<typename... CallbackTypes>
 struct FirstElementIsArma
 {
   static constexpr bool value = arma::is_arma_type<
-      typename std::remove_reference<
+      std::remove_reference_t<
           typename First<CallbackTypes...>::type
-      >::type>::value;
+      >>::value;
 };
 
 } // namespace mlpack
diff --git a/src/mlpack/core/util/prefixedoutstream.hpp b/src/mlpack/core/util/prefixedoutstream.hpp
index bca5639444..2947f24481 100644
--- a/src/mlpack/core/util/prefixedoutstream.hpp
+++ b/src/mlpack/core/util/prefixedoutstream.hpp
@@ -134,7 +134,7 @@ class PrefixedOutStream
    * @param val The The data to be output.
    */
   template<typename T>
-  typename std::enable_if<!arma::is_arma_type<T>::value>::type
+  std::enable_if_t<!arma::is_arma_type<T>::value>
   BaseLogic(const T& val);
 
   /**
@@ -148,7 +148,7 @@ class PrefixedOutStream
    * @param val The The data to be output.
    */
   template<typename T>
-  typename std::enable_if<arma::is_arma_type<T>::value>::type
+  std::enable_if_t<arma::is_arma_type<T>::value>
   BaseLogic(const T& val);
 
   /**
diff --git a/src/mlpack/core/util/prefixedoutstream_impl.hpp b/src/mlpack/core/util/prefixedoutstream_impl.hpp
index 5f2aa48142..498fad50f3 100644
--- a/src/mlpack/core/util/prefixedoutstream_impl.hpp
+++ b/src/mlpack/core/util/prefixedoutstream_impl.hpp
@@ -146,7 +146,7 @@ inline PrefixedOutStream& PrefixedOutStream::operator<<(
 
 // For non-Armadillo types.
 template<typename T>
-typename std::enable_if<!arma::is_arma_type<T>::value>::type
+std::enable_if_t<!arma::is_arma_type<T>::value>
 PrefixedOutStream::BaseLogic(const T& val)
 {
   // We will use this to track whether or not we need to terminate at the end of
@@ -254,7 +254,7 @@ PrefixedOutStream::BaseLogic(const T& val)
 
 // For Armadillo types.
 template<typename T>
-typename std::enable_if<arma::is_arma_type<T>::value>::type
+std::enable_if_t<arma::is_arma_type<T>::value>
 PrefixedOutStream::BaseLogic(const T& val)
 {
   // Extract printable object from the input.
diff --git a/src/mlpack/core/util/sfinae_utility.hpp b/src/mlpack/core/util/sfinae_utility.hpp
index 848fa515b7..b1747bd4a4 100644
--- a/src/mlpack/core/util/sfinae_utility.hpp
+++ b/src/mlpack/core/util/sfinae_utility.hpp
@@ -156,7 +156,7 @@ struct NAME                                                                    \
                                                                                \
     template<typename T, typename ResultType>                                  \
     using EnableIfVoid =                                                       \
-        typename std::enable_if<std::is_void<T>::value, ResultType>::type;     \
+        std::enable_if_t<std::is_void_v<T>, ResultType>;     \
                                                                                \
     template<typename C>                                                       \
     static EnableIfVoid<decltype(MFD<C, MF, N>()(&C::METHOD)), yes&> chk(int); \
@@ -196,20 +196,19 @@ struct NAME                                                                    \
  * function in the given class name.
  * This can also be used in conjunction with std::enable_if.
  */
-#define HAS_ANY_METHOD_FORM(FUNC, NAME)                                      \
-template <typename T>                                                        \
-struct NAME                                                                  \
-{                                                                            \
-  template <typename Q = T>                                                  \
-  static typename                                                            \
-  std::enable_if<std::is_member_function_pointer<decltype(&Q::FUNC)>::value, \
-                 int>::type                                                  \
-  f(int) { return 1;}                                                      \
-                                                                             \
-  template <typename Q = T>                                                  \
-  static char f(char) { return 0; }                                        \
-                                                                             \
-  static const bool value = sizeof(f<T>(0)) != sizeof(char);                 \
+#define HAS_ANY_METHOD_FORM(FUNC, NAME)                                       \
+template <typename T>                                                         \
+struct NAME                                                                   \
+{                                                                             \
+  template <typename Q = T>                                                   \
+  static                                                                      \
+  std::enable_if_t<std::is_member_function_pointer_v<decltype(&Q::FUNC)>, int>\
+  f(int) { return 1;}                                                         \
+                                                                              \
+  template <typename Q = T>                                                   \
+  static char f(char) { return 0; }                                           \
+                                                                              \
+  static const bool value = sizeof(f<T>(0)) != sizeof(char);                  \
 };
 /*
  * A macro that can be used for passing arguments containing commas to other
diff --git a/src/mlpack/core/util/size_checks.hpp b/src/mlpack/core/util/size_checks.hpp
index 4f25af8021..2d55c25f23 100644
--- a/src/mlpack/core/util/size_checks.hpp
+++ b/src/mlpack/core/util/size_checks.hpp
@@ -39,8 +39,8 @@ inline void CheckSameSizes(
     const std::string& addInfo = "labels",
     const bool& isDataTranspose = false,
     const bool& isLabelTranspose = false,
-    const typename std::enable_if<
-        !std::is_integral<LabelsType>::value>::type* = 0)
+    const std::enable_if_t<
+        !std::is_integral_v<LabelsType>>* = 0)
 {
   const size_t dataPoints = (isDataTranspose == true) ? data.n_rows :
       data.n_cols;
@@ -67,7 +67,7 @@ inline void CheckSameSizes(
     const SizeType& size,
     const std::string& callerDescription,
     const std::string& addInfo = "labels",
-    const typename std::enable_if<std::is_integral<SizeType>::value>::type* = 0)
+    const std::enable_if_t<std::is_integral_v<SizeType>>* = 0)
 {
   if (data.n_cols != size)
   {
@@ -96,7 +96,7 @@ inline void CheckSameDimensionality(
     const DimType& dimension,
     const std::string& callerDescription,
     const std::string& addInfo = "dataset",
-    const typename std::enable_if<!std::is_integral<DimType>::value>::type* = 0)
+    const std::enable_if_t<!std::is_integral_v<DimType>>* = 0)
 {
   if (data.n_rows != dimension.n_rows)
   {
@@ -119,7 +119,7 @@ inline void CheckSameDimensionality(
     const DimType& dimension,
     const std::string& callerDescription,
     const std::string& addInfo = "dataset",
-    const typename std::enable_if<std::is_integral<DimType>::value>::type* = 0)
+    const std::enable_if_t<std::is_integral_v<DimType>>* = 0)
 {
   if (data.n_rows != dimension)
   {
diff --git a/src/mlpack/core/util/using.hpp b/src/mlpack/core/util/using.hpp
index 719a255cf6..de5f1c81a4 100644
--- a/src/mlpack/core/util/using.hpp
+++ b/src/mlpack/core/util/using.hpp
@@ -92,7 +92,7 @@ struct GetFillType
 // If the matrix type is a Bandicoot type, use Bandicoot fill objects instead.
 template<
     typename MatType,
-    typename = typename std::enable_if<is_coot_type<MatType>::value>::type*>
+    typename = std::enable_if_t<is_coot_type<MatType>::value>*>
 struct GetFillType
 {
   static constexpr const decltype(coot::fill::none)& none   = coot::fill::none;
diff --git a/src/mlpack/methods/adaboost/adaboost.hpp b/src/mlpack/methods/adaboost/adaboost.hpp
index 6c5f19c9dd..e6a71275d1 100644
--- a/src/mlpack/methods/adaboost/adaboost.hpp
+++ b/src/mlpack/methods/adaboost/adaboost.hpp
@@ -130,9 +130,9 @@ class AdaBoost
            const WeakLearnerInType& other,
            const size_t maxIterations = 100,
            const ElemType tolerance = 1e-6,
-           const typename std::enable_if<
-              std::is_same<WeakLearnerType, WeakLearnerInType>::value
-           >::type* = 0);
+           const std::enable_if_t<
+              std::is_same_v<WeakLearnerType, WeakLearnerInType>
+           >* = 0);
 
   //! Get the maximum number of weak learners allowed in the model.
   size_t MaxIterations() const { return maxIterations; }
@@ -189,8 +189,8 @@ class AdaBoost
       const std::optional<size_t> maxIterations = std::nullopt,
       const std::optional<double> tolerance = std::nullopt,
       // Necessary to distinguish from other overloads.
-      const typename std::enable_if<
-          std::is_same<WeakLearnerType, WeakLearnerInType>::value>::type* = 0);
+      const std::enable_if_t<
+          std::is_same_v<WeakLearnerType, WeakLearnerInType>>* = 0);
 
   /**
    * Train AdaBoost on the given dataset, using the given parameters.  The last
diff --git a/src/mlpack/methods/adaboost/adaboost_impl.hpp b/src/mlpack/methods/adaboost/adaboost_impl.hpp
index 006e4d8dde..7609ee7749 100644
--- a/src/mlpack/methods/adaboost/adaboost_impl.hpp
+++ b/src/mlpack/methods/adaboost/adaboost_impl.hpp
@@ -57,8 +57,8 @@ AdaBoost<WeakLearnerType, MatType>::AdaBoost(
     const WeakLearnerInType& other,
     const size_t maxIterations,
     const typename MatType::elem_type tol,
-    const typename std::enable_if<
-        std::is_same<WeakLearnerType, WeakLearnerInType>::value>::type*) :
+    const std::enable_if_t<
+        std::is_same_v<WeakLearnerType, WeakLearnerInType>>*) :
     maxIterations(maxIterations),
     tolerance(tol)
 {
@@ -102,8 +102,8 @@ typename MatType::elem_type AdaBoost<WeakLearnerType, MatType>::Train(
     const WeakLearnerInType& other,
     const std::optional<size_t> maxIterations,
     const std::optional<double> tolerance,
-    const typename std::enable_if<
-        std::is_same<WeakLearnerType, WeakLearnerInType>::value>::type*)
+    const std::enable_if_t<
+        std::is_same_v<WeakLearnerType, WeakLearnerInType>>*)
 {
   if (maxIterations.has_value())
     this->maxIterations = maxIterations.value();
@@ -229,7 +229,7 @@ void AdaBoost<WeakLearnerType, MatType>::serialize(Archive& ar,
 
     // In earlier versions, `alpha` was a vector of doubles---but it might not
     // be now.
-    if (std::is_same<ElemType, double>::value)
+    if (std::is_same_v<ElemType, double>)
     {
       ar(CEREAL_NVP(alpha)); // The easy case.
     }
diff --git a/src/mlpack/methods/ann/convolution_rules/fft_convolution.hpp b/src/mlpack/methods/ann/convolution_rules/fft_convolution.hpp
index a6e48ea4af..0405619572 100644
--- a/src/mlpack/methods/ann/convolution_rules/fft_convolution.hpp
+++ b/src/mlpack/methods/ann/convolution_rules/fft_convolution.hpp
@@ -48,8 +48,8 @@ class FFTConvolution
    * @param output Output data that contains the results of the convolution.
    */
   template<typename MatType, typename Border = BorderMode>
-  static typename std::enable_if<
-      std::is_same<Border, ValidConvolution>::value, void>::type
+  static std::enable_if_t<
+      std::is_same_v<Border, ValidConvolution>, void>
   Convolution(const MatType& input,
               const MatType& filter,
               MatType& output,
@@ -83,8 +83,8 @@ class FFTConvolution
    * @param output Output data that contains the results of the convolution.
    */
   template<typename MatType, typename Border = BorderMode>
-  static typename std::enable_if<
-      std::is_same<Border, FullConvolution>::value, void>::type
+  static std::enable_if_t<
+      std::is_same_v<Border, FullConvolution>, void>
   Convolution(const MatType& input,
               const MatType& filter,
               MatType& output,
diff --git a/src/mlpack/methods/ann/convolution_rules/naive_convolution.hpp b/src/mlpack/methods/ann/convolution_rules/naive_convolution.hpp
index a472966794..1243479b74 100644
--- a/src/mlpack/methods/ann/convolution_rules/naive_convolution.hpp
+++ b/src/mlpack/methods/ann/convolution_rules/naive_convolution.hpp
@@ -49,8 +49,8 @@ class NaiveConvolution
    */
   template<typename InMatType, typename FilMatType, typename OutMatType,
       typename Border = BorderMode>
-  static typename std::enable_if<
-      std::is_same<Border, ValidConvolution>::value, void>::type
+  static std::enable_if_t<
+      std::is_same_v<Border, ValidConvolution>, void>
   Convolution(const InMatType& input,
               const FilMatType& filter,
               OutMatType& output,
@@ -110,8 +110,8 @@ class NaiveConvolution
    */
   template<typename InMatType, typename FilMatType, typename OutMatType,
       typename Border = BorderMode>
-  static typename std::enable_if<
-      std::is_same<Border, FullConvolution>::value, void>::type
+  static std::enable_if_t<
+      std::is_same_v<Border, FullConvolution>, void>
   Convolution(const InMatType& input,
               const FilMatType& filter,
               OutMatType& output,
diff --git a/src/mlpack/methods/ann/ffn.hpp b/src/mlpack/methods/ann/ffn.hpp
index 7b895c0663..671d82f962 100644
--- a/src/mlpack/methods/ann/ffn.hpp
+++ b/src/mlpack/methods/ann/ffn.hpp
@@ -486,9 +486,9 @@ class FFN
    * @param samples Number of datapoints in the dataset.
    */
   template<typename OptimizerType>
-  typename std::enable_if<
+  std::enable_if_t<
       ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void
-  >::type
+  >
   WarnMessageMaxIterations(OptimizerType& optimizer, size_t samples) const;
 
   /**
@@ -500,9 +500,9 @@ class FFN
    * @param samples Number of datapoints in the dataset.
    */
   template<typename OptimizerType>
-  typename std::enable_if<
+  std::enable_if_t<
       !ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void
-  >::type
+  >
   WarnMessageMaxIterations(OptimizerType& optimizer, size_t samples) const;
 
   //! Instantiated output layer used to evaluate the network.
diff --git a/src/mlpack/methods/ann/ffn_impl.hpp b/src/mlpack/methods/ann/ffn_impl.hpp
index 8e1bfdbb5f..980e3fd2a6 100644
--- a/src/mlpack/methods/ann/ffn_impl.hpp
+++ b/src/mlpack/methods/ann/ffn_impl.hpp
@@ -694,9 +694,9 @@ template<typename OutputLayerType,
          typename InitializationRuleType,
          typename MatType>
 template<typename OptimizerType>
-typename std::enable_if<
+std::enable_if_t<
     ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void
->::type
+>
 FFN<
     OutputLayerType,
     InitializationRuleType,
@@ -718,9 +718,9 @@ template<typename OutputLayerType,
          typename InitializationRuleType,
          typename MatType>
 template<typename OptimizerType>
-typename std::enable_if<
+std::enable_if_t<
     !ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void
->::type
+>
 FFN<
     OutputLayerType,
     InitializationRuleType,
diff --git a/src/mlpack/methods/ann/not_adapted/brnn.hpp b/src/mlpack/methods/ann/not_adapted/brnn.hpp
index d38089ed76..c90f59c196 100644
--- a/src/mlpack/methods/ann/not_adapted/brnn.hpp
+++ b/src/mlpack/methods/ann/not_adapted/brnn.hpp
@@ -89,9 +89,9 @@ class BRNN
    * @param samples Number of datapoints in the dataset.
    */
   template<typename OptimizerType>
-  typename std::enable_if<
+  std::enable_if_t<
       HasMaxIterations<OptimizerType, size_t&(OptimizerType::*)()>
-      ::value, void>::type
+      ::value, void>
   WarnMessageMaxIterations(OptimizerType& optimizer, size_t samples) const;
 
   /**
@@ -103,9 +103,9 @@ class BRNN
    * @param samples Number of datapoints in the dataset.
    */
   template<typename OptimizerType>
-  typename std::enable_if<
+  std::enable_if_t<
       !HasMaxIterations<OptimizerType, size_t&(OptimizerType::*)()>
-      ::value, void>::type
+      ::value, void>
   WarnMessageMaxIterations(OptimizerType& optimizer, size_t samples) const;
 
   /**
diff --git a/src/mlpack/methods/ann/not_adapted/brnn_impl.hpp b/src/mlpack/methods/ann/not_adapted/brnn_impl.hpp
index 1d08a3cd7d..fdc7cb8e51 100644
--- a/src/mlpack/methods/ann/not_adapted/brnn_impl.hpp
+++ b/src/mlpack/methods/ann/not_adapted/brnn_impl.hpp
@@ -78,9 +78,9 @@ template<typename OutputLayerType, typename MergeLayerType,
          typename MergeOutputType, typename InitializationRuleType,
          typename... CustomLayers>
 template<typename OptimizerType>
-typename std::enable_if<
+std::enable_if_t<
       HasMaxIterations<OptimizerType, size_t&(OptimizerType::*)()>
-      ::value, void>::type
+      ::value, void>
 BRNN<OutputLayerType, MergeLayerType, MergeOutputType,
     InitializationRuleType, CustomLayers...>::WarnMessageMaxIterations
 (OptimizerType& optimizer, size_t samples) const
@@ -102,9 +102,9 @@ template<typename OutputLayerType, typename MergeLayerType,
          typename MergeOutputType, typename InitializationRuleType,
          typename... CustomLayers>
 template<typename OptimizerType>
-typename std::enable_if<
+std::enable_if_t<
       !HasMaxIterations<OptimizerType, size_t&(OptimizerType::*)()>
-      ::value, void>::type
+      ::value, void>
 BRNN<OutputLayerType, MergeLayerType, MergeOutputType,
     InitializationRuleType, CustomLayers...>::WarnMessageMaxIterations
 (OptimizerType& /* optimizer */, size_t /* samples */) const
@@ -201,7 +201,7 @@ void BRNN<OutputLayerType, MergeLayerType, MergeOutputType,
     ResetParameters();
   }
 
-  if (std::is_same<MergeLayerType, Concat<>>::value)
+  if (std::is_same_v<MergeLayerType, Concat<>>)
   {
     results = zeros<arma::cube>(outputSize * 2, predictors.n_cols, rho);
   }
@@ -438,7 +438,7 @@ EvaluateWithGradient(const arma::mat& /* parameters */,
   }
 
   arma::cube results;
-  if (std::is_same<MergeLayerType, Concat<>>::value)
+  if (std::is_same_v<MergeLayerType, Concat<>>)
   {
     results = zeros<arma::cube>(outputSize * 2, batchSize, rho);
   }
diff --git a/src/mlpack/methods/ann/not_adapted/gan/gan.hpp b/src/mlpack/methods/ann/not_adapted/gan/gan.hpp
index 4b32a605a1..2b754dddbe 100644
--- a/src/mlpack/methods/ann/not_adapted/gan/gan.hpp
+++ b/src/mlpack/methods/ann/not_adapted/gan/gan.hpp
@@ -134,8 +134,8 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename Policy = PolicyType>
-  typename std::enable_if<std::is_same<Policy, StandardGAN>::value ||
-                          std::is_same<Policy, DCGAN>::value, double>::type
+  std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
+                          std::is_same_v<Policy, DCGAN>, double>
   Evaluate(const arma::mat& parameters,
            const size_t i,
            const size_t batchSize);
@@ -149,8 +149,8 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename Policy = PolicyType>
-  typename std::enable_if<std::is_same<Policy, WGAN>::value,
-                          double>::type
+  std::enable_if_t<std::is_same_v<Policy, WGAN>,
+                          double>
   Evaluate(const arma::mat& parameters,
            const size_t i,
            const size_t batchSize);
@@ -164,8 +164,8 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename Policy = PolicyType>
-  typename std::enable_if<std::is_same<Policy, WGANGP>::value,
-                          double>::type
+  std::enable_if_t<std::is_same_v<Policy, WGANGP>,
+                          double>
   Evaluate(const arma::mat& parameters,
            const size_t i,
            const size_t batchSize);
@@ -181,8 +181,8 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename GradType, typename Policy = PolicyType>
-  typename std::enable_if<std::is_same<Policy, StandardGAN>::value ||
-                          std::is_same<Policy, DCGAN>::value, double>::type
+  std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
+                          std::is_same_v<Policy, DCGAN>, double>
   EvaluateWithGradient(const arma::mat& parameters,
                        const size_t i,
                        GradType& gradient,
@@ -199,8 +199,8 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename GradType, typename Policy = PolicyType>
-  typename std::enable_if<std::is_same<Policy, WGAN>::value,
-                          double>::type
+  std::enable_if_t<std::is_same_v<Policy, WGAN>,
+                          double>
   EvaluateWithGradient(const arma::mat& parameters,
                        const size_t i,
                        GradType& gradient,
@@ -217,8 +217,8 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename GradType, typename Policy = PolicyType>
-  typename std::enable_if<std::is_same<Policy, WGANGP>::value,
-                          double>::type
+  std::enable_if_t<std::is_same_v<Policy, WGANGP>,
+                          double>
   EvaluateWithGradient(const arma::mat& parameters,
                        const size_t i,
                        GradType& gradient,
@@ -235,8 +235,8 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename Policy = PolicyType>
-  typename std::enable_if<std::is_same<Policy, StandardGAN>::value ||
-                          std::is_same<Policy, DCGAN>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
+                          std::is_same_v<Policy, DCGAN>, void>
   Gradient(const arma::mat& parameters,
            const size_t i,
            arma::mat& gradient,
@@ -253,7 +253,7 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename Policy = PolicyType>
-  typename std::enable_if<std::is_same<Policy, WGAN>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, WGAN>, void>
   Gradient(const arma::mat& parameters,
            const size_t i,
            arma::mat& gradient,
@@ -270,8 +270,8 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename Policy = PolicyType>
-  typename std::enable_if<std::is_same<Policy, WGANGP>::value,
-                          void>::type
+  std::enable_if_t<std::is_same_v<Policy, WGANGP>,
+                          void>
   Gradient(const arma::mat& parameters,
            const size_t i,
            arma::mat& gradient,
diff --git a/src/mlpack/methods/ann/not_adapted/gan/gan_impl.hpp b/src/mlpack/methods/ann/not_adapted/gan/gan_impl.hpp
index 56459ddc57..88371bab52 100644
--- a/src/mlpack/methods/ann/not_adapted/gan/gan_impl.hpp
+++ b/src/mlpack/methods/ann/not_adapted/gan/gan_impl.hpp
@@ -233,8 +233,8 @@ template<
   typename PolicyType
 >
 template<typename Policy>
-typename std::enable_if<std::is_same<Policy, StandardGAN>::value ||
-                        std::is_same<Policy, DCGAN>::value, double>::type
+std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
+                        std::is_same_v<Policy, DCGAN>, double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::Evaluate(
     const arma::mat& /* parameters */,
     const size_t i,
@@ -288,8 +288,8 @@ template<
   typename PolicyType
 >
 template<typename GradType, typename Policy>
-typename std::enable_if<std::is_same<Policy, StandardGAN>::value ||
-                        std::is_same<Policy, DCGAN>::value, double>::type
+std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
+                        std::is_same_v<Policy, DCGAN>, double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 EvaluateWithGradient(const arma::mat& /* parameters */,
                      const size_t i,
@@ -391,8 +391,8 @@ template<
   typename PolicyType
 >
 template<typename Policy>
-typename std::enable_if<std::is_same<Policy, StandardGAN>::value ||
-                        std::is_same<Policy, DCGAN>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
+                        std::is_same_v<Policy, DCGAN>, void>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 Gradient(const arma::mat& parameters,
          const size_t i,
diff --git a/src/mlpack/methods/ann/not_adapted/gan/wgan_impl.hpp b/src/mlpack/methods/ann/not_adapted/gan/wgan_impl.hpp
index 56e02e7318..75fbfa1289 100644
--- a/src/mlpack/methods/ann/not_adapted/gan/wgan_impl.hpp
+++ b/src/mlpack/methods/ann/not_adapted/gan/wgan_impl.hpp
@@ -27,7 +27,7 @@ template<
   typename PolicyType
 >
 template<typename Policy>
-typename std::enable_if<std::is_same<Policy, WGAN>::value, double>::type
+std::enable_if_t<std::is_same_v<Policy, WGAN>, double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::Evaluate(
     const arma::mat& /* parameters */,
     const size_t i,
@@ -82,7 +82,7 @@ template<
   typename PolicyType
 >
 template<typename GradType, typename Policy>
-typename std::enable_if<std::is_same<Policy, WGAN>::value, double>::type
+std::enable_if_t<std::is_same_v<Policy, WGAN>, double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 EvaluateWithGradient(const arma::mat& /* parameters */,
                      const size_t i,
@@ -185,7 +185,7 @@ template<
   typename PolicyType
 >
 template<typename Policy>
-typename std::enable_if<std::is_same<Policy, WGAN>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, WGAN>, void>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 Gradient(const arma::mat& parameters,
          const size_t i,
diff --git a/src/mlpack/methods/ann/not_adapted/gan/wgangp_impl.hpp b/src/mlpack/methods/ann/not_adapted/gan/wgangp_impl.hpp
index f86fe5c43b..d4f49ace20 100644
--- a/src/mlpack/methods/ann/not_adapted/gan/wgangp_impl.hpp
+++ b/src/mlpack/methods/ann/not_adapted/gan/wgangp_impl.hpp
@@ -27,8 +27,8 @@ template<
   typename PolicyType
 >
 template<typename Policy>
-typename std::enable_if<std::is_same<Policy, WGANGP>::value,
-                        double>::type
+std::enable_if_t<std::is_same_v<Policy, WGANGP>,
+                        double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::Evaluate(
     const arma::mat& /* parameters */,
     const size_t i,
@@ -95,8 +95,8 @@ template<
   typename PolicyType
 >
 template<typename GradType, typename Policy>
-typename std::enable_if<std::is_same<Policy, WGANGP>::value,
-                        double>::type
+std::enable_if_t<std::is_same_v<Policy, WGANGP>,
+                        double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 EvaluateWithGradient(const arma::mat& /* parameters */,
                      const size_t i,
@@ -209,8 +209,8 @@ template<
   typename PolicyType
 >
 template<typename Policy>
-typename std::enable_if<std::is_same<Policy, WGANGP>::value,
-                        void>::type
+std::enable_if_t<std::is_same_v<Policy, WGANGP>,
+                        void>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 Gradient(const arma::mat& parameters,
          const size_t i,
diff --git a/src/mlpack/methods/ann/not_adapted/rbm/rbm.hpp b/src/mlpack/methods/ann/not_adapted/rbm/rbm.hpp
index c7c34b9f08..cd15b08d01 100644
--- a/src/mlpack/methods/ann/not_adapted/rbm/rbm.hpp
+++ b/src/mlpack/methods/ann/not_adapted/rbm/rbm.hpp
@@ -70,12 +70,12 @@ class RBM
 
   // Reset the network.
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
   Reset();
 
   // Reset the network.
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   Reset();
 
   /**
@@ -116,7 +116,7 @@ class RBM
    * @param input The visible neurons.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, double>::type
+  std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, double>
   FreeEnergy(const arma::Mat<ElemType>& input);
 
   /**
@@ -130,8 +130,8 @@ class RBM
    * @param input The visible layer neurons.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value,
-      double>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>,
+      double>
   FreeEnergy(const arma::Mat<ElemType>& input);
 
   /**
@@ -141,7 +141,7 @@ class RBM
    * @param gradient Stores the gradient of the RBM network.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
   Phase(const InputType& input, DataType& gradient);
 
   /**
@@ -151,7 +151,7 @@ class RBM
    * @param gradient Stores the gradient of the RBM network.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   Phase(const InputType& input, DataType& gradient);
 
   /**
@@ -162,7 +162,7 @@ class RBM
    * @param output The sampled hidden layer.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
   SampleHidden(const arma::Mat<ElemType>& input, arma::Mat<ElemType>& output);
 
   /**
@@ -176,7 +176,7 @@ class RBM
    * @param output Sampled slab neurons.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   SampleHidden(const arma::Mat<ElemType>& input, arma::Mat<ElemType>& output);
 
   /**
@@ -187,7 +187,7 @@ class RBM
    * @param output The sampled visible layer.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
   SampleVisible(arma::Mat<ElemType>& input, arma::Mat<ElemType>& output);
 
   /**
@@ -201,7 +201,7 @@ class RBM
    * @param output The sampled visible layer.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   SampleVisible(arma::Mat<ElemType>& input, arma::Mat<ElemType>& output);
 
   /**
@@ -211,7 +211,7 @@ class RBM
    * @param output Visible neuron activations.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
   VisibleMean(InputType& input, DataType& output);
 
   /**
@@ -223,7 +223,7 @@ class RBM
    * @param output Mean of the of the Normal distribution.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   VisibleMean(InputType& input, DataType& output);
 
   /**
@@ -233,7 +233,7 @@ class RBM
    * @param output Hidden neuron activations.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
   HiddenMean(const InputType& input, DataType& output);
 
   /**
@@ -247,7 +247,7 @@ class RBM
    * @param output Consists of both the spike samples and slab samples.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   HiddenMean(const InputType& input, DataType& output);
 
   /**
@@ -259,7 +259,7 @@ class RBM
    * @param spikeMean Indicates P(h|v).
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   SpikeMean(const InputType& visible, DataType& spikeMean);
 
   /**
@@ -268,7 +268,7 @@ class RBM
    * @param spike Sampled binary spike variables.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   SampleSpike(InputType& spikeMean, DataType& spike);
 
   /**
@@ -281,7 +281,7 @@ class RBM
    * @param slabMean The mean of the Normal distribution of slab neurons.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   SlabMean(const DataType& visible, DataType& spike, DataType& slabMean);
 
   /**
@@ -295,7 +295,7 @@ class RBM
    * @param slab Sampled slab variable from the Normal distribution.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
   SampleSlab(InputType& slabMean, DataType& slab);
 
   /**
diff --git a/src/mlpack/methods/ann/not_adapted/rbm/rbm_impl.hpp b/src/mlpack/methods/ann/not_adapted/rbm/rbm_impl.hpp
index 2ec598d424..0ab6129f95 100644
--- a/src/mlpack/methods/ann/not_adapted/rbm/rbm_impl.hpp
+++ b/src/mlpack/methods/ann/not_adapted/rbm/rbm_impl.hpp
@@ -58,7 +58,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::Reset()
 {
   size_t shape = (visibleSize * hiddenSize) + visibleSize + hiddenSize;
@@ -108,7 +108,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, double>::type
+std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, double>
 RBM<InitializationRuleType, DataType, PolicyType>::FreeEnergy(
     const arma::Mat<ElemType>& input)
 {
@@ -124,7 +124,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::Phase(
     const InputType& input,
     DataType& gradient)
@@ -161,7 +161,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::SampleHidden(
     const arma::Mat<ElemType>& input,
     arma::Mat<ElemType>& output)
@@ -180,7 +180,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::SampleVisible(
     arma::Mat<ElemType>& input,
     arma::Mat<ElemType>& output)
@@ -199,7 +199,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::VisibleMean(
     InputType& input,
     DataType& output)
@@ -215,7 +215,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, BinaryRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::HiddenMean(
     const InputType& input,
     DataType& output)
diff --git a/src/mlpack/methods/ann/not_adapted/rbm/spike_slab_rbm_impl.hpp b/src/mlpack/methods/ann/not_adapted/rbm/spike_slab_rbm_impl.hpp
index 3a8da8c70e..633ddf9c53 100644
--- a/src/mlpack/methods/ann/not_adapted/rbm/spike_slab_rbm_impl.hpp
+++ b/src/mlpack/methods/ann/not_adapted/rbm/spike_slab_rbm_impl.hpp
@@ -25,7 +25,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::Reset()
 {
   size_t shape = (visibleSize * hiddenSize * poolSize) + visibleSize +
@@ -65,7 +65,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, double>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, double>
 RBM<InitializationRuleType, DataType, PolicyType>::FreeEnergy(
     const arma::Mat<ElemType>& input)
 {
@@ -90,7 +90,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::Phase(
     const InputType& input,
     DataType& gradient)
@@ -123,7 +123,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::SampleHidden(
     const arma::Mat<ElemType>& input,
     arma::Mat<ElemType>& output)
@@ -146,7 +146,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::SampleVisible(
     arma::Mat<ElemType>& input,
     arma::Mat<ElemType>& output)
@@ -184,7 +184,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::VisibleMean(
     InputType& input,
     DataType& output)
@@ -209,7 +209,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::HiddenMean(
     const InputType& input,
     DataType& output)
@@ -231,7 +231,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::SpikeMean(
     const InputType& visible,
     DataType& spikeMean)
@@ -250,7 +250,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::SampleSpike(
     InputType& spikeMean,
     DataType& spike)
@@ -267,7 +267,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::SlabMean(
     const DataType& visible,
     DataType& spike,
@@ -286,7 +286,7 @@ template<
   typename PolicyType
 >
 template<typename Policy, typename InputType>
-typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
+std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, void>
 RBM<InitializationRuleType, DataType, PolicyType>::SampleSlab(
     InputType& slabMean,
     DataType& slab)
diff --git a/src/mlpack/methods/bayesian_linear_regression/bayesian_linear_regression.hpp b/src/mlpack/methods/bayesian_linear_regression/bayesian_linear_regression.hpp
index f59dea34b1..84779e9723 100644
--- a/src/mlpack/methods/bayesian_linear_regression/bayesian_linear_regression.hpp
+++ b/src/mlpack/methods/bayesian_linear_regression/bayesian_linear_regression.hpp
@@ -139,9 +139,9 @@ class BayesianLinearRegression
    */
   template<typename MatType,
            typename ResponsesType,
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   BayesianLinearRegression(const MatType& data,
                            const ResponsesType& responses,
                            const bool centerData = true,
@@ -175,9 +175,9 @@ class BayesianLinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const std::optional<bool> centerData = std::nullopt,
@@ -187,9 +187,9 @@ class BayesianLinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool centerData,
@@ -231,9 +231,9 @@ class BayesianLinearRegression
    */
   template<typename MatType,
            typename ResponsesType,
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   void Predict(const MatType& points,
                ResponsesType& predictions) const;
 
@@ -249,9 +249,9 @@ class BayesianLinearRegression
    */
   template<typename MatType,
            typename ResponsesType,
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   void Predict(const MatType& points,
                ResponsesType& predictions,
                ResponsesType& std) const;
@@ -266,9 +266,9 @@ class BayesianLinearRegression
    **/
   template<typename MatType,
            typename ResponsesType,
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType RMSE(const MatType& data,
                 const ResponsesType& responses) const;
 
diff --git a/src/mlpack/methods/decision_tree/decision_tree.hpp b/src/mlpack/methods/decision_tree/decision_tree.hpp
index 24409fa2db..5ed4cbd9bd 100644
--- a/src/mlpack/methods/decision_tree/decision_tree.hpp
+++ b/src/mlpack/methods/decision_tree/decision_tree.hpp
@@ -130,7 +130,7 @@ class DecisionTree :
       const size_t maximumDepth = 0,
       DimensionSelectionType dimensionSelector = DimensionSelectionType(),
       const std::enable_if_t<arma::is_arma_type<
-          typename std::remove_reference<WeightsType>::type>::value>* = 0);
+          std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Construct the decision tree on the given data and labels with weights,
@@ -161,7 +161,7 @@ class DecisionTree :
       const size_t maximumDepth = 0,
       DimensionSelectionType dimensionSelector = DimensionSelectionType(),
       const std::enable_if_t<arma::is_arma_type<
-          typename std::remove_reference<WeightsType>::type>::value>* = 0);
+          std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Using the hyperparameters of another decision tree, train on the given data
@@ -193,7 +193,7 @@ class DecisionTree :
       const size_t minimumLeafSize = 10,
       const double minimumGainSplit = 1e-7,
       const std::enable_if_t<arma::is_arma_type<
-          typename std::remove_reference<WeightsType>::type>::value>* = 0);
+          std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Take ownership of another decision tree and train on the given data and
@@ -225,7 +225,7 @@ class DecisionTree :
       const size_t maximumDepth = 0,
       DimensionSelectionType dimensionSelector = DimensionSelectionType(),
       const std::enable_if_t<arma::is_arma_type<
-          typename std::remove_reference<WeightsType>::type>::value>* = 0);
+          std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Construct a decision tree without training it.  It will be a leaf node with
@@ -359,8 +359,8 @@ class DecisionTree :
                const size_t maximumDepth = 0,
                DimensionSelectionType dimensionSelector =
                    DimensionSelectionType(),
-               const std::enable_if_t<arma::is_arma_type<typename
-                   std::remove_reference<WeightsType>::type>::value>* = 0);
+               const std::enable_if_t<arma::is_arma_type<
+                   std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Train the decision tree on the given weighted data, assuming that all
@@ -391,8 +391,8 @@ class DecisionTree :
                const size_t maximumDepth = 0,
                DimensionSelectionType dimensionSelector =
                    DimensionSelectionType(),
-               const std::enable_if_t<arma::is_arma_type<typename
-                   std::remove_reference<WeightsType>::type>::value>* = 0);
+               const std::enable_if_t<arma::is_arma_type<
+                   std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Classify the given point, using the entire tree.  The predicted label is
diff --git a/src/mlpack/methods/decision_tree/decision_tree_impl.hpp b/src/mlpack/methods/decision_tree/decision_tree_impl.hpp
index 799aebf406..b8102a2445 100644
--- a/src/mlpack/methods/decision_tree/decision_tree_impl.hpp
+++ b/src/mlpack/methods/decision_tree/decision_tree_impl.hpp
@@ -37,8 +37,8 @@ DecisionTree<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector)
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -74,8 +74,8 @@ DecisionTree<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector)
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -112,11 +112,11 @@ DecisionTree<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<arma::is_arma_type<
-        typename std::remove_reference<WeightsType>::type>::value>*)
+        std::remove_reference_t<WeightsType>>::value>*)
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -153,11 +153,11 @@ DecisionTree<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<arma::is_arma_type<
-        typename std::remove_reference<WeightsType>::type>::value>*)
+        std::remove_reference_t<WeightsType>>::value>*)
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -193,13 +193,13 @@ DecisionTree<FitnessFunction,
     const size_t minimumLeafSize,
     const double minimumGainSplit,
     const std::enable_if_t<arma::is_arma_type<
-        typename std::remove_reference<WeightsType>::type>::value>*):
+        std::remove_reference_t<WeightsType>>::value>*):
         NumericAuxiliarySplitInfo(other),
         CategoricalAuxiliarySplitInfo(other)
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -233,14 +233,13 @@ DecisionTree<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<arma::is_arma_type<
-        typename std::remove_reference<
-        WeightsType>::type>::value>*):
+        std::remove_reference_t<WeightsType>>::value>*):
         NumericAuxiliarySplitInfo(other),
         CategoricalAuxiliarySplitInfo(other)  // other info does need to copy
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -458,8 +457,8 @@ double DecisionTree<FitnessFunction,
   // Sanity check on data.
   util::CheckSameSizes(data, labels, "DecisionTree::Train()");
 
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -498,8 +497,8 @@ double DecisionTree<FitnessFunction,
   // Sanity check on data.
   util::CheckSameSizes(data, labels, "DecisionTree::Train()");
 
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -538,15 +537,14 @@ double DecisionTree<FitnessFunction,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<
         arma::is_arma_type<
-        typename std::remove_reference<
-        WeightsType>::type>::value>*)
+        std::remove_reference_t<WeightsType>>::value>*)
 {
   // Sanity check on data.
   util::CheckSameSizes(data, labels, "DecisionTree::Train()");
 
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -584,15 +582,14 @@ double DecisionTree<FitnessFunction,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<
         arma::is_arma_type<
-        typename std::remove_reference<
-        WeightsType>::type>::value>*)
+        std::remove_reference_t<WeightsType>>::value>*)
 {
   // Sanity check on data.
   util::CheckSameSizes(data, labels, "DecisionTree::Train()");
 
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueLabelsType = typename std::decay<LabelsType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueLabelsType = std::decay_t<LabelsType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
diff --git a/src/mlpack/methods/decision_tree/decision_tree_regressor.hpp b/src/mlpack/methods/decision_tree/decision_tree_regressor.hpp
index f5441b509d..b0f4a61241 100644
--- a/src/mlpack/methods/decision_tree/decision_tree_regressor.hpp
+++ b/src/mlpack/methods/decision_tree/decision_tree_regressor.hpp
@@ -129,7 +129,7 @@ class DecisionTreeRegressor :
       const size_t maximumDepth = 0,
       DimensionSelectionType dimensionSelector = DimensionSelectionType(),
       const std::enable_if_t<arma::is_arma_type<
-          typename std::remove_reference<WeightsType>::type>::value>* = 0);
+          std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Construct the decision tree on the given data and responses with weights,
@@ -158,7 +158,7 @@ class DecisionTreeRegressor :
       const size_t maximumDepth = 0,
       DimensionSelectionType dimensionSelector = DimensionSelectionType(),
       const std::enable_if_t<arma::is_arma_type<
-          typename std::remove_reference<WeightsType>::type>::value>* = 0);
+          std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Take ownership of another decision tree and train on the given data and
@@ -188,7 +188,7 @@ class DecisionTreeRegressor :
       const size_t minimumLeafSize = 10,
       const double minimumGainSplit = 1e-7,
       const std::enable_if_t<arma::is_arma_type<
-          typename std::remove_reference<WeightsType>::type>::value>* = 0);
+          std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Take ownership of another decision tree and train on the given data and
@@ -218,7 +218,7 @@ class DecisionTreeRegressor :
       const size_t maximumDepth = 0,
       DimensionSelectionType dimensionSelector = DimensionSelectionType(),
       const std::enable_if_t<arma::is_arma_type<
-          typename std::remove_reference<WeightsType>::type>::value>* = 0);
+          std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Copy another tree.  This may use a lot of memory---be sure that it's what
@@ -347,8 +347,8 @@ class DecisionTreeRegressor :
                DimensionSelectionType dimensionSelector =
                    DimensionSelectionType(),
                FitnessFunction fitnessFunction = FitnessFunction(),
-               const std::enable_if_t<arma::is_arma_type<typename
-                   std::remove_reference<WeightsType>::type>::value>* = 0);
+               const std::enable_if_t<arma::is_arma_type<
+                   std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Train the decision tree on the given weighted data, assuming that all
@@ -380,8 +380,8 @@ class DecisionTreeRegressor :
                DimensionSelectionType dimensionSelector =
                    DimensionSelectionType(),
                FitnessFunction fitnessFunction = FitnessFunction(),
-               const std::enable_if_t<arma::is_arma_type<typename
-                   std::remove_reference<WeightsType>::type>::value>* = 0);
+               const std::enable_if_t<arma::is_arma_type<
+                   std::remove_reference_t<WeightsType>>::value>* = 0);
 
   /**
    * Make prediction for the given point, using the entire tree.  The predicted
diff --git a/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp b/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp
index 05875a75f1..b2fc5538a5 100644
--- a/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp
+++ b/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp
@@ -52,8 +52,8 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector) : splitInfo()
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -88,8 +88,8 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector) : splitInfo()
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -125,12 +125,12 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<arma::is_arma_type<
-        typename std::remove_reference<WeightsType>::type>::value>*)
+        std::remove_reference_t<WeightsType>>::value>*)
     : splitInfo()
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   TrueMatType tmpData(std::move(data));
   TrueResponsesType tmpResponses(std::move(responses));
@@ -166,12 +166,12 @@ DecisionTreeRegressor<FitnessFunction,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<
         arma::is_arma_type<
-        typename std::remove_reference<
-        WeightsType>::type>::value>*) : splitInfo()
+        std::remove_reference_t<
+        WeightsType>>::value>*) : splitInfo()
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -206,14 +206,14 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t minimumLeafSize,
     const double minimumGainSplit,
     const std::enable_if_t<arma::is_arma_type<
-        typename std::remove_reference<WeightsType>::type>::value>*):
+        std::remove_reference_t<WeightsType>>::value>*):
         splitInfo(std::move(other.splitInfo)),
         NumericAuxiliarySplitInfo(other),
         CategoricalAuxiliarySplitInfo(other)
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -246,15 +246,15 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<arma::is_arma_type<
-        typename std::remove_reference<
-        WeightsType>::type>::value>*):
+        std::remove_reference_t<
+        WeightsType>>::value>*):
         splitInfo(std::move(other.splitInfo)),
         NumericAuxiliarySplitInfo(other),
         CategoricalAuxiliarySplitInfo(other)   // other info does need to copy
 {
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -442,8 +442,8 @@ double DecisionTreeRegressor<FitnessFunction,
   // Sanity check on data.
   util::CheckSameSizes(data, responses, "DecisionTreeRegressor::Train()");
 
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -482,8 +482,8 @@ double DecisionTreeRegressor<FitnessFunction,
   // Sanity check on data.
   util::CheckSameSizes(data, responses, "DecisionTreeRegressor::Train()");
 
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -522,15 +522,15 @@ double DecisionTreeRegressor<FitnessFunction,
     FitnessFunction fitnessFunction,
     const std::enable_if_t<
         arma::is_arma_type<
-        typename std::remove_reference<
-        WeightsType>::type>::value>*)
+        std::remove_reference_t<
+        WeightsType>>::value>*)
 {
   // Sanity check on data.
   util::CheckSameSizes(data, responses, "DecisionTreeRegressor::Train()");
 
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
@@ -568,15 +568,15 @@ double DecisionTreeRegressor<FitnessFunction,
     FitnessFunction fitnessFunction,
     const std::enable_if_t<
         arma::is_arma_type<
-        typename std::remove_reference<
-        WeightsType>::type>::value>*)
+        std::remove_reference_t<
+        WeightsType>>::value>*)
 {
   // Sanity check on data.
   util::CheckSameSizes(data, responses, "DecisionTreeRegressor::Train()");
 
-  using TrueMatType = typename std::decay<MatType>::type;
-  using TrueResponsesType = typename std::decay<ResponsesType>::type;
-  using TrueWeightsType = typename std::decay<WeightsType>::type;
+  using TrueMatType = std::decay_t<MatType>;
+  using TrueResponsesType = std::decay_t<ResponsesType>;
+  using TrueWeightsType = std::decay_t<WeightsType>;
 
   // Copy or move data.
   TrueMatType tmpData(std::move(data));
diff --git a/src/mlpack/methods/decision_tree/splits/best_binary_categorical_split_impl.hpp b/src/mlpack/methods/decision_tree/splits/best_binary_categorical_split_impl.hpp
index d5cd9ccd58..1e078c5600 100644
--- a/src/mlpack/methods/decision_tree/splits/best_binary_categorical_split_impl.hpp
+++ b/src/mlpack/methods/decision_tree/splits/best_binary_categorical_split_impl.hpp
@@ -157,7 +157,7 @@ double BestBinaryCategoricalSplit<FitnessFunction>::SplitIfBetter(
     AuxiliarySplitInfo& aux,
     FitnessFunction& fitnessFunction)
 {
-  static_assert(std::is_same<FitnessFunction, MSEGain>::value,
+  static_assert(std::is_same_v<FitnessFunction, MSEGain>,
       "BestBinaryCategoricalSplit: regression FitnessFunction must be "
       "MSEGain.");
   const size_t n = data.n_elem;
diff --git a/src/mlpack/methods/decision_tree/splits/best_binary_numeric_split.hpp b/src/mlpack/methods/decision_tree/splits/best_binary_numeric_split.hpp
index bc1adac8f9..3857ff9cd5 100644
--- a/src/mlpack/methods/decision_tree/splits/best_binary_numeric_split.hpp
+++ b/src/mlpack/methods/decision_tree/splits/best_binary_numeric_split.hpp
@@ -108,9 +108,9 @@ class BestBinaryNumericSplit
    */
   template<bool UseWeights, typename VecType, typename ResponsesType,
            typename WeightVecType>
-  static typename std::enable_if<
+  static std::enable_if_t<
       !HasOptimizedBinarySplitForms<FitnessFunction, UseWeights>::value,
-      double>::type
+      double>
   SplitIfBetter(
       const double bestGain,
       const VecType& data,
@@ -145,9 +145,9 @@ class BestBinaryNumericSplit
    */
   template<bool UseWeights, typename VecType, typename ResponsesType,
           typename WeightVecType>
-  static typename std::enable_if<
+  static std::enable_if_t<
       HasOptimizedBinarySplitForms<FitnessFunction, UseWeights>::value,
-      double>::type
+      double>
   SplitIfBetter(
       const double bestGain,
       const VecType& data,
diff --git a/src/mlpack/methods/decision_tree/splits/best_binary_numeric_split_impl.hpp b/src/mlpack/methods/decision_tree/splits/best_binary_numeric_split_impl.hpp
index a5717e2347..4687506a16 100644
--- a/src/mlpack/methods/decision_tree/splits/best_binary_numeric_split_impl.hpp
+++ b/src/mlpack/methods/decision_tree/splits/best_binary_numeric_split_impl.hpp
@@ -207,9 +207,9 @@ double BestBinaryNumericSplit<FitnessFunction>::SplitIfBetter(
 template<typename FitnessFunction>
 template<bool UseWeights, typename VecType, typename ResponsesType,
          typename WeightVecType>
-typename std::enable_if<
+std::enable_if_t<
     !HasOptimizedBinarySplitForms<FitnessFunction, UseWeights>::value,
-    double>::type
+    double>
 BestBinaryNumericSplit<FitnessFunction>::SplitIfBetter(
     const double bestGain,
     const VecType& data,
@@ -363,9 +363,9 @@ BestBinaryNumericSplit<FitnessFunction>::SplitIfBetter(
 template<typename FitnessFunction>
 template<bool UseWeights, typename VecType, typename ResponsesType,
          typename WeightVecType>
-typename std::enable_if<
+std::enable_if_t<
     HasOptimizedBinarySplitForms<FitnessFunction, UseWeights>::value,
-    double>::type
+    double>
 BestBinaryNumericSplit<FitnessFunction>::SplitIfBetter(
     const double bestGain,
     const VecType& data,
diff --git a/src/mlpack/methods/det/dtree_impl.hpp b/src/mlpack/methods/det/dtree_impl.hpp
index fe1100b178..e62c851f9e 100644
--- a/src/mlpack/methods/det/dtree_impl.hpp
+++ b/src/mlpack/methods/det/dtree_impl.hpp
@@ -30,7 +30,7 @@ void ExtractSplits(std::vector<std::pair<ElemType, size_t>>& splitVec,
                    const size_t minLeafSize)
 {
   static_assert(
-    std::is_same<typename MatType::elem_type, ElemType>::value == true,
+    std::is_same_v<typename MatType::elem_type, ElemType> == true,
     "The ElemType does not correspond to the matrix's element type.");
 
   typedef std::pair<ElemType, size_t> SplitItem;
diff --git a/src/mlpack/methods/gmm/em_fit_impl.hpp b/src/mlpack/methods/gmm/em_fit_impl.hpp
index 19fc220b7d..485d147c02 100644
--- a/src/mlpack/methods/gmm/em_fit_impl.hpp
+++ b/src/mlpack/methods/gmm/em_fit_impl.hpp
@@ -44,7 +44,7 @@ Estimate(const arma::mat& observations,
          arma::vec& weights,
          const bool useInitialModel)
 {
-  if (std::is_same<Distribution, DiagonalGaussianDistribution<>>::value)
+  if (std::is_same_v<Distribution, DiagonalGaussianDistribution<>>)
   {
     #ifdef _WIN32
       Log::Warn << "Cannot use arma::gmm_diag on Visual Studio due to OpenMP"
@@ -55,8 +55,8 @@ Estimate(const arma::mat& observations,
       return;
     #endif
   }
-  else if (std::is_same<CovarianceConstraintPolicy, DiagonalConstraint>::value
-      && std::is_same<Distribution, GaussianDistribution<>>::value)
+  else if (std::is_same_v<CovarianceConstraintPolicy, DiagonalConstraint>
+      && std::is_same_v<Distribution, GaussianDistribution<>>)
   {
     // EMFit::Estimate() using DiagonalConstraint with GaussianDistribution
     // makes use of slower implementation.
@@ -129,7 +129,7 @@ Estimate(const arma::mat& observations,
 
       // If the distribution is DiagonalGaussianDistribution, calculate the
       // covariance only with diagonal components.
-      if (std::is_same<Distribution, DiagonalGaussianDistribution<>>::value)
+      if (std::is_same_v<Distribution, DiagonalGaussianDistribution<>>)
       {
         arma::vec covariance = sum((tmp % tmp) %
             (ones<arma::vec>(observations.n_rows) *
@@ -240,7 +240,7 @@ Estimate(const arma::mat& observations,
 
       // If the distribution is DiagonalGaussianDistribution, calculate the
       // covariance only with diagonal components.
-      if (std::is_same<Distribution, DiagonalGaussianDistribution<>>::value)
+      if (std::is_same_v<Distribution, DiagonalGaussianDistribution<>>)
       {
         arma::vec cov = sum((tmp % tmp) %
             (ones<arma::vec>(observations.n_rows) *
@@ -292,8 +292,8 @@ InitialClustering(const arma::mat& observations,
   // Check if the type of Distribution is DiagonalGaussianDistribution.  If so,
   // we can get faster performance by using diagonal elements when calculating
   // the covariance.
-  const bool isDiagGaussDist = std::is_same<Distribution,
-      DiagonalGaussianDistribution<>>::value;
+  const bool isDiagGaussDist = std::is_same_v<Distribution,
+      DiagonalGaussianDistribution<>>;
 
   std::vector<arma::vec> means(dists.size());
 
@@ -437,7 +437,7 @@ ArmadilloGMMWrapper(const arma::mat& observations,
   // Armadillo's implementation.  If mlpack ever changes k-means defaults to use
   // something that is reliably quicker than the Lloyd iteration k-means update,
   // then this code maybe should be revisited.
-  if (!std::is_same<InitialClusteringType, KMeans<>>::value || useInitialModel)
+  if (!std::is_same_v<InitialClusteringType, KMeans<>> || useInitialModel)
   {
     // Use clusterer to get initial values.
     if (!useInitialModel)
diff --git a/src/mlpack/methods/gmm/positive_definite_constraint.hpp b/src/mlpack/methods/gmm/positive_definite_constraint.hpp
index 23742975bb..a153533ded 100644
--- a/src/mlpack/methods/gmm/positive_definite_constraint.hpp
+++ b/src/mlpack/methods/gmm/positive_definite_constraint.hpp
@@ -35,7 +35,7 @@ class PositiveDefiniteConstraint
   template<typename MatType>
   static void ApplyConstraint(
       MatType& covariance,
-      const typename std::enable_if<!IsVector<MatType>::value>::type*
+      const std::enable_if_t<!IsVector<MatType>::value>*
           /* junk */ = 0)
   {
     typedef typename MatType::elem_type ElemType;
@@ -82,7 +82,7 @@ class PositiveDefiniteConstraint
   template<typename VecType>
   static void ApplyConstraint(
       VecType& diagCovariance,
-      const typename std::enable_if<IsVector<VecType>::value>::type*
+      const std::enable_if_t<IsVector<VecType>::value>*
           /* junk */ = 0)
   {
     typedef typename VecType::elem_type ElemType;
diff --git a/src/mlpack/methods/kde/kde_impl.hpp b/src/mlpack/methods/kde/kde_impl.hpp
index 4bf4b939c0..6e5fe10fed 100644
--- a/src/mlpack/methods/kde/kde_impl.hpp
+++ b/src/mlpack/methods/kde/kde_impl.hpp
@@ -498,7 +498,7 @@ Evaluate(Tree* queryTree,
   }
 
   // Clean accumulated alpha if Monte Carlo estimations are available.
-  if (monteCarlo && std::is_same<KernelType, GaussianKernel>::value)
+  if (monteCarlo && std::is_same_v<KernelType, GaussianKernel>)
   {
     KDECleanRules<Tree> cleanRules;
     SingleTreeTraversalType<KDECleanRules<Tree>> cleanTraverser(cleanRules);
@@ -562,7 +562,7 @@ Evaluate(arma::vec& estimations)
   estimations.fill(arma::fill::zeros);
 
   // Clean accumulated alpha if Monte Carlo estimations are available.
-  if (monteCarlo && std::is_same<KernelType, GaussianKernel>::value)
+  if (monteCarlo && std::is_same_v<KernelType, GaussianKernel>)
   {
     KDECleanRules<Tree> cleanRules;
     SingleTreeTraversalType<KDECleanRules<Tree>> cleanTraverser(cleanRules);
diff --git a/src/mlpack/methods/kde/kde_model.hpp b/src/mlpack/methods/kde/kde_model.hpp
index 835c883a94..e520405f14 100644
--- a/src/mlpack/methods/kde/kde_model.hpp
+++ b/src/mlpack/methods/kde/kde_model.hpp
@@ -43,9 +43,9 @@ class KernelNormalizer
       KernelType& /* kernel */,
       const size_t /* dimension */,
       arma::vec& /* estimations */,
-      const typename std::enable_if<
-          !HasNormalizer<KernelType, double(KernelType::*)(size_t)>::value>::
-          type* = 0)
+      const std::enable_if_t<
+          !HasNormalizer<KernelType, double(KernelType::*)(size_t)>::value>*
+          = 0)
   { return; }
 
   //! Normalize kernels that have normalizer.
@@ -54,9 +54,9 @@ class KernelNormalizer
       KernelType& kernel,
       const size_t dimension,
       arma::vec& estimations,
-      const typename std::enable_if<
-          HasNormalizer<KernelType, double(KernelType::*)(size_t)>::value>::
-          type* = 0)
+      const std::enable_if_t<
+          HasNormalizer<KernelType, double(KernelType::*)(size_t)>::value>*
+          = 0)
   {
     estimations /= kernel.Normalizer(dimension);
   }
diff --git a/src/mlpack/methods/kde/kde_rules.hpp b/src/mlpack/methods/kde/kde_rules.hpp
index 671abbc478..1a77894c40 100644
--- a/src/mlpack/methods/kde/kde_rules.hpp
+++ b/src/mlpack/methods/kde/kde_rules.hpp
@@ -159,7 +159,7 @@ class KDERules
 
   //! Whether the kernel used for the rule is the Gaussian Kernel.
   constexpr static bool kernelIsGaussian =
-      std::is_same<KernelType, GaussianKernel>::value;
+      std::is_same_v<KernelType, GaussianKernel>;
 
   //! Absolute error tolerance available for each reference point.
   const double absErrorTol;
diff --git a/src/mlpack/methods/kmeans/dual_tree_kmeans_impl.hpp b/src/mlpack/methods/kmeans/dual_tree_kmeans_impl.hpp
index 8181b49512..691e8b75e8 100644
--- a/src/mlpack/methods/kmeans/dual_tree_kmeans_impl.hpp
+++ b/src/mlpack/methods/kmeans/dual_tree_kmeans_impl.hpp
@@ -27,8 +27,8 @@ template<typename TreeType, typename MatType>
 TreeType* BuildForcedLeafSizeTree(
     MatType&& dataset,
     std::vector<size_t>& oldFromNew,
-    const typename std::enable_if<
-        TreeTraits<TreeType>::RearrangesDataset>::type* = 0)
+    const std::enable_if_t<
+        TreeTraits<TreeType>::RearrangesDataset>* = 0)
 {
   // This is a hack.  I know this will be BinarySpaceTree, so force a leaf size
   // of one.
@@ -40,8 +40,8 @@ template<typename TreeType, typename MatType>
 TreeType* BuildForcedLeafSizeTree(
     MatType&& dataset,
     const std::vector<size_t>& /* oldFromNew */,
-    const typename std::enable_if<
-        !TreeTraits<TreeType>::RearrangesDataset>::type* = 0)
+    const std::enable_if_t<
+        !TreeTraits<TreeType>::RearrangesDataset>* = 0)
 {
   return new TreeType(std::forward<MatType>(dataset));
 }
diff --git a/src/mlpack/methods/lars/lars.hpp b/src/mlpack/methods/lars/lars.hpp
index 32bf5c6b7e..fa001aba96 100644
--- a/src/mlpack/methods/lars/lars.hpp
+++ b/src/mlpack/methods/lars/lars.hpp
@@ -165,9 +165,9 @@ class LARS
    */
   template<typename MatType,
            typename ResponsesType,
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   LARS(const MatType& data,
        const ResponsesType& responses,
        bool colMajor = true,
@@ -204,9 +204,9 @@ class LARS
    */
   template<typename MatType,
            typename ResponsesType,
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   LARS(const MatType& data,
        const ResponsesType& responses,
        const bool colMajor,
@@ -296,12 +296,12 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type,
-           typename = typename std::enable_if<
-               !std::is_same<ResponsesType, arma::rowvec>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >,
+           typename = std::enable_if_t<
+               !std::is_same_v<ResponsesType, arma::rowvec>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor = true);
@@ -309,9 +309,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -320,9 +320,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -332,9 +332,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -345,9 +345,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -359,9 +359,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -374,9 +374,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -407,9 +407,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -419,9 +419,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -432,9 +432,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -446,9 +446,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -461,9 +461,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -477,9 +477,9 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
diff --git a/src/mlpack/methods/linear_regression/linear_regression.hpp b/src/mlpack/methods/linear_regression/linear_regression.hpp
index 71d28e1933..639d23eb01 100644
--- a/src/mlpack/methods/linear_regression/linear_regression.hpp
+++ b/src/mlpack/methods/linear_regression/linear_regression.hpp
@@ -43,9 +43,9 @@ class LinearRegression
    */
   template<typename MatType,
            typename ResponsesType,
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   LinearRegression(const MatType& predictors,
                    const ResponsesType& responses,
                    const double lambda = 0,
@@ -63,12 +63,12 @@ class LinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename WeightsType,
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type,
-           typename = typename std::enable_if<
-               std::is_same<typename WeightsType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >,
+           typename = std::enable_if_t<
+               std::is_same_v<typename WeightsType::elem_type, ElemType>
+           >>
   LinearRegression(const MatType& predictors,
                    const ResponsesType& responses,
                    const WeightsType& weights,
@@ -103,8 +103,8 @@ class LinearRegression
   double Train(const arma::mat& predictors,
                const arma::rowvec& responses,
                const T intercept,
-               const typename std::enable_if<std::is_same<T, bool>::value
-                   >::type* = 0);
+               const std::enable_if_t<std::is_same_v<T, bool>
+                   >* = 0);
 
   /**
    * Train the LinearRegression model on the given data and instance weights.
@@ -129,8 +129,8 @@ class LinearRegression
                const arma::rowvec& responses,
                const arma::rowvec& weights,
                const T intercept,
-               const typename std::enable_if<std::is_same<T, bool>::value
-                   >::type* = 0);
+               const std::enable_if_t<std::is_same_v<T, bool>
+                   >* = 0);
 
   /**
    * Train the LinearRegression model.  This is a dummy overload so that
@@ -157,9 +157,9 @@ class LinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& predictors,
                  const ResponsesType& responses,
                  const std::optional<double> lambda = std::nullopt,
@@ -192,12 +192,12 @@ class LinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename WeightsType,
-           typename = typename std::enable_if<
-               std::is_same<typename ResponsesType::elem_type, ElemType>::value
-           >::type,
-           typename = typename std::enable_if<
-               std::is_same<typename WeightsType::elem_type, ElemType>::value
-           >::type>
+           typename = std::enable_if_t<
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>
+           >,
+           typename = std::enable_if_t<
+               std::is_same_v<typename WeightsType::elem_type, ElemType>
+           >>
   ElemType Train(const MatType& predictors,
                  const ResponsesType& responses,
                  const WeightsType& weights,
diff --git a/src/mlpack/methods/linear_regression/linear_regression_impl.hpp b/src/mlpack/methods/linear_regression/linear_regression_impl.hpp
index 1b3569d1e8..7676370ef3 100644
--- a/src/mlpack/methods/linear_regression/linear_regression_impl.hpp
+++ b/src/mlpack/methods/linear_regression/linear_regression_impl.hpp
@@ -51,7 +51,7 @@ inline double LinearRegression<ModelMatType>::Train(
     const arma::mat& predictors,
     const arma::rowvec& responses,
     const T intercept,
-    const typename std::enable_if<std::is_same<T, bool>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T, bool>>*)
 {
   return Train(predictors, responses, arma::rowvec(), this->lambda, intercept);
 }
@@ -63,7 +63,7 @@ inline double LinearRegression<ModelMatType>::Train(
     const arma::rowvec& responses,
     const arma::rowvec& weights,
     const T intercept,
-    const typename std::enable_if<std::is_same<T, bool>::value>::type*)
+    const std::enable_if_t<std::is_same_v<T, bool>>*)
 {
   return Train(predictors, responses, weights, this->lambda, intercept);
 }
diff --git a/src/mlpack/methods/linear_svm/linear_svm.hpp b/src/mlpack/methods/linear_svm/linear_svm.hpp
index 61fb7875f6..dd680da97b 100644
--- a/src/mlpack/methods/linear_svm/linear_svm.hpp
+++ b/src/mlpack/methods/linear_svm/linear_svm.hpp
@@ -135,14 +135,14 @@ class LinearSVM
    */
   template<typename OptimizerType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType,
                LinearSVMFunction<arma::mat, ModelMatType>,
                ModelMatType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   [[deprecated("Will be removed in mlpack 5.0.0, use other constructors")]]
   LinearSVM(const arma::mat& data,
             const arma::Row<size_t>& labels,
@@ -173,11 +173,11 @@ class LinearSVM
    * @param optimizer Desired optimizer.
    */
   template<typename OptimizerType = ens::L_BFGS,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType,
                LinearSVMFunction<arma::mat, ModelMatType>,
                ModelMatType
-           >::value>::type>
+           >::value>>
   [[deprecated("Will be removed in mlpack 5.0.0, use other constructors")]]
   LinearSVM(const arma::mat& data,
             const arma::Row<size_t>& labels,
@@ -203,9 +203,9 @@ class LinearSVM
    */
   template<typename MatType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   LinearSVM(const MatType& data,
             const arma::Row<size_t>& labels,
             const size_t numClasses,
@@ -232,9 +232,9 @@ class LinearSVM
   template<typename MatType,
            typename OptimizerType = ens::L_BFGS,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   LinearSVM(const MatType& data,
             const arma::Row<size_t>& labels,
             const size_t numClasses,
@@ -259,9 +259,9 @@ class LinearSVM
    */
   template<typename MatType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& data,
                  const arma::Row<size_t>& labels,
                  const size_t numClasses,
@@ -269,9 +269,9 @@ class LinearSVM
 
   template<typename MatType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& data,
                  const arma::Row<size_t>& labels,
                  const size_t numClasses,
@@ -299,14 +299,14 @@ class LinearSVM
   template<typename MatType,
            typename OptimizerType = ens::L_BFGS,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType,
                LinearSVMFunction<MatType, ModelMatType>,
                ModelMatType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& data,
                  const arma::Row<size_t>& labels,
                  const size_t numClasses,
@@ -316,14 +316,14 @@ class LinearSVM
   template<typename MatType,
            typename OptimizerType = ens::L_BFGS,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType,
                LinearSVMFunction<MatType, ModelMatType>,
                ModelMatType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& data,
                  const arma::Row<size_t>& labels,
                  const size_t numClasses,
diff --git a/src/mlpack/methods/lmnn/lmnn.hpp b/src/mlpack/methods/lmnn/lmnn.hpp
index 8dadc5b31e..6f62734b4b 100644
--- a/src/mlpack/methods/lmnn/lmnn.hpp
+++ b/src/mlpack/methods/lmnn/lmnn.hpp
@@ -97,12 +97,12 @@ class LMNN
    *      See https://www.ensmallen.org/docs.html#callback-documentation.
    */
   template<typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type,
-           typename = typename std::enable_if<
+           >::value>,
+           typename = std::enable_if_t<
                !FirstElementIsArma<CallbackTypes...>::value
-           >::type>
+           >>
   [[deprecated("Will be removed in mlpack 5.0.0.  Use the version that takes a "
                "dataset as a parameter.")]]
   void LearnDistance(arma::mat& outputMatrix, CallbackTypes&&... callbacks);
@@ -122,14 +122,14 @@ class LMNN
   template<typename MatType,
            typename LabelsType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<!IsEnsOptimizer<
+           typename = std::enable_if_t<!IsEnsOptimizer<
                typename First<CallbackTypes...>::type,
                LMNNFunction<MatType, LabelsType, DistanceType>,
                MatType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   void LearnDistance(const MatType& dataset,
                      const LabelsType& labels,
                      MatType& outputMatrix,
@@ -152,11 +152,11 @@ class LMNN
            typename LabelsType,
            typename OptimizerType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType,
                LMNNFunction<MatType, LabelsType, DistanceType>,
                MatType
-           >::value>::type>
+           >::value>>
   void LearnDistance(const MatType& dataset,
                      const LabelsType& labels,
                      MatType& outputMatrix,
diff --git a/src/mlpack/methods/local_coordinate_coding/lcc_impl.hpp b/src/mlpack/methods/local_coordinate_coding/lcc_impl.hpp
index 2894d015f6..f7d9c7090c 100644
--- a/src/mlpack/methods/local_coordinate_coding/lcc_impl.hpp
+++ b/src/mlpack/methods/local_coordinate_coding/lcc_impl.hpp
@@ -145,7 +145,7 @@ inline void LocalCoordinateCoding<MatType>::Encode(const MatType& data,
 
     bool useCholesky = false;
     // Normalization and fitting and intercept are disabled.
-    const double tol = std::is_same<typename MatType::elem_type, float>::value ?
+    const double tol = std::is_same_v<typename MatType::elem_type, float> ?
         1e-8 : 1e-16;
     LARS<MatType> lars(useCholesky, 0.5 * lambda, 0, tol, false, false);
 
diff --git a/src/mlpack/methods/logistic_regression/logistic_regression.hpp b/src/mlpack/methods/logistic_regression/logistic_regression.hpp
index 37fddf2f15..6dd06dbd00 100644
--- a/src/mlpack/methods/logistic_regression/logistic_regression.hpp
+++ b/src/mlpack/methods/logistic_regression/logistic_regression.hpp
@@ -67,9 +67,9 @@ class LogisticRegression
    * @param lambda L2-regularization parameter.
    */
   template<typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   LogisticRegression(const MatType& predictors,
                      const arma::Row<size_t>& responses,
                      const double lambda = 0.0,
@@ -91,9 +91,9 @@ class LogisticRegression
    *     (L-BFGS).
    */
   template<typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   LogisticRegression(const MatType& predictors,
                      const arma::Row<size_t>& responses,
                      const RowType& initialPoint,
@@ -117,12 +117,12 @@ class LogisticRegression
    */
   template<typename OptimizerType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, LogisticRegressionFunction<MatType>, RowType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   LogisticRegression(const MatType& predictors,
                      const arma::Row<size_t>& responses,
                      OptimizerType& optimizer,
@@ -147,12 +147,12 @@ class LogisticRegression
    */
   template<typename OptimizerType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, LogisticRegressionFunction<MatType>, RowType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   LogisticRegression(const MatType& predictors,
                      const arma::Row<size_t>& responses,
                      OptimizerType& optimizer,
@@ -179,9 +179,9 @@ class LogisticRegression
    */
   template<typename OptimizerType = ens::L_BFGS,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& predictors,
                  const arma::Row<size_t>& responses,
                  CallbackTypes&&... callbacks);
@@ -206,9 +206,9 @@ class LogisticRegression
    */
   template<typename OptimizerType = ens::L_BFGS,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& predictors,
                  const arma::Row<size_t>& responses,
                  const double lambda,
@@ -234,12 +234,12 @@ class LogisticRegression
    */
   template<typename OptimizerType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, LogisticRegressionFunction<MatType>, RowType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& predictors,
                  const arma::Row<size_t>& responses,
                  OptimizerType& optimizer,
@@ -266,12 +266,12 @@ class LogisticRegression
    */
   template<typename OptimizerType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, LogisticRegressionFunction<MatType>, RowType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& predictors,
                  const arma::Row<size_t>& responses,
                  OptimizerType& optimizer,
diff --git a/src/mlpack/methods/mean_shift/mean_shift.hpp b/src/mlpack/methods/mean_shift/mean_shift.hpp
index 6316daa8b6..08e8507ecd 100644
--- a/src/mlpack/methods/mean_shift/mean_shift.hpp
+++ b/src/mlpack/methods/mean_shift/mean_shift.hpp
@@ -155,7 +155,7 @@ class MeanShift
    # @param centroid Store calculated centroid
    */
   template<bool ApplyKernel = UseKernel, typename MatType, typename VecType>
-  typename std::enable_if<ApplyKernel, bool>::type
+  std::enable_if_t<ApplyKernel, bool>
   CalculateCentroid(const MatType& data,
                     const std::vector<size_t>& neighbors,
                     const std::vector<typename MatType::elem_type>& distances,
@@ -170,7 +170,7 @@ class MeanShift
    # @param centroid Store calculated centroid
    */
   template<bool ApplyKernel = UseKernel, typename MatType, typename VecType>
-  typename std::enable_if<!ApplyKernel, bool>::type
+  std::enable_if_t<!ApplyKernel, bool>
   CalculateCentroid(const MatType& data,
                     const std::vector<size_t>& neighbors,
                     const std::vector<typename MatType::elem_type>&, /*unused*/
diff --git a/src/mlpack/methods/mean_shift/mean_shift_impl.hpp b/src/mlpack/methods/mean_shift/mean_shift_impl.hpp
index e3ea0dd09e..9c8faa7154 100644
--- a/src/mlpack/methods/mean_shift/mean_shift_impl.hpp
+++ b/src/mlpack/methods/mean_shift/mean_shift_impl.hpp
@@ -131,7 +131,7 @@ void MeanShift<UseKernel, KernelType>::GenSeeds(const MatType& data,
 // Calculate new centroid with given kernel.
 template<bool UseKernel, typename KernelType>
 template<bool ApplyKernel, typename MatType, typename VecType>
-typename std::enable_if<ApplyKernel, bool>::type
+std::enable_if_t<ApplyKernel, bool>
 MeanShift<UseKernel, KernelType>::CalculateCentroid(
     const MatType& data,
     const std::vector<size_t>& neighbors,
@@ -163,7 +163,7 @@ MeanShift<UseKernel, KernelType>::CalculateCentroid(
 // Calculate new centroid by mean.
 template<bool UseKernel, typename KernelType>
 template<bool ApplyKernel, typename MatType, typename VecType>
-typename std::enable_if<!ApplyKernel, bool>::type
+std::enable_if_t<!ApplyKernel, bool>
 MeanShift<UseKernel, KernelType>::CalculateCentroid(
     const MatType& data,
     const std::vector<size_t>& neighbors,
diff --git a/src/mlpack/methods/naive_bayes/naive_bayes_classifier_impl.hpp b/src/mlpack/methods/naive_bayes/naive_bayes_classifier_impl.hpp
index 877079ae12..7e8ced7b3c 100644
--- a/src/mlpack/methods/naive_bayes/naive_bayes_classifier_impl.hpp
+++ b/src/mlpack/methods/naive_bayes/naive_bayes_classifier_impl.hpp
@@ -35,7 +35,7 @@ NaiveBayesClassifier<ModelMatType>::NaiveBayesClassifier(
     trainingPoints(0), // Set when we call Train().
     epsilon(epsilon)
 {
-  static_assert(std::is_same<ElemType, typename MatType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType, typename MatType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
@@ -82,7 +82,7 @@ void NaiveBayesClassifier<ModelMatType>::Train(
     const size_t numClasses,
     const bool incremental)
 {
-  static_assert(std::is_same<ElemType, typename MatType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType, typename MatType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
@@ -178,7 +178,7 @@ template<typename VecType>
 void NaiveBayesClassifier<ModelMatType>::Train(const VecType& point,
                                                const size_t label)
 {
-  static_assert(std::is_same<ElemType, typename VecType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType, typename VecType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
@@ -213,7 +213,7 @@ void NaiveBayesClassifier<ModelMatType>::LogLikelihood(
     const MatType& data,
     ModelMatType& logLikelihoods) const
 {
-  static_assert(std::is_same<ElemType, typename MatType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType, typename MatType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
@@ -241,7 +241,7 @@ template<typename ModelMatType>
 template<typename VecType>
 size_t NaiveBayesClassifier<ModelMatType>::Classify(const VecType& point) const
 {
-  static_assert(std::is_same<ElemType, typename VecType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType, typename VecType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
@@ -270,11 +270,11 @@ void NaiveBayesClassifier<ModelMatType>::Classify(
     size_t& prediction,
     ProbabilitiesVecType& probabilities) const
 {
-  static_assert(std::is_same<ElemType, typename VecType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType, typename VecType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
-  static_assert(std::is_same<ElemType,
-                             typename ProbabilitiesVecType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType,
+                             typename ProbabilitiesVecType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
@@ -312,7 +312,7 @@ void NaiveBayesClassifier<ModelMatType>::Classify(
     const MatType& data,
     arma::Row<size_t>& predictions) const
 {
-  static_assert(std::is_same<ElemType, typename MatType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType, typename MatType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
@@ -345,11 +345,11 @@ void NaiveBayesClassifier<ModelMatType>::Classify(
     arma::Row<size_t>& predictions,
     ProbabilitiesMatType& predictionProbs) const
 {
-  static_assert(std::is_same<ElemType, typename MatType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType, typename MatType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
-  static_assert(std::is_same<ElemType,
-                             typename ProbabilitiesMatType::elem_type>::value,
+  static_assert(std::is_same_v<ElemType,
+                             typename ProbabilitiesMatType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
diff --git a/src/mlpack/methods/nca/nca.hpp b/src/mlpack/methods/nca/nca.hpp
index fd66154b28..1d68ef4db3 100644
--- a/src/mlpack/methods/nca/nca.hpp
+++ b/src/mlpack/methods/nca/nca.hpp
@@ -80,12 +80,12 @@ class NCA
    *      See https://www.ensmallen.org/docs.html#callback-documentation.
    */
   template<typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type,
-           typename = typename std::enable_if<
+           >::value>,
+           typename = std::enable_if_t<
                !FirstElementIsArma<CallbackTypes...>::value
-           >::type>
+           >>
   [[deprecated("Will be removed in mlpack 5.0.0.  Use the version that takes a "
                "dataset as a parameter.")]]
   void LearnDistance(arma::mat& outputMatrix, CallbackTypes&&... callbacks);
@@ -106,14 +106,14 @@ class NCA
   template<typename MatType,
            typename LabelsType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<!IsEnsOptimizer<
+           typename = std::enable_if_t<!IsEnsOptimizer<
                typename First<CallbackTypes...>::type,
                SoftmaxErrorFunction<MatType, LabelsType, DistanceType>,
                MatType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   void LearnDistance(const MatType& dataset,
                      const LabelsType& labels,
                      MatType& outputMatrix,
@@ -137,11 +137,11 @@ class NCA
            typename LabelsType,
            typename OptimizerType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType,
                SoftmaxErrorFunction<MatType, LabelsType, DistanceType>,
                MatType
-           >::value>::type>
+           >::value>>
   void LearnDistance(const MatType& dataset,
                      const LabelsType& labels,
                      MatType& outputMatrix,
diff --git a/src/mlpack/methods/pca/pca_impl.hpp b/src/mlpack/methods/pca/pca_impl.hpp
index 865c968300..d8da5362bc 100644
--- a/src/mlpack/methods/pca/pca_impl.hpp
+++ b/src/mlpack/methods/pca/pca_impl.hpp
@@ -47,8 +47,8 @@ void PCA<DecompositionPolicy>::Apply(const MatType& data,
       "PCA::Apply(): transformedData must be a matrix type!");
   static_assert(IsBaseMatType<VecType>::value,
       "PCA::Apply(): eigVal must be a vector type!");
-  static_assert(std::is_same<typename MatType::elem_type,
-                             typename OutMatType::elem_type>::value,
+  static_assert(std::is_same_v<typename MatType::elem_type,
+                             typename OutMatType::elem_type>,
       "PCA::Apply(): data and transformedData must have the same element "
       "types!");
 
@@ -81,8 +81,8 @@ void PCA<DecompositionPolicy>::Apply(const MatType& data,
       "PCA::Apply(): transformedData must be a matrix type!");
   static_assert(IsBaseMatType<VecType>::value,
       "PCA::Apply(): eigVal must be a vector type!");
-  static_assert(std::is_same<typename MatType::elem_type,
-                             typename OutMatType::elem_type>::value,
+  static_assert(std::is_same_v<typename MatType::elem_type,
+                             typename OutMatType::elem_type>,
       "PCA::Apply(): data and transformedData must have the same element "
       "types!");
 
@@ -104,8 +104,8 @@ void PCA<DecompositionPolicy>::Apply(const MatType& data,
   // Sanity checks on input types.
   static_assert(IsBaseMatType<OutMatType>::value,
       "PCA::Apply(): transformedData must be a matrix type!");
-  static_assert(std::is_same<typename MatType::elem_type,
-                             typename OutMatType::elem_type>::value,
+  static_assert(std::is_same_v<typename MatType::elem_type,
+                             typename OutMatType::elem_type>,
       "PCA::Apply(): data and transformedData must have the same element "
       "types!");
 
diff --git a/src/mlpack/methods/perceptron/perceptron.hpp b/src/mlpack/methods/perceptron/perceptron.hpp
index 1988d980b6..dccc250975 100644
--- a/src/mlpack/methods/perceptron/perceptron.hpp
+++ b/src/mlpack/methods/perceptron/perceptron.hpp
@@ -92,8 +92,8 @@ class Perceptron
              const size_t numClasses,
              const WeightsType& instanceWeights,
              const size_t maxIterations = 1000,
-             const typename std::enable_if<
-                 arma::is_arma_type<WeightsType>::value>::type* = 0);
+             const std::enable_if_t<
+                 arma::is_arma_type<WeightsType>::value>* = 0);
 
   /**
    * Alternate constructor which copies parameters from an already initiated
@@ -114,8 +114,8 @@ class Perceptron
              const arma::Row<size_t>& labels,
              const size_t numClasses,
              const WeightsType& instanceWeights,
-             const typename std::enable_if<
-                 arma::is_arma_type<WeightsType>::value>::type* = 0);
+             const std::enable_if_t<
+                 arma::is_arma_type<WeightsType>::value>* = 0);
 
   /**
    * Train the perceptron on the given data for up to the given maximum number
diff --git a/src/mlpack/methods/perceptron/perceptron_impl.hpp b/src/mlpack/methods/perceptron/perceptron_impl.hpp
index 28f02a8f4d..b8dcc740e8 100644
--- a/src/mlpack/methods/perceptron/perceptron_impl.hpp
+++ b/src/mlpack/methods/perceptron/perceptron_impl.hpp
@@ -83,8 +83,8 @@ Perceptron<LearnPolicy, WeightInitializationPolicy, MatType>::Perceptron(
     const size_t numClasses,
     const WeightsType& instanceWeights,
     const size_t maxIterations,
-    const typename std::enable_if<
-        arma::is_arma_type<WeightsType>::value>::type*) :
+    const std::enable_if_t<
+        arma::is_arma_type<WeightsType>::value>*) :
     maxIterations(maxIterations)
 {
   // Start training.
@@ -114,8 +114,8 @@ Perceptron<LearnPolicy, WeightInitializationPolicy, MatType>::Perceptron(
     const arma::Row<size_t>& labels,
     const size_t numClasses,
     const WeightsType& instanceWeights,
-    const typename std::enable_if<
-        arma::is_arma_type<WeightsType>::value>::type*) :
+    const std::enable_if_t<
+        arma::is_arma_type<WeightsType>::value>*) :
     maxIterations(other.maxIterations)
 {
   TrainInternal<true>(data, labels, numClasses, instanceWeights);
diff --git a/src/mlpack/methods/softmax_regression/softmax_regression.hpp b/src/mlpack/methods/softmax_regression/softmax_regression.hpp
index fb5f3b0c57..8ce97ab28d 100644
--- a/src/mlpack/methods/softmax_regression/softmax_regression.hpp
+++ b/src/mlpack/methods/softmax_regression/softmax_regression.hpp
@@ -93,12 +93,12 @@ class SoftmaxRegression
    */
   template<typename OptimizerType = ens::L_BFGS,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   SoftmaxRegression(const MatType& data,
                     const arma::Row<size_t>& labels,
                     const size_t numClasses,
@@ -125,12 +125,12 @@ class SoftmaxRegression
    */
   template<typename OptimizerType = ens::L_BFGS,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   SoftmaxRegression(const MatType& data,
                     const arma::Row<size_t>& labels,
                     const size_t numClasses,
@@ -158,15 +158,15 @@ class SoftmaxRegression
   template<typename OptimizerType = ens::L_BFGS,
            typename FirstCallbackType,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
-           >::value>::type,
-           typename = typename std::enable_if<
-              std::is_class<FirstCallbackType>::value
-           >::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<
+              std::is_class_v<FirstCallbackType>
+           >,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   [[deprecated("Will be removed in mlpack 5.0.0, use other Train() variants")]]
   double Train(const MatType& data,
                const arma::Row<size_t>& labels,
@@ -191,12 +191,12 @@ class SoftmaxRegression
    */
   template<typename OptimizerType = ens::L_BFGS,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& data,
                  const arma::Row<size_t>& labels,
                  const size_t numClasses,
@@ -221,12 +221,12 @@ class SoftmaxRegression
    */
   template<typename OptimizerType = ens::L_BFGS,
            typename... CallbackTypes,
-           typename = typename std::enable_if<IsEnsOptimizer<
+           typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
-           >::value>::type,
-           typename = typename std::enable_if<IsEnsCallbackTypes<
+           >::value>,
+           typename = std::enable_if_t<IsEnsCallbackTypes<
                CallbackTypes...
-           >::value>::type>
+           >::value>>
   ElemType Train(const MatType& data,
                  const arma::Row<size_t>& labels,
                  const size_t numClasses,
diff --git a/src/mlpack/tests/cv_test.cpp b/src/mlpack/tests/cv_test.cpp
index b78e651f9d..a5ff8dc001 100644
--- a/src/mlpack/tests/cv_test.cpp
+++ b/src/mlpack/tests/cv_test.cpp
@@ -299,7 +299,7 @@ void CheckPredictionsType()
 {
   using Extractor = MetaInfoExtractor<Class, PassedMT, PassedPT>;
   using ActualPT = typename Extractor::PredictionsType;
-  static_assert(std::is_same<ExpectedPT, ActualPT>::value,
+  static_assert(std::is_same_v<ExpectedPT, ActualPT>,
       "Should be the same");
 }
 
@@ -350,7 +350,7 @@ void CheckWeightsType()
 {
   using Extractor = MetaInfoExtractor<Class, PassedMT, PassedPT, PassedWT>;
   using ActualWT = typename Extractor::WeightsType;
-  static_assert(std::is_same<ExpectedWT, ActualWT>::value,
+  static_assert(std::is_same_v<ExpectedWT, ActualWT>,
       "Should be the same");
 }
 
diff --git a/src/mlpack/tests/distribution_test.cpp b/src/mlpack/tests/distribution_test.cpp
index ac73f2ad8b..b1325d557c 100644
--- a/src/mlpack/tests/distribution_test.cpp
+++ b/src/mlpack/tests/distribution_test.cpp
@@ -454,7 +454,7 @@ TEMPLATE_TEST_CASE("GaussianUnivariateProbabilityTest", "[DistributionTest]",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 1e-4 : 1e-7;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 1e-4 : 1e-7;
 
   GaussianDistribution<MatType> g(VecType("0.0"), MatType("1.0"));
 
@@ -500,7 +500,7 @@ TEMPLATE_TEST_CASE("GaussianMultivariateProbabilityTest", "[DistributionTest]",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 1e-4 : 1e-7;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 1e-4 : 1e-7;
 
   // Simple case.
   VecType mean = "0 0";
@@ -611,7 +611,7 @@ TEMPLATE_TEST_CASE("GaussianDistributionRandomTest", "[DistributionTest]",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 0.3 : 0.125;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 0.3 : 0.125;
 
   VecType mean("1.0 2.25");
   MatType cov("0.85 0.60;"
@@ -648,7 +648,7 @@ TEMPLATE_TEST_CASE("GaussianDistributionTrainTest", "[DistributionTest]", float,
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 1e-3 : 1e-5;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 1e-3 : 1e-5;
 
   VecType mean("1.0 3.0 0.0 2.5");
   MatType cov("3.0 0.0 1.0 4.0;"
@@ -695,7 +695,7 @@ TEMPLATE_TEST_CASE("GaussianDistributionTrainWithProbabilitiesTest",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 0.25 : 0.1;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 0.25 : 0.1;
 
   VecType mean = ("5.0");
   VecType cov = ("2.0");
@@ -739,8 +739,8 @@ TEMPLATE_TEST_CASE("GaussianDistributionWithProbabilties1Test",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol1 = (std::is_same<ElemType, float>::value) ? 1e-10 : 1e-17;
-  const ElemType tol2 = (std::is_same<ElemType, float>::value) ? 1e-2 : 1e-4;
+  const ElemType tol1 = (std::is_same_v<ElemType, float>) ? 1e-10 : 1e-17;
+  const ElemType tol2 = (std::is_same_v<ElemType, float>) ? 1e-2 : 1e-4;
 
   VecType mean = ("5.0");
   VecType cov  = ("4.0");
@@ -891,7 +891,7 @@ TEMPLATE_TEST_CASE("GammaDistributionTrainWithProbabilitiesTest",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 0.03 : 0.015;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 0.03 : 0.015;
 
   ElemType alphaReal = 5.4;
   ElemType betaReal = 6.7;
@@ -986,7 +986,7 @@ TEMPLATE_TEST_CASE("GammaDistributionTrainTwoDistProbabilities1Test",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 0.25 : 0.075;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 0.25 : 0.075;
 
   ElemType alphaReal = 5.4;
   ElemType betaReal = 6.7;
@@ -1275,7 +1275,7 @@ TEMPLATE_TEST_CASE("DiscreteDistributionTest", "[DistributionTest]",
   typedef typename arma::Col<ObsElemType> ObsVecType;
   typedef typename arma::Mat<ObsElemType> ObsMatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 1e-4 : 1e-8;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 1e-4 : 1e-8;
 
   // I assume that I am properly saving vectors, so, this should be
   // straightforward.
@@ -1600,7 +1600,7 @@ TEMPLATE_TEST_CASE("DiagonalGaussianUnivariateProbabilityTest",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 1e-4 : 1e-7;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 1e-4 : 1e-7;
 
   DiagonalGaussianDistribution<MatType> d(VecType("0.0"), VecType("1.0"));
 
@@ -1640,7 +1640,7 @@ TEMPLATE_TEST_CASE("DiagonalGaussianMultivariateProbabilityTest",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 1e-4 : 1e-7;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 1e-4 : 1e-7;
 
   VecType mean("0 0");
   VecType cov("2 2");
@@ -1706,7 +1706,7 @@ TEMPLATE_TEST_CASE("DiagonalGaussianDistributionRandomTest",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 0.2 : 0.1;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 0.2 : 0.1;
 
   VecType mean("2.5 1.25");
   VecType cov("0.50 0.25");
@@ -1739,7 +1739,7 @@ TEMPLATE_TEST_CASE("DiagonalGaussianDistributionTrainTest",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 1e-3 : 1e-5;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 1e-3 : 1e-5;
 
   VecType mean("2.5 1.5 8.2 3.1");
   VecType cov("1.2 3.1 8.3 4.3");
@@ -1778,7 +1778,7 @@ TEMPLATE_TEST_CASE("DiagonalGaussianUnbiasedEstimatorTest",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 1e-4 : 1e-7;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 1e-4 : 1e-7;
 
   // Generate the observations.
   MatType observations("3 5 2 7;"
@@ -1816,7 +1816,7 @@ TEMPLATE_TEST_CASE("DiagonalGaussianWeightedParametersReductionTest",
   typedef typename arma::Col<ElemType> VecType;
   typedef typename arma::Mat<ElemType> MatType;
 
-  const ElemType tol = (std::is_same<ElemType, float>::value) ? 1e-4 : 1e-7;
+  const ElemType tol = (std::is_same_v<ElemType, float>) ? 1e-4 : 1e-7;
 
   VecType mean("2.5 1.5 8.2 3.1");
   VecType cov("1.2 3.1 8.3 4.3");
diff --git a/src/mlpack/tests/lars_test.cpp b/src/mlpack/tests/lars_test.cpp
index 196e6c23c7..c143fbd426 100644
--- a/src/mlpack/tests/lars_test.cpp
+++ b/src/mlpack/tests/lars_test.cpp
@@ -35,7 +35,7 @@ void LARSVerifyCorrectness(const VecType& beta,
   size_t nDims = beta.n_elem;
 
   // floats require a much larger tolerance.
-  const ElemType tol = (std::is_same<ElemType, double>::value) ? 1e-8 : 5e-3;
+  const ElemType tol = (std::is_same_v<ElemType, double>) ? 1e-8 : 5e-3;
 
   for (size_t j = 0; j < nDims; ++j)
   {
@@ -1226,7 +1226,7 @@ TEMPLATE_TEST_CASE("LARSSelectBetaTest", "[LARSTest]", arma::fmat, arma::mat)
   typedef TestType MatType;
   typedef typename MatType::elem_type ElemType;
 
-  const ElemType tol = (std::is_same<ElemType, double>::value) ? 1e-5 : 5e-3;
+  const ElemType tol = (std::is_same_v<ElemType, double>) ? 1e-5 : 5e-3;
 
   // Train a model on a randomly generated problem.  Then, we will iterate
   // through different selected lambda values, ensuring that the error on the
@@ -1244,7 +1244,7 @@ TEMPLATE_TEST_CASE("LARSSelectBetaTest", "[LARSTest]", arma::fmat, arma::mat)
 
   // Now step through numerous different lambda values.
   ElemType lastError = std::numeric_limits<ElemType>::max();
-  const ElemType errorTol = (std::is_same<ElemType, double>::value) ? 1e-8 :
+  const ElemType errorTol = (std::is_same_v<ElemType, double>) ? 1e-8 :
       0.05;
   for (ElemType i = 5.0; i >= -5.0; i -= 0.1)
   {
diff --git a/src/mlpack/tests/lmnn_test.cpp b/src/mlpack/tests/lmnn_test.cpp
index 394474511b..5192483972 100644
--- a/src/mlpack/tests/lmnn_test.cpp
+++ b/src/mlpack/tests/lmnn_test.cpp
@@ -116,8 +116,8 @@ TEMPLATE_TEST_CASE("LMNNInitialPointTest", "[LMNNTest]", float, double)
   LMNNFunction<arma::Mat<ElemType>> lmnnfn(dataset, labels, 1, 0.5, 1);
 
   // Verify the initial point is the identity matrix.
-  const double eps = std::is_same<ElemType, float>::value ? 1e-4 : 1e-7;
-  const double margin = std::is_same<ElemType, float>::value ? 1e-4 : 1e-5;
+  const double eps = std::is_same_v<ElemType, float> ? 1e-4 : 1e-7;
+  const double margin = std::is_same_v<ElemType, float> ? 1e-4 : 1e-5;
   arma::Mat<ElemType> initialPoint = lmnnfn.GetInitialPoint();
   for (int row = 0; row < 5; row++)
   {
@@ -148,7 +148,7 @@ TEMPLATE_TEST_CASE("LMNNInitialEvaluationTest", "[LMNNTest]", float, double)
   ElemType objective = lmnnfn.Evaluate(arma::eye<arma::Mat<ElemType>>(2, 2));
 
   // Result calculated by hand.
-  const double eps = std::is_same<ElemType, float>::value ? 1e-4 : 1e-7;
+  const double eps = std::is_same_v<ElemType, float> ? 1e-4 : 1e-7;
   REQUIRE(objective == Approx(9.456).epsilon(eps));
 }
 
@@ -171,8 +171,8 @@ TEMPLATE_TEST_CASE("LMNNInitialGradientTest", "[LMNNTest]", float, double)
   lmnnfn.Gradient(coordinates, gradient);
 
   // Result calculated by hand.
-  const double eps = std::is_same<ElemType, float>::value ? 1e-4 : 1e-7;
-  const double margin = std::is_same<ElemType, float>::value ? 1e-4 : 1e-5;
+  const double eps = std::is_same_v<ElemType, float> ? 1e-4 : 1e-7;
+  const double margin = std::is_same_v<ElemType, float> ? 1e-4 : 1e-5;
   REQUIRE(gradient(0, 0) == Approx(-0.288).epsilon(eps));
   REQUIRE(gradient(1, 0) == Approx(0.0).margin(margin));
   REQUIRE(gradient(0, 1) == Approx(0.0).margin(margin));
@@ -198,8 +198,8 @@ TEMPLATE_TEST_CASE("LMNNInitialEvaluateWithGradientTest", "[LMNNTest]", float,
   arma::Mat<ElemType> coordinates = arma::eye<arma::Mat<ElemType>>(2, 2);
   ElemType objective = lmnnfn.EvaluateWithGradient(coordinates, gradient);
 
-  const double eps = std::is_same<ElemType, float>::value ? 1e-4 : 1e-7;
-  const double margin = std::is_same<ElemType, float>::value ? 1e-4 : 1e-5;
+  const double eps = std::is_same_v<ElemType, float> ? 1e-4 : 1e-7;
+  const double margin = std::is_same_v<ElemType, float> ? 1e-4 : 1e-5;
 
   // Result calculated by hand.
   REQUIRE(objective == Approx(9.456).epsilon(eps));
@@ -225,7 +225,7 @@ TEMPLATE_TEST_CASE("LMNNSeparableObjectiveTest", "[LMNNTest]", float, double)
   LMNNFunction<arma::Mat<ElemType>> lmnnfn(dataset, labels, 1, 0.6, 1);
 
   // Result calculated by hand.
-  const double eps = std::is_same<ElemType, float>::value ? 1e-4 : 1e-7;
+  const double eps = std::is_same_v<ElemType, float> ? 1e-4 : 1e-7;
   arma::Mat<ElemType> coordinates = arma::eye<arma::Mat<ElemType>>(2, 2);
   REQUIRE(lmnnfn.Evaluate(coordinates, 0, 1) == Approx(1.576).epsilon(eps));
   REQUIRE(lmnnfn.Evaluate(coordinates, 1, 1) == Approx(1.576).epsilon(eps));
@@ -254,8 +254,8 @@ TEMPLATE_TEST_CASE("LMNNSeparableGradientTest", "[LMNNTest]", float, double)
 
   lmnnfn.Gradient(coordinates, 0, gradient, 1);
 
-  const double eps = std::is_same<ElemType, float>::value ? 1e-4 : 1e-7;
-  const double margin = std::is_same<ElemType, float>::value ? 1e-4 : 1e-5;
+  const double eps = std::is_same_v<ElemType, float> ? 1e-4 : 1e-7;
+  const double margin = std::is_same_v<ElemType, float> ? 1e-4 : 1e-5;
 
   REQUIRE(gradient(0, 0) == Approx(-0.048).epsilon(eps));
   REQUIRE(gradient(0, 1) == Approx(0.0).margin(margin));
@@ -318,8 +318,8 @@ TEMPLATE_TEST_CASE("LMNNSeparableEvaluateWithGradientTest", "[LMNNTest]", float,
 
   ElemType objective = lmnnfn.EvaluateWithGradient(coordinates, 0, gradient, 1);
 
-  const double eps = std::is_same<ElemType, float>::value ? 1e-4 : 1e-7;
-  const double margin = std::is_same<ElemType, float>::value ? 1e-4 : 1e-5;
+  const double eps = std::is_same_v<ElemType, float> ? 1e-4 : 1e-7;
+  const double margin = std::is_same_v<ElemType, float> ? 1e-4 : 1e-5;
 
   REQUIRE(objective == Approx(1.576).epsilon(eps));
 
diff --git a/src/mlpack/tests/main_tests/main_test_fixture.hpp b/src/mlpack/tests/main_tests/main_test_fixture.hpp
index 44ba2642e2..5c9cf94bac 100644
--- a/src/mlpack/tests/main_tests/main_test_fixture.hpp
+++ b/src/mlpack/tests/main_tests/main_test_fixture.hpp
@@ -106,7 +106,7 @@ class MainTestFixture
   template<typename T>
   void SetInputParam(const std::string& name, T&& value)
   {
-    params.Get<typename std::remove_reference<T>::type>(name) =
+    params.Get<std::remove_reference_t<T>>(name) =
         std::forward<T>(value);
     params.SetPassed(name);
   }
diff --git a/src/mlpack/tests/nca_test.cpp b/src/mlpack/tests/nca_test.cpp
index f618363404..09024d67ec 100644
--- a/src/mlpack/tests/nca_test.cpp
+++ b/src/mlpack/tests/nca_test.cpp
@@ -41,8 +41,8 @@ TEMPLATE_TEST_CASE("SoftmaxInitialPoint", "[NCATest]", float, double)
 
   // Verify the initial point is the identity matrix.
   arma::Mat<eT> initialPoint = sef.GetInitialPoint();
-  const double eps = std::is_same<eT, float>::value ? 1e-4 : 1e-7;
-  const double margin = std::is_same<eT, float>::value ? 1e-4 : 1e-5;
+  const double eps = std::is_same_v<eT, float> ? 1e-4 : 1e-7;
+  const double margin = std::is_same_v<eT, float> ? 1e-4 : 1e-5;
   for (int row = 0; row < 5; row++)
   {
     for (int col = 0; col < 5; col++)
@@ -131,7 +131,7 @@ TEMPLATE_TEST_CASE("SoftmaxOptimalEvaluation", "[NCATest]", float, double)
 
   // Use a very close tolerance for optimality; we need to be sure this function
   // gives optimal results correctly.
-  const double eps = std::is_same<eT, float>::value ? 1e-6 : 1e-12;
+  const double eps = std::is_same_v<eT, float> ? 1e-6 : 1e-12;
   REQUIRE(objective == Approx(-4.0).epsilon(eps));
 }
 
diff --git a/src/mlpack/tests/pca_test.cpp b/src/mlpack/tests/pca_test.cpp
index 4957280df4..2878913e2c 100644
--- a/src/mlpack/tests/pca_test.cpp
+++ b/src/mlpack/tests/pca_test.cpp
@@ -361,7 +361,7 @@ TEMPLATE_TEST_CASE("PCASubviewTest", "[PCATest]", ExactSVDPolicy,
   p.Apply(data.cols(0, 1999), transData3, eigval2, eigvec);
 
   // Only check for deterministic policies.
-  if (std::is_same<DecompositionPolicy, ExactSVDPolicy>::value)
+  if (std::is_same_v<DecompositionPolicy, ExactSVDPolicy>)
   {
     arma::mat trueTransData, trueEigvec;
     arma::vec trueEigval;
@@ -408,7 +408,7 @@ TEMPLATE_TEST_CASE("PCAExpressionTest", "[PCATest]", ExactSVDPolicy,
   p.Apply(2 * data + 1, transData3, eigval2, eigvec);
 
   // Only check for deterministic policies.
-  if (std::is_same<DecompositionPolicy, ExactSVDPolicy>::value)
+  if (std::is_same_v<DecompositionPolicy, ExactSVDPolicy>)
   {
     arma::mat trueTransData, trueEigvec;
     arma::vec trueEigval;
@@ -456,7 +456,7 @@ TEMPLATE_TEST_CASE("PCAFloatTest", "[PCATest]", ExactSVDPolicy,
 
   // Verify the PCA results based on the eigenvalues.  We don't check for
   // QUIC-SVD, since that method has a lot of noise.
-  if (!std::is_same<DecompositionPolicy, QUICSVDPolicy>::value)
+  if (!std::is_same_v<DecompositionPolicy, QUICSVDPolicy>)
   {
     for (size_t i = 0; i < eigVal.n_elem; ++i)
     {
diff --git a/src/mlpack/tests/sparse_coding_test.cpp b/src/mlpack/tests/sparse_coding_test.cpp
index fa22dbc9cc..0a732cf2a5 100644
--- a/src/mlpack/tests/sparse_coding_test.cpp
+++ b/src/mlpack/tests/sparse_coding_test.cpp
@@ -23,7 +23,7 @@ void SCVerifyCorrectness(const VecType& beta,
                          const VecType& errCorr,
                          double lambda)
 {
-  const double tol = std::is_same<typename VecType::elem_type, float>::value ?
+  const double tol = std::is_same_v<typename VecType::elem_type, float> ?
       1e-6 : 1e-12;
   size_t nDims = beta.n_elem;
   for (size_t j = 0; j < nDims; ++j)
@@ -122,7 +122,7 @@ TEMPLATE_TEST_CASE("SparseCodingTestDictionaryStep", "[SparseCodingTest]",
 {
   typedef TestType MatType;
 
-  const double tol = std::is_same<typename MatType::elem_type, float>::value ?
+  const double tol = std::is_same_v<typename MatType::elem_type, float> ?
       0.01 : 1e-6;
 
   double lambda1 = 0.1;
@@ -215,7 +215,7 @@ TEMPLATE_TEST_CASE("SparseCodingTrainReturnObjective", "[SparseCodingTest]",
 {
   typedef TestType MatType;
 
-  const double tol = std::is_same<typename MatType::elem_type, float>::value ?
+  const double tol = std::is_same_v<typename MatType::elem_type, float> ?
       0.01 : 1e-6;
 
   double lambda1 = 0.1;
diff --git a/src/mlpack/tests/test_catch_tools.hpp b/src/mlpack/tests/test_catch_tools.hpp
index 288cd26075..1377b7359a 100644
--- a/src/mlpack/tests/test_catch_tools.hpp
+++ b/src/mlpack/tests/test_catch_tools.hpp
@@ -23,8 +23,8 @@
 
 // Simple wrapper class to prevent copies of Armadillo matrices.
 template <typename MatType, typename ElemType = typename MatType::elem_type,
-          typename = std::enable_if_t<std::is_same<ElemType,
-              typename MatType::elem_type>::value>>
+          typename = std::enable_if_t<std::is_same_v<ElemType,
+              typename MatType::elem_type>>>
 class MatProxy
 {
  public:
@@ -54,9 +54,9 @@ class MatProxy<arma::Mat<ElemType>, ElemType>
 template <typename MatTypeA, typename MatTypeB,
     typename = std::enable_if_t<arma::is_arma_type<MatTypeA>::value
         && arma::is_arma_type<MatTypeB>::value
-        && std::is_same<typename MatTypeA::elem_type,
-                        typename MatTypeB::elem_type>::value
-        && !std::is_integral<typename MatTypeA::elem_type>::value>>
+        && std::is_same_v<typename MatTypeA::elem_type,
+                        typename MatTypeB::elem_type>
+        && !std::is_integral_v<typename MatTypeA::elem_type>>>
 inline void CheckMatrices(const MatTypeA& _a,
                           const MatTypeB& _b,
                           double tolerance = 1e-5)
@@ -103,8 +103,8 @@ inline void CheckFields(const FieldType& a,
 
 // Simple wrapper class to prevent copies of Armadillo cubes.
 template <typename CubeType, typename ElemType = typename CubeType::elem_type,
-    typename = std::enable_if_t<std::is_same<ElemType,
-        typename CubeType::elem_type>::value>>
+    typename = std::enable_if_t<std::is_same_v<ElemType,
+        typename CubeType::elem_type>>>
 class CubeProxy
 {
  public:
@@ -136,9 +136,9 @@ class CubeProxy<arma::Cube<ElemType>, ElemType>
 template <typename CubeTypeA, typename CubeTypeB,
     typename = std::enable_if_t<arma::is_arma_cube_type<CubeTypeA>::value
         && arma::is_arma_cube_type<CubeTypeB>::value
-        && std::is_same<typename CubeTypeA::elem_type,
-                        typename CubeTypeB::elem_type>::value
-        && !std::is_integral<typename CubeTypeA::elem_type>::value>,
+        && std::is_same_v<typename CubeTypeA::elem_type,
+                        typename CubeTypeB::elem_type>
+        && !std::is_integral_v<typename CubeTypeA::elem_type>>,
     typename = void>
 inline void CheckMatrices(const CubeTypeA& _a,
                           const CubeTypeB& _b,
diff --git a/src/mlpack/tests/ub_tree_test.cpp b/src/mlpack/tests/ub_tree_test.cpp
index fbd134535a..874c5bab18 100644
--- a/src/mlpack/tests/ub_tree_test.cpp
+++ b/src/mlpack/tests/ub_tree_test.cpp
@@ -44,9 +44,9 @@ template<typename TreeType>
 void CheckSplit(const TreeType& tree)
 {
   typedef typename TreeType::ElemType ElemType;
-  typedef typename std::conditional<sizeof(ElemType) * CHAR_BIT <= 32,
+  typedef std::conditional_t<sizeof(ElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>::type AddressElemType;
+                                    uint64_t>AddressElemType;
 
   if (tree.IsLeaf())
     return;

From 469cce1724a422b3bbbeacfd975c89c47a7b2a1b Mon Sep 17 00:00:00 2001
From: Martin Lambertsen <github@lambertsen.one>
Date: Mon, 14 Oct 2024 22:33:57 +0200
Subject: [PATCH 15/24] Remove trailing whitespaces

---
 src/mlpack/core/hpt/cv_function.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/mlpack/core/hpt/cv_function.hpp b/src/mlpack/core/hpt/cv_function.hpp
index 264b878d7d..90dd1da5c5 100644
--- a/src/mlpack/core/hpt/cv_function.hpp
+++ b/src/mlpack/core/hpt/cv_function.hpp
@@ -130,7 +130,7 @@ class CVFunction
   template<size_t BoundArgIndex,
            size_t ParamIndex,
            typename... Args,
-           typename = 
+           typename =
                std::enable_if_t<(BoundArgIndex + ParamIndex < TotalArgs)>>
   inline double Evaluate(const arma::mat& parameters, const Args&... args);
 
@@ -140,7 +140,7 @@ class CVFunction
   template<size_t BoundArgIndex,
            size_t ParamIndex,
            typename... Args,
-           typename = 
+           typename =
                std::enable_if_t<BoundArgIndex + ParamIndex == TotalArgs>,
            typename = void>
   inline double Evaluate(const arma::mat& parameters, const Args&... args);

From 395c63383cd08aeb21c96047beaff7937bb8976c Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 16 Oct 2024 12:33:00 -0400
Subject: [PATCH 16/24] Fix some minor links.

---
 doc/user/core/trees/binary_space_tree.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/user/core/trees/binary_space_tree.md b/doc/user/core/trees/binary_space_tree.md
index 7eab97e542..05313b16e9 100644
--- a/doc/user/core/trees/binary_space_tree.md
+++ b/doc/user/core/trees/binary_space_tree.md
@@ -842,8 +842,8 @@ Different constructor forms can be used to specify different template parameters
      any points at all).
 
 ***Note***: these constructors provide an empty bound; be sure to
-[grow](#growing-and-shrinking-the-bound) the bound or
-[directly modify the bound](#accessing-and-modifying-properties-of-the-bound)
+[grow](#growing-the-bound) the bound or
+[directly modify the bound](#accessing-and-modifying-properties-of-the-bound-1)
 before using it!
 
 ---
@@ -1122,7 +1122,7 @@ Different constructor forms can be used to specify different template parameters
    - `ElemType` should generally be `double` or `float`.
 
 ***Note***: these constructors provide an empty bound; be sure to
-[grow](#growing-and-shrinking-the-bound-2) the bound or
+[grow](#growing-the-bound-1) the bound or
 [directly modify the bound](#accessing-and-modifying-properties-of-the-bound-2)
 before using it!
 
@@ -1205,7 +1205,7 @@ be accessed and modified.
    `DistanceType` if a custom `DistanceType` has been specified in the
    constructor.
 
- * `b.Center(center)` will compute the center of the `HRectBound` (e.g. the
+ * `b.Center(center)` will compute the center of the `HollowBallBound` (e.g. the
    vector with elements equal to the midpoint of `b` in each dimension) and
    store it in the vector `center`.  `center` should be of type `arma::vec`.
 

From 05281d6e17f249906cfff1f41be47db877b4e7fc Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Wed, 16 Oct 2024 13:26:48 -0400
Subject: [PATCH 17/24] Fix paper link.

---
 doc/user/core/trees/binary_space_tree.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/user/core/trees/binary_space_tree.md b/doc/user/core/trees/binary_space_tree.md
index 05313b16e9..0d51f7cdf1 100644
--- a/doc/user/core/trees/binary_space_tree.md
+++ b/doc/user/core/trees/binary_space_tree.md
@@ -1679,7 +1679,8 @@ For implementation details, see
 
 The `VantagePointSplit` class is a splitting strategy that can be used by
 [`BinarySpaceTree`](#binaryspacetree).  It is the default strategy for splitting
-[`VPTree`s](vptree.md), and is detailed in [the paper](...).
+[`VPTree`s](vptree.md), and is detailed in
+[the paper](https://www.mlpack.org/paper/uhlmann91.pdf).
 Due to the nature of the split, ***`VantagePointSplit` should always be used
 with the [`HollowBallBound`](#hollowballbound)***.
 

From d24f019d1ac74f4ebf128eb05106f69e9660d7d6 Mon Sep 17 00:00:00 2001
From: Martin Lambertsen <github@lambertsen.one>
Date: Sat, 19 Oct 2024 10:42:42 +0200
Subject: [PATCH 18/24] Apply formatting

and some small manual fixes found by chance.
---
 src/mlpack/bindings/R/default_param.hpp       |  5 +-
 src/mlpack/bindings/R/default_param_impl.hpp  |  2 +-
 src/mlpack/bindings/R/get_printable_type.hpp  |  9 ++--
 .../bindings/R/get_printable_type_impl.hpp    |  9 ++--
 src/mlpack/bindings/R/get_r_type.hpp          |  9 ++--
 src/mlpack/bindings/R/get_type.hpp            |  9 ++--
 src/mlpack/bindings/cli/add_to_cli11.hpp      | 52 +++++++------------
 src/mlpack/bindings/cli/cli_option.hpp        |  3 +-
 src/mlpack/bindings/cli/default_param.hpp     |  8 ++-
 .../bindings/cli/default_param_impl.hpp       |  5 +-
 .../bindings/cli/get_allocated_memory.hpp     |  3 +-
 .../bindings/cli/get_printable_param.hpp      |  3 +-
 .../bindings/cli/get_printable_param_impl.hpp |  6 +--
 .../bindings/cli/get_printable_type.hpp       |  3 +-
 src/mlpack/bindings/cli/get_raw_param.hpp     |  2 +-
 src/mlpack/bindings/cli/in_place_copy.hpp     |  8 ++-
 .../bindings/cli/map_parameter_name.hpp       |  3 +-
 src/mlpack/bindings/cli/print_type_doc.hpp    |  3 +-
 src/mlpack/bindings/cli/set_param.hpp         |  3 +-
 src/mlpack/bindings/go/default_param.hpp      |  8 ++-
 src/mlpack/bindings/go/default_param_impl.hpp |  8 ++-
 src/mlpack/bindings/go/get_go_type.hpp        |  9 ++--
 .../bindings/go/get_printable_param.hpp       |  3 +-
 src/mlpack/bindings/go/get_printable_type.hpp | 12 ++---
 .../bindings/go/get_printable_type_impl.hpp   |  9 ++--
 src/mlpack/bindings/go/get_type.hpp           | 12 ++---
 src/mlpack/bindings/go/print_doc.hpp          |  3 +-
 .../bindings/go/print_input_processing.hpp    |  3 +-
 .../bindings/go/print_method_config.hpp       |  3 +-
 src/mlpack/bindings/go/print_method_init.hpp  |  3 +-
 src/mlpack/bindings/go/print_type_doc.hpp     |  3 +-
 src/mlpack/bindings/julia/default_param.hpp   |  8 ++-
 .../bindings/julia/default_param_impl.hpp     |  8 ++-
 src/mlpack/bindings/julia/get_julia_type.hpp  |  9 ++--
 .../bindings/julia/get_printable_param.hpp    |  3 +-
 .../bindings/julia/get_printable_type.hpp     |  3 +-
 .../bindings/julia/print_input_param.hpp      |  3 +-
 .../bindings/julia/print_input_processing.hpp |  3 +-
 .../julia/print_input_processing_impl.hpp     |  8 +--
 .../julia/print_output_processing.hpp         |  3 +-
 .../bindings/julia/print_param_defn.hpp       |  3 +-
 src/mlpack/bindings/julia/print_type_doc.hpp  |  3 +-
 .../bindings/markdown/get_printable_param.hpp |  3 +-
 src/mlpack/bindings/python/default_param.hpp  |  8 ++-
 .../bindings/python/default_param_impl.hpp    |  8 ++-
 .../bindings/python/get_cython_type.hpp       |  9 ++--
 .../bindings/python/get_printable_param.hpp   |  3 +-
 .../bindings/python/get_printable_type.hpp    | 12 ++---
 .../python/get_printable_type_impl.hpp        |  9 ++--
 .../bindings/python/is_serializable.hpp       |  3 +-
 src/mlpack/bindings/python/print_doc.hpp      |  3 +-
 .../python/print_input_processing.hpp         |  3 +-
 src/mlpack/bindings/python/print_type_doc.hpp |  3 +-
 .../bindings/tests/get_allocated_memory.hpp   |  3 +-
 .../bindings/tests/get_printable_param.hpp    |  3 +-
 src/mlpack/core/cereal/is_loading.hpp         |  6 +--
 src/mlpack/core/cv/cv_base.hpp                |  6 +--
 src/mlpack/core/data/string_encoding_impl.hpp | 12 ++---
 src/mlpack/core/hpt/hpt.hpp                   |  3 +-
 src/mlpack/core/tree/address.hpp              |  4 +-
 .../tree/binary_space_tree/ub_tree_split.hpp  |  2 +-
 src/mlpack/core/tree/build_tree.hpp           |  6 +--
 src/mlpack/core/tree/cellbound.hpp            |  2 +-
 .../rectangle_tree/discrete_hilbert_value.hpp |  2 +-
 src/mlpack/core/util/ens_traits.hpp           |  8 ++-
 .../core/util/first_element_is_arma.hpp       |  4 +-
 src/mlpack/core/util/sfinae_utility.hpp       |  9 ++--
 src/mlpack/core/util/size_checks.hpp          |  3 +-
 src/mlpack/methods/adaboost/adaboost.hpp      |  3 +-
 .../ann/convolution_rules/fft_convolution.hpp |  6 +--
 .../convolution_rules/naive_convolution.hpp   |  6 +--
 src/mlpack/methods/ann/ffn.hpp                |  6 +--
 src/mlpack/methods/ann/ffn_impl.hpp           |  6 +--
 .../methods/ann/not_adapted/gan/gan.hpp       | 21 +++-----
 .../methods/ann/not_adapted/gan/gan_impl.hpp  |  6 +--
 .../ann/not_adapted/gan/wgangp_impl.hpp       |  9 ++--
 .../methods/ann/not_adapted/rbm/rbm.hpp       |  3 +-
 .../bayesian_linear_regression.hpp            | 18 +++----
 .../decision_tree/decision_tree_impl.hpp      |  6 +--
 .../decision_tree_regressor_impl.hpp          | 22 +++-----
 src/mlpack/methods/det/dtree_impl.hpp         |  3 +-
 src/mlpack/methods/gmm/em_fit_impl.hpp        |  4 +-
 .../gmm/positive_definite_constraint.hpp      |  6 +--
 .../methods/kmeans/dual_tree_kmeans_impl.hpp  |  6 +--
 src/mlpack/methods/lars/lars.hpp              | 48 ++++++-----------
 .../linear_regression/linear_regression.hpp   | 24 +++------
 src/mlpack/methods/lmnn/lmnn.hpp              |  3 +-
 src/mlpack/methods/lsh/lsh_search_impl.hpp    |  3 +-
 .../naive_bayes_classifier_impl.hpp           |  4 +-
 src/mlpack/methods/nca/nca.hpp                | 11 ++--
 src/mlpack/methods/pca/pca_impl.hpp           |  6 +--
 .../methods/perceptron/perceptron_impl.hpp    |  6 +--
 .../softmax_regression/softmax_regression.hpp | 27 ++++------
 src/mlpack/tests/cv_test.cpp                  |  3 +-
 src/mlpack/tests/lars_test.cpp                |  3 +-
 .../tests/main_tests/main_test_fixture.hpp    |  3 +-
 src/mlpack/tests/test_catch_tools.hpp         |  4 +-
 src/mlpack/tests/ub_tree_test.cpp             |  6 +--
 98 files changed, 251 insertions(+), 443 deletions(-)

diff --git a/src/mlpack/bindings/R/default_param.hpp b/src/mlpack/bindings/R/default_param.hpp
index 1e05baf21e..be6fdbf57b 100644
--- a/src/mlpack/bindings/R/default_param.hpp
+++ b/src/mlpack/bindings/R/default_param.hpp
@@ -48,8 +48,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const std::enable_if_t<std::is_same_v<T, std::string>
-        >* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>>* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -62,7 +61,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* /* junk */ = 0);
+                                     arma::mat>>>* /* junk */ = 0);
 
 /**
  * Return the default value of a model option (this returns the default
diff --git a/src/mlpack/bindings/R/default_param_impl.hpp b/src/mlpack/bindings/R/default_param_impl.hpp
index a542cf7885..d210f1c6bd 100644
--- a/src/mlpack/bindings/R/default_param_impl.hpp
+++ b/src/mlpack/bindings/R/default_param_impl.hpp
@@ -117,7 +117,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* /* junk */)
+                                     arma::mat>>>* /* junk */)
 {
   // Get the filename and return it, or return an empty string.
   if (std::is_same_v<T, arma::rowvec> ||
diff --git a/src/mlpack/bindings/R/get_printable_type.hpp b/src/mlpack/bindings/R/get_printable_type.hpp
index 72e9d0c5cf..d04f06f025 100644
--- a/src/mlpack/bindings/R/get_printable_type.hpp
+++ b/src/mlpack/bindings/R/get_printable_type.hpp
@@ -50,12 +50,9 @@ inline std::string GetPrintableType<double>(
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<
         !std::is_same_v<std::string,
         std::tuple<data::DatasetInfo, arma::mat>>>*);
diff --git a/src/mlpack/bindings/R/get_printable_type_impl.hpp b/src/mlpack/bindings/R/get_printable_type_impl.hpp
index 0f388103c8..9b59da016d 100644
--- a/src/mlpack/bindings/R/get_printable_type_impl.hpp
+++ b/src/mlpack/bindings/R/get_printable_type_impl.hpp
@@ -58,12 +58,9 @@ inline std::string GetPrintableType<double>(
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<
         !std::is_same_v<std::string,
          std::tuple<data::DatasetInfo, arma::mat>>>*)
diff --git a/src/mlpack/bindings/R/get_r_type.hpp b/src/mlpack/bindings/R/get_r_type.hpp
index fe8c3dd7e8..fdc43beecc 100644
--- a/src/mlpack/bindings/R/get_r_type.hpp
+++ b/src/mlpack/bindings/R/get_r_type.hpp
@@ -83,12 +83,9 @@ inline std::string GetRType<double>(
 template<>
 inline std::string GetRType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<
         !std::is_same_v<std::string,
         std::tuple<data::DatasetInfo, arma::mat>>>*)
diff --git a/src/mlpack/bindings/R/get_type.hpp b/src/mlpack/bindings/R/get_type.hpp
index 1ef816f7bc..0b62a0cfdc 100644
--- a/src/mlpack/bindings/R/get_type.hpp
+++ b/src/mlpack/bindings/R/get_type.hpp
@@ -72,12 +72,9 @@ inline std::string GetType<double>(
 template<>
 inline std::string GetType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<!std::is_same_v<std::string,
         std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
diff --git a/src/mlpack/bindings/cli/add_to_cli11.hpp b/src/mlpack/bindings/cli/add_to_cli11.hpp
index 5bbb3eff9d..907eb1d3bc 100644
--- a/src/mlpack/bindings/cli/add_to_cli11.hpp
+++ b/src/mlpack/bindings/cli/add_to_cli11.hpp
@@ -33,15 +33,12 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const std::enable_if_t<!std::is_same_v<T,
-                    bool>>* = 0,
-                const std::enable_if_t<!
-                    arma::is_arma_type<T>::value>* = 0,
-                const std::enable_if_t<!
-                    data::HasSerialize<T>::value>* = 0,
+                const std::enable_if_t<!std::is_same_v<T, bool>>* = 0,
+                const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
                 const std::enable_if_t<std::is_same_v<T,
                     std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>>* = 0)
+                               arma::mat>>>* = 0)
 {
   app.add_option_function<std::string>(cliName.c_str(),
       [&param](const std::string& value)
@@ -65,15 +62,12 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const std::enable_if_t<!std::is_same_v<T,
-                    bool>>* = 0,
-                const std::enable_if_t<!
-                    arma::is_arma_type<T>::value>* = 0,
-                const std::enable_if_t<
-                    data::HasSerialize<T>::value>* = 0,
+                const std::enable_if_t<!std::is_same_v<T, bool>>* = 0,
+                const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<data::HasSerialize<T>::value>* = 0,
                 const std::enable_if_t<!std::is_same_v<T,
                     std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>>* = 0)
+                               arma::mat>>>* = 0)
 {
   app.add_option_function<std::string>(cliName.c_str(),
       [&param](const std::string& value)
@@ -97,13 +91,11 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const std::enable_if_t<!
-                    std::is_same_v<T, bool>>* = 0,
-                const std::enable_if_t<
-                    arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<!std::is_same_v<T, bool>>* = 0,
+                const std::enable_if_t<arma::is_arma_type<T>::value>* = 0,
                 const std::enable_if_t<!std::is_same_v<T,
                   std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>>* = 0)
+                             arma::mat>>>* = 0)
 {
   app.add_option_function<std::string>(cliName.c_str(),
       [&param](const std::string& value)
@@ -127,15 +119,12 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const std::enable_if_t<!
-                    std::is_same_v<T, bool>>* = 0,
-                const std::enable_if_t<!
-                    arma::is_arma_type<T>::value>* = 0,
-                const std::enable_if_t<!
-                    data::HasSerialize<T>::value>* = 0,
+                const std::enable_if_t<!std::is_same_v<T, bool>>* = 0,
+                const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
                 const std::enable_if_t<!std::is_same_v<T,
                     std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>>* = 0)
+                               arma::mat>>>* = 0)
 {
   app.add_option_function<T>(cliName.c_str(),
       [&param](const T& value)
@@ -157,15 +146,12 @@ template<typename T>
 void AddToCLI11(const std::string& cliName,
                 util::ParamData& param,
                 CLI::App& app,
-                const std::enable_if_t<
-                    std::is_same_v<T, bool>>* = 0,
-                const std::enable_if_t<!
-                    arma::is_arma_type<T>::value>* = 0,
-                const std::enable_if_t<!
-                    data::HasSerialize<T>::value>* = 0,
+                const std::enable_if_t<std::is_same_v<T, bool>>* = 0,
+                const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
+                const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
                 const std::enable_if_t<!std::is_same_v<T,
                     std::tuple<mlpack::data::DatasetInfo,
-                    arma::mat>>>* = 0)
+                               arma::mat>>>* = 0)
 {
   app.add_flag_function(cliName.c_str(),
       [&param](const T& value)
diff --git a/src/mlpack/bindings/cli/cli_option.hpp b/src/mlpack/bindings/cli/cli_option.hpp
index a1c1032be5..af9a83057f 100644
--- a/src/mlpack/bindings/cli/cli_option.hpp
+++ b/src/mlpack/bindings/cli/cli_option.hpp
@@ -92,8 +92,7 @@ class CLIOption
 
     // Apply default value.
     if (std::is_same_v<std::remove_pointer_t<N>,
-                     typename ParameterType<
-                         std::remove_pointer_t<N>>::type>)
+                       typename ParameterType<std::remove_pointer_t<N>>::type>)
     {
       data.value = defaultValue;
     }
diff --git a/src/mlpack/bindings/cli/default_param.hpp b/src/mlpack/bindings/cli/default_param.hpp
index 256afdbc51..7bdda5972b 100644
--- a/src/mlpack/bindings/cli/default_param.hpp
+++ b/src/mlpack/bindings/cli/default_param.hpp
@@ -29,8 +29,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
     const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
     const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
-    const std::enable_if_t<!std::is_same_v<T,
-        std::string>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T, std::string>>* = 0,
     const std::enable_if_t<!std::is_same_v<T,
         std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0);
 
@@ -48,8 +47,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const std::enable_if_t<std::is_same_v<T, std::string>
-        >* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>>* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -62,7 +60,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* /* junk */ = 0);
+                                     arma::mat>>>* /* junk */ = 0);
 
 /**
  * Return the default value of a model option (this returns the default
diff --git a/src/mlpack/bindings/cli/default_param_impl.hpp b/src/mlpack/bindings/cli/default_param_impl.hpp
index d7e0506d1e..cdefb16d22 100644
--- a/src/mlpack/bindings/cli/default_param_impl.hpp
+++ b/src/mlpack/bindings/cli/default_param_impl.hpp
@@ -27,8 +27,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<!arma::is_arma_type<T>::value>*,
     const std::enable_if_t<!util::IsStdVector<T>::value>*,
     const std::enable_if_t<!data::HasSerialize<T>::value>*,
-    const std::enable_if_t<!std::is_same_v<T,
-        std::string>>*,
+    const std::enable_if_t<!std::is_same_v<T, std::string>>*,
     const std::enable_if_t<!std::is_same_v<T,
         std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*)
 {
@@ -104,7 +103,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* /* junk */)
+                                     arma::mat>>>* /* junk */)
 {
   // The filename will always be empty.
   return "''";
diff --git a/src/mlpack/bindings/cli/get_allocated_memory.hpp b/src/mlpack/bindings/cli/get_allocated_memory.hpp
index 989dab1535..6cc4d2e94e 100644
--- a/src/mlpack/bindings/cli/get_allocated_memory.hpp
+++ b/src/mlpack/bindings/cli/get_allocated_memory.hpp
@@ -53,8 +53,7 @@ void GetAllocatedMemory(util::ParamData& d,
                         const void* /* input */,
                         void* output)
 {
-  *((void**) output) =
-      GetAllocatedMemory<std::remove_pointer_t<T>>(d);
+  *((void**) output) = GetAllocatedMemory<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/get_printable_param.hpp b/src/mlpack/bindings/cli/get_printable_param.hpp
index bffe499f37..c8c25f3a9f 100644
--- a/src/mlpack/bindings/cli/get_printable_param.hpp
+++ b/src/mlpack/bindings/cli/get_printable_param.hpp
@@ -47,8 +47,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const std::enable_if_t<arma::is_arma_type<T>::value ||
-                                  std::is_same_v<T,
+    const std::enable_if_t<arma::is_arma_type<T>::value || std::is_same_v<T,
         std::tuple<data::DatasetInfo, arma::mat>>>* = 0);
 
 /**
diff --git a/src/mlpack/bindings/cli/get_printable_param_impl.hpp b/src/mlpack/bindings/cli/get_printable_param_impl.hpp
index d9dadfecde..3bbd8989fc 100644
--- a/src/mlpack/bindings/cli/get_printable_param_impl.hpp
+++ b/src/mlpack/bindings/cli/get_printable_param_impl.hpp
@@ -38,8 +38,7 @@ std::string GetPrintableParam(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const std::enable_if_t<util::IsStdVector<T>::value>*
-        /* junk */)
+    const std::enable_if_t<util::IsStdVector<T>::value>* /* junk */)
 {
   const T& t = std::any_cast<T>(data.value);
 
@@ -74,8 +73,7 @@ std::string GetMatrixSize(
 template<typename T>
 std::string GetPrintableParam(
     util::ParamData& data,
-    const std::enable_if_t<arma::is_arma_type<T>::value ||
-                                  std::is_same_v<T,
+    const std::enable_if_t<arma::is_arma_type<T>::value || std::is_same_v<T,
         std::tuple<data::DatasetInfo, arma::mat>>>* /* junk */)
 {
   // Extract the string from the tuple that's being held.
diff --git a/src/mlpack/bindings/cli/get_printable_type.hpp b/src/mlpack/bindings/cli/get_printable_type.hpp
index 328e8f1055..1e6e127d2a 100644
--- a/src/mlpack/bindings/cli/get_printable_type.hpp
+++ b/src/mlpack/bindings/cli/get_printable_type.hpp
@@ -71,8 +71,7 @@ void GetPrintableType(util::ParamData& data,
                        const void* /* input */,
                        void* output)
 {
-  *((std::string*) output) =
-      GetPrintableType<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = GetPrintableType<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/get_raw_param.hpp b/src/mlpack/bindings/cli/get_raw_param.hpp
index acd2788e79..5464b01d72 100644
--- a/src/mlpack/bindings/cli/get_raw_param.hpp
+++ b/src/mlpack/bindings/cli/get_raw_param.hpp
@@ -45,7 +45,7 @@ T& GetRawParam(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* = 0)
+                                     arma::mat>>>* = 0)
 {
   // Don't load the matrix.
   typedef std::tuple<T, std::tuple<std::string, size_t, size_t>> TupleType;
diff --git a/src/mlpack/bindings/cli/in_place_copy.hpp b/src/mlpack/bindings/cli/in_place_copy.hpp
index 861e1e2729..2e8b2a5efc 100644
--- a/src/mlpack/bindings/cli/in_place_copy.hpp
+++ b/src/mlpack/bindings/cli/in_place_copy.hpp
@@ -52,9 +52,8 @@ void InPlaceCopyInternal(
     util::ParamData& input,
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same_v<T,
-                     std::tuple<mlpack::data::DatasetInfo, arma::mat>>
-                 >* = 0)
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*
+            = 0)
 {
   // Make the output filename the same as the input filename.
   typedef std::tuple<T, typename ParameterType<T>::type> TupleType;
@@ -76,8 +75,7 @@ template<typename T>
 void InPlaceCopyInternal(
     util::ParamData& d,
     util::ParamData& input,
-    const std::enable_if_t<
-        data::HasSerialize<T>::value>* = 0)
+    const std::enable_if_t<data::HasSerialize<T>::value>* = 0)
 {
   // Make the output filename the same as the input filename.
   typedef std::tuple<T*, typename ParameterType<T>::type> TupleType;
diff --git a/src/mlpack/bindings/cli/map_parameter_name.hpp b/src/mlpack/bindings/cli/map_parameter_name.hpp
index a4e9416b83..17235ed3a1 100644
--- a/src/mlpack/bindings/cli/map_parameter_name.hpp
+++ b/src/mlpack/bindings/cli/map_parameter_name.hpp
@@ -45,8 +45,7 @@ std::string MapParameterName(
     const std::string& identifier,
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
-        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>> ||
+        std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo, arma::mat>> ||
         data::HasSerialize<T>::value>* /* junk */ = 0)
 {
   return identifier + "_file";
diff --git a/src/mlpack/bindings/cli/print_type_doc.hpp b/src/mlpack/bindings/cli/print_type_doc.hpp
index 52b4e01f6e..630ebf7f9b 100644
--- a/src/mlpack/bindings/cli/print_type_doc.hpp
+++ b/src/mlpack/bindings/cli/print_type_doc.hpp
@@ -73,8 +73,7 @@ void PrintTypeDoc(util::ParamData& data,
                   const void* /* input */,
                   void* output)
 {
-  *((std::string*) output) =
-      PrintTypeDoc<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = PrintTypeDoc<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace cli
diff --git a/src/mlpack/bindings/cli/set_param.hpp b/src/mlpack/bindings/cli/set_param.hpp
index 6ff35afb80..73f493c660 100644
--- a/src/mlpack/bindings/cli/set_param.hpp
+++ b/src/mlpack/bindings/cli/set_param.hpp
@@ -58,8 +58,7 @@ template<typename T>
 void SetParam(
     util::ParamData& d,
     const std::any& value,
-    const std::enable_if_t<arma::is_arma_type<T>::value ||
-                                  std::is_same_v<T,
+    const std::enable_if_t<arma::is_arma_type<T>::value || std::is_same_v<T,
         std::tuple<data::DatasetInfo, arma::mat>>>* = 0)
 {
   // We're setting the string filename.
diff --git a/src/mlpack/bindings/go/default_param.hpp b/src/mlpack/bindings/go/default_param.hpp
index 9c749759f4..e67185d619 100644
--- a/src/mlpack/bindings/go/default_param.hpp
+++ b/src/mlpack/bindings/go/default_param.hpp
@@ -29,8 +29,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
     const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
     const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
-    const std::enable_if_t<!std::is_same_v<T,
-        std::string>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T, std::string>>* = 0,
     const std::enable_if_t<!std::is_same_v<T,
         std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0);
 
@@ -48,8 +47,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const std::enable_if_t<std::is_same_v<T, std::string>
-        >* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>>* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -62,7 +60,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* = 0);
+                                     arma::mat>>>* = 0);
 
 /**
  * Return the default value of a model option (this returns the default
diff --git a/src/mlpack/bindings/go/default_param_impl.hpp b/src/mlpack/bindings/go/default_param_impl.hpp
index a4abee84ea..6d78a5ef1c 100644
--- a/src/mlpack/bindings/go/default_param_impl.hpp
+++ b/src/mlpack/bindings/go/default_param_impl.hpp
@@ -27,8 +27,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<!arma::is_arma_type<T>::value>*,
     const std::enable_if_t<!util::IsStdVector<T>::value>*,
     const std::enable_if_t<!data::HasSerialize<T>::value>*,
-    const std::enable_if_t<!std::is_same_v<T,
-        std::string>>*,
+    const std::enable_if_t<!std::is_same_v<T, std::string>>*,
     const std::enable_if_t<!std::is_same_v<T,
         std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*)
 {
@@ -106,11 +105,10 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* /* junk */)
+                                     arma::mat>>>* /* junk */)
 {
   // Get the filename and return it, or return an empty string.
-  if (std::is_same_v<T, arma::rowvec> ||
-      std::is_same_v<T, arma::vec>)
+  if (std::is_same_v<T, arma::rowvec> || std::is_same_v<T, arma::vec>)
   {
     return "mat.NewDense(1, 1, nil)";
   }
diff --git a/src/mlpack/bindings/go/get_go_type.hpp b/src/mlpack/bindings/go/get_go_type.hpp
index b4db78e753..3790a0e0e2 100644
--- a/src/mlpack/bindings/go/get_go_type.hpp
+++ b/src/mlpack/bindings/go/get_go_type.hpp
@@ -73,12 +73,9 @@ inline std::string GetGoType<double>(
 template<>
 inline std::string GetGoType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<!std::is_same_v<std::string,
         std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
diff --git a/src/mlpack/bindings/go/get_printable_param.hpp b/src/mlpack/bindings/go/get_printable_param.hpp
index 057d5c24d6..01b94df15a 100644
--- a/src/mlpack/bindings/go/get_printable_param.hpp
+++ b/src/mlpack/bindings/go/get_printable_param.hpp
@@ -115,8 +115,7 @@ void GetPrintableParam(util::ParamData& data,
                        const void* /* input */,
                        void* output)
 {
-  *((std::string*) output) =
-      GetPrintableParam<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/get_printable_type.hpp b/src/mlpack/bindings/go/get_printable_type.hpp
index 6316b69e3a..e5db191fae 100644
--- a/src/mlpack/bindings/go/get_printable_type.hpp
+++ b/src/mlpack/bindings/go/get_printable_type.hpp
@@ -50,12 +50,9 @@ inline std::string GetPrintableType<double>(
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<!std::is_same_v<std::string,
         std::tuple<data::DatasetInfo, arma::mat>>>*);
 
@@ -101,8 +98,7 @@ void GetPrintableType(util::ParamData& d,
                       const void* /* input */,
                       void* output)
 {
-  *((std::string*) output) =
-      GetPrintableType<std::remove_pointer_t<T>>(d);
+  *((std::string*) output) = GetPrintableType<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/get_printable_type_impl.hpp b/src/mlpack/bindings/go/get_printable_type_impl.hpp
index 0c01ccbe83..1bde9d0a7a 100644
--- a/src/mlpack/bindings/go/get_printable_type_impl.hpp
+++ b/src/mlpack/bindings/go/get_printable_type_impl.hpp
@@ -59,12 +59,9 @@ inline std::string GetPrintableType<double>(
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<!std::is_same_v<std::string,
         std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
diff --git a/src/mlpack/bindings/go/get_type.hpp b/src/mlpack/bindings/go/get_type.hpp
index ac60755f31..1134ee6148 100644
--- a/src/mlpack/bindings/go/get_type.hpp
+++ b/src/mlpack/bindings/go/get_type.hpp
@@ -64,12 +64,9 @@ inline std::string GetType<double>(
 template<>
 inline std::string GetType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*)
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*)
 {
   return "String";
 }
@@ -144,8 +141,7 @@ void GetType(util::ParamData& d,
              const void* /* input */,
              void* output)
 {
-  *((std::string*) output) =
-      GetType<std::remove_pointer_t<T>>(d);
+  *((std::string*) output) = GetType<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/print_doc.hpp b/src/mlpack/bindings/go/print_doc.hpp
index 2ba21e0f5c..05f59cea0b 100644
--- a/src/mlpack/bindings/go/print_doc.hpp
+++ b/src/mlpack/bindings/go/print_doc.hpp
@@ -45,8 +45,7 @@ void PrintDoc(util::ParamData& d,
   std::ostringstream oss;
   oss << " - ";
   oss << util::CamelCase(d.name, Lower) << " (";
-  oss << GetGoType<std::remove_pointer_t<T>>(d) << "): "
-      << d.desc;
+  oss << GetGoType<std::remove_pointer_t<T>>(d) << "): " << d.desc;
 
   // Print a default, if possible.
   if (!d.required)
diff --git a/src/mlpack/bindings/go/print_input_processing.hpp b/src/mlpack/bindings/go/print_input_processing.hpp
index c64e5ed4e2..8bd00d1b18 100644
--- a/src/mlpack/bindings/go/print_input_processing.hpp
+++ b/src/mlpack/bindings/go/print_input_processing.hpp
@@ -340,8 +340,7 @@ void PrintInputProcessing(util::ParamData& d,
                           const void* input,
                           void* /* output */)
 {
-  PrintInputProcessing<std::remove_pointer_t<T>>(d,
-      *((size_t*) input));
+  PrintInputProcessing<std::remove_pointer_t<T>>(d, *((size_t*) input));
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/print_method_config.hpp b/src/mlpack/bindings/go/print_method_config.hpp
index 5d6d1d5fd6..2895101377 100644
--- a/src/mlpack/bindings/go/print_method_config.hpp
+++ b/src/mlpack/bindings/go/print_method_config.hpp
@@ -171,8 +171,7 @@ void PrintMethodConfig(util::ParamData& d,
                        const void* input,
                        void* /* output */)
 {
-  PrintMethodConfig<std::remove_pointer_t<T>>(d,
-      *((size_t*) input));
+  PrintMethodConfig<std::remove_pointer_t<T>>(d, *((size_t*) input));
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/print_method_init.hpp b/src/mlpack/bindings/go/print_method_init.hpp
index 6448874dee..e2fab09052 100644
--- a/src/mlpack/bindings/go/print_method_init.hpp
+++ b/src/mlpack/bindings/go/print_method_init.hpp
@@ -193,8 +193,7 @@ void PrintMethodInit(util::ParamData& d,
                      const void* input,
                      void* /* output */)
 {
-  PrintMethodInit<std::remove_pointer_t<T>>(d,
-      *((size_t*) input));
+  PrintMethodInit<std::remove_pointer_t<T>>(d, *((size_t*) input));
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/go/print_type_doc.hpp b/src/mlpack/bindings/go/print_type_doc.hpp
index f8550dc9e5..4815d15ab2 100644
--- a/src/mlpack/bindings/go/print_type_doc.hpp
+++ b/src/mlpack/bindings/go/print_type_doc.hpp
@@ -73,8 +73,7 @@ void PrintTypeDoc(util::ParamData& data,
                   const void* /* input */,
                   void* output)
 {
-  *((std::string*) output) =
-      PrintTypeDoc<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = PrintTypeDoc<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace go
diff --git a/src/mlpack/bindings/julia/default_param.hpp b/src/mlpack/bindings/julia/default_param.hpp
index d6a96c2237..dc0bb49c2f 100644
--- a/src/mlpack/bindings/julia/default_param.hpp
+++ b/src/mlpack/bindings/julia/default_param.hpp
@@ -29,8 +29,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
     const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
     const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
-    const std::enable_if_t<!std::is_same_v<T,
-        std::string>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T, std::string>>* = 0,
     const std::enable_if_t<!std::is_same_v<T,
         std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0);
 
@@ -48,8 +47,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const std::enable_if_t<std::is_same_v<T, std::string>
-        >* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>>* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -62,7 +60,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* = 0);
+                                     arma::mat>>>* = 0);
 
 /**
  * Return the default value of a model option (this returns the default
diff --git a/src/mlpack/bindings/julia/default_param_impl.hpp b/src/mlpack/bindings/julia/default_param_impl.hpp
index 9812a1990f..233a2073c8 100644
--- a/src/mlpack/bindings/julia/default_param_impl.hpp
+++ b/src/mlpack/bindings/julia/default_param_impl.hpp
@@ -27,8 +27,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<!arma::is_arma_type<T>::value>*,
     const std::enable_if_t<!util::IsStdVector<T>::value>*,
     const std::enable_if_t<!data::HasSerialize<T>::value>*,
-    const std::enable_if_t<!std::is_same_v<T,
-        std::string>>*,
+    const std::enable_if_t<!std::is_same_v<T, std::string>>*,
     const std::enable_if_t<!std::is_same_v<T,
         std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*)
 {
@@ -106,11 +105,10 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* /* junk */)
+                                     arma::mat>>>* /* junk */)
 {
   // Get the filename and return it, or return an empty string.
-  if (std::is_same_v<T, arma::rowvec> ||
-      std::is_same_v<T, arma::vec>)
+  if (std::is_same_v<T, arma::rowvec> || std::is_same_v<T, arma::vec>)
   {
     return "Float64[]";
   }
diff --git a/src/mlpack/bindings/julia/get_julia_type.hpp b/src/mlpack/bindings/julia/get_julia_type.hpp
index 464934d5e3..bf3ceae334 100644
--- a/src/mlpack/bindings/julia/get_julia_type.hpp
+++ b/src/mlpack/bindings/julia/get_julia_type.hpp
@@ -82,14 +82,11 @@ inline std::string GetJuliaType<double>(
 template<>
 inline std::string GetJuliaType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<!std::is_same_v<std::string,
         std::tuple<data::DatasetInfo, arma::mat>>>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*)
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*)
 {
   return "String";
 }
diff --git a/src/mlpack/bindings/julia/get_printable_param.hpp b/src/mlpack/bindings/julia/get_printable_param.hpp
index 25783d8910..d5d8743652 100644
--- a/src/mlpack/bindings/julia/get_printable_param.hpp
+++ b/src/mlpack/bindings/julia/get_printable_param.hpp
@@ -115,8 +115,7 @@ void GetPrintableParam(util::ParamData& data,
                        const void* /* input */,
                        void* output)
 {
-  *((std::string*) output) =
-      GetPrintableParam<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/get_printable_type.hpp b/src/mlpack/bindings/julia/get_printable_type.hpp
index 751928eacc..7a63863864 100644
--- a/src/mlpack/bindings/julia/get_printable_type.hpp
+++ b/src/mlpack/bindings/julia/get_printable_type.hpp
@@ -71,8 +71,7 @@ void GetPrintableType(util::ParamData& data,
                        const void* /* input */,
                        void* output)
 {
-  *((std::string*) output) =
-      GetPrintableType<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = GetPrintableType<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/print_input_param.hpp b/src/mlpack/bindings/julia/print_input_param.hpp
index e46d3bf42b..57baeef693 100644
--- a/src/mlpack/bindings/julia/print_input_param.hpp
+++ b/src/mlpack/bindings/julia/print_input_param.hpp
@@ -43,8 +43,7 @@ void PrintInputParam(util::ParamData& d,
     }
     else
     {
-      std::cout << "Union{"
-          << GetJuliaType<std::remove_pointer_t<T>>(d)
+      std::cout << "Union{" << GetJuliaType<std::remove_pointer_t<T>>(d)
           << ", Missing} = missing";
     }
   }
diff --git a/src/mlpack/bindings/julia/print_input_processing.hpp b/src/mlpack/bindings/julia/print_input_processing.hpp
index d6339c3016..1d1a1e8031 100644
--- a/src/mlpack/bindings/julia/print_input_processing.hpp
+++ b/src/mlpack/bindings/julia/print_input_processing.hpp
@@ -72,8 +72,7 @@ void PrintInputProcessing(util::ParamData& d,
                           void* /* output */)
 {
   // Call out to the right overload.
-  PrintInputProcessing<std::remove_pointer_t<T>>(d,
-      *((std::string*) input));
+  PrintInputProcessing<std::remove_pointer_t<T>>(d, *((std::string*) input));
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/print_input_processing_impl.hpp b/src/mlpack/bindings/julia/print_input_processing_impl.hpp
index e6078fb905..206cb69414 100644
--- a/src/mlpack/bindings/julia/print_input_processing_impl.hpp
+++ b/src/mlpack/bindings/julia/print_input_processing_impl.hpp
@@ -151,12 +151,12 @@ void PrintInputProcessing(
   std::string indent(extraIndent + 2, ' ');
   std::string type = util::StripType(d.cppType);
   std::cout << indent << "push!(modelPtrs, convert("
-      << GetJuliaType<std::remove_pointer_t<T>>(d) << ", "
-      << juliaName << ").ptr)" << std::endl;
+      << GetJuliaType<std::remove_pointer_t<T>>(d) << ", " << juliaName
+      << ").ptr)" << std::endl;
   std::cout << indent << functionName << "_internal.SetParam" << type
       << "(p, \"" << d.name << "\", convert("
-      << GetJuliaType<std::remove_pointer_t<T>>(d) << ", "
-      << juliaName << "))" << std::endl;
+      << GetJuliaType<std::remove_pointer_t<T>>(d) << ", " << juliaName
+      << "))" << std::endl;
 
   if (!d.required)
   {
diff --git a/src/mlpack/bindings/julia/print_output_processing.hpp b/src/mlpack/bindings/julia/print_output_processing.hpp
index c44184e8c2..7d94ee2b59 100644
--- a/src/mlpack/bindings/julia/print_output_processing.hpp
+++ b/src/mlpack/bindings/julia/print_output_processing.hpp
@@ -73,8 +73,7 @@ void PrintOutputProcessing(util::ParamData& d,
                            void* /* output */)
 {
   // Call out to the right overload.
-  PrintOutputProcessing<std::remove_pointer_t<T>>(d,
-      *((std::string*) input));
+  PrintOutputProcessing<std::remove_pointer_t<T>>(d, *((std::string*) input));
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/print_param_defn.hpp b/src/mlpack/bindings/julia/print_param_defn.hpp
index 7883a4d8ff..c5022875bf 100644
--- a/src/mlpack/bindings/julia/print_param_defn.hpp
+++ b/src/mlpack/bindings/julia/print_param_defn.hpp
@@ -171,8 +171,7 @@ void PrintParamDefn(util::ParamData& d,
                     const void* input,
                     void* /* output */)
 {
-  PrintParamDefn<std::remove_pointer_t<T>>(d,
-      *(std::string*) input);
+  PrintParamDefn<std::remove_pointer_t<T>>(d, *(std::string*) input);
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/julia/print_type_doc.hpp b/src/mlpack/bindings/julia/print_type_doc.hpp
index a007ac88d8..4acc30c144 100644
--- a/src/mlpack/bindings/julia/print_type_doc.hpp
+++ b/src/mlpack/bindings/julia/print_type_doc.hpp
@@ -73,8 +73,7 @@ void PrintTypeDoc(util::ParamData& data,
                   const void* /* input */,
                   void* output)
 {
-  *((std::string*) output) =
-      PrintTypeDoc<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = PrintTypeDoc<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace julia
diff --git a/src/mlpack/bindings/markdown/get_printable_param.hpp b/src/mlpack/bindings/markdown/get_printable_param.hpp
index f2d8d13d22..c3a971fb6f 100644
--- a/src/mlpack/bindings/markdown/get_printable_param.hpp
+++ b/src/mlpack/bindings/markdown/get_printable_param.hpp
@@ -115,8 +115,7 @@ void GetPrintableParam(util::ParamData& data,
                        const void* /* input */,
                        void* output)
 {
-  *((std::string*) output) =
-      GetPrintableParam<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace markdown
diff --git a/src/mlpack/bindings/python/default_param.hpp b/src/mlpack/bindings/python/default_param.hpp
index 2482ed0f75..9495949af5 100644
--- a/src/mlpack/bindings/python/default_param.hpp
+++ b/src/mlpack/bindings/python/default_param.hpp
@@ -29,8 +29,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<!arma::is_arma_type<T>::value>* = 0,
     const std::enable_if_t<!util::IsStdVector<T>::value>* = 0,
     const std::enable_if_t<!data::HasSerialize<T>::value>* = 0,
-    const std::enable_if_t<!std::is_same_v<T,
-        std::string>>* = 0,
+    const std::enable_if_t<!std::is_same_v<T, std::string>>* = 0,
     const std::enable_if_t<!std::is_same_v<T,
         std::tuple<mlpack::data::DatasetInfo, arma::mat>>>* = 0);
 
@@ -48,8 +47,7 @@ std::string DefaultParamImpl(
 template<typename T>
 std::string DefaultParamImpl(
     util::ParamData& data,
-    const std::enable_if_t<std::is_same_v<T, std::string>
-        >* = 0);
+    const std::enable_if_t<std::is_same_v<T, std::string>>* = 0);
 
 /**
  * Return the default value of a matrix option, a tuple option, a
@@ -62,7 +60,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* = 0);
+                                     arma::mat>>>* = 0);
 
 /**
  * Return the default value of a model option (this returns the default
diff --git a/src/mlpack/bindings/python/default_param_impl.hpp b/src/mlpack/bindings/python/default_param_impl.hpp
index 1153574181..e318febfc9 100644
--- a/src/mlpack/bindings/python/default_param_impl.hpp
+++ b/src/mlpack/bindings/python/default_param_impl.hpp
@@ -27,8 +27,7 @@ std::string DefaultParamImpl(
     const std::enable_if_t<!arma::is_arma_type<T>::value>*,
     const std::enable_if_t<!util::IsStdVector<T>::value>*,
     const std::enable_if_t<!data::HasSerialize<T>::value>*,
-    const std::enable_if_t<!std::is_same_v<T,
-        std::string>>*,
+    const std::enable_if_t<!std::is_same_v<T, std::string>>*,
     const std::enable_if_t<!std::is_same_v<T,
         std::tuple<mlpack::data::DatasetInfo, arma::mat>>>*)
 {
@@ -106,11 +105,10 @@ std::string DefaultParamImpl(
     const std::enable_if_t<
         arma::is_arma_type<T>::value ||
         std::is_same_v<T, std::tuple<mlpack::data::DatasetInfo,
-                                   arma::mat>>>* /* junk */)
+                                     arma::mat>>>* /* junk */)
 {
   // Get the filename and return it, or return an empty string.
-  if (std::is_same_v<T, arma::rowvec> ||
-      std::is_same_v<T, arma::vec>)
+  if (std::is_same_v<T, arma::rowvec> || std::is_same_v<T, arma::vec>)
   {
     return "np.empty([0])";
   }
diff --git a/src/mlpack/bindings/python/get_cython_type.hpp b/src/mlpack/bindings/python/get_cython_type.hpp
index a1b12abcda..5d1b48ad50 100644
--- a/src/mlpack/bindings/python/get_cython_type.hpp
+++ b/src/mlpack/bindings/python/get_cython_type.hpp
@@ -53,12 +53,9 @@ inline std::string GetCythonType<double>(
 template<>
 inline std::string GetCythonType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*)
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*)
 {
   return "string";
 }
diff --git a/src/mlpack/bindings/python/get_printable_param.hpp b/src/mlpack/bindings/python/get_printable_param.hpp
index db87a6ae72..3e205760fb 100644
--- a/src/mlpack/bindings/python/get_printable_param.hpp
+++ b/src/mlpack/bindings/python/get_printable_param.hpp
@@ -115,8 +115,7 @@ void GetPrintableParam(util::ParamData& data,
                        const void* /* input */,
                        void* output)
 {
-  *((std::string*) output) =
-      GetPrintableParam<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/get_printable_type.hpp b/src/mlpack/bindings/python/get_printable_type.hpp
index 741dd68061..8d55a30b92 100644
--- a/src/mlpack/bindings/python/get_printable_type.hpp
+++ b/src/mlpack/bindings/python/get_printable_type.hpp
@@ -50,12 +50,9 @@ inline std::string GetPrintableType<double>(
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<!std::is_same_v<std::string,
         std::tuple<data::DatasetInfo, arma::mat>>>*);
 
@@ -110,8 +107,7 @@ void GetPrintableType(util::ParamData& d,
                       const void* /* input */,
                       void* output)
 {
-  *((std::string*) output) =
-      GetPrintableType<std::remove_pointer_t<T>>(d);
+  *((std::string*) output) = GetPrintableType<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/get_printable_type_impl.hpp b/src/mlpack/bindings/python/get_printable_type_impl.hpp
index fab3255956..cd8851da38 100644
--- a/src/mlpack/bindings/python/get_printable_type_impl.hpp
+++ b/src/mlpack/bindings/python/get_printable_type_impl.hpp
@@ -58,12 +58,9 @@ inline std::string GetPrintableType<double>(
 template<>
 inline std::string GetPrintableType<std::string>(
     util::ParamData& /* d */,
-    const std::enable_if_t<
-        !util::IsStdVector<std::string>::value>*,
-    const std::enable_if_t<
-        !data::HasSerialize<std::string>::value>*,
-    const std::enable_if_t<
-        !arma::is_arma_type<std::string>::value>*,
+    const std::enable_if_t<!util::IsStdVector<std::string>::value>*,
+    const std::enable_if_t<!data::HasSerialize<std::string>::value>*,
+    const std::enable_if_t<!arma::is_arma_type<std::string>::value>*,
     const std::enable_if_t<!std::is_same_v<std::string,
         std::tuple<data::DatasetInfo, arma::mat>>>*)
 {
diff --git a/src/mlpack/bindings/python/is_serializable.hpp b/src/mlpack/bindings/python/is_serializable.hpp
index 0c326dd81c..6c014593fc 100644
--- a/src/mlpack/bindings/python/is_serializable.hpp
+++ b/src/mlpack/bindings/python/is_serializable.hpp
@@ -39,8 +39,7 @@ void IsSerializable(util::ParamData& data,
                     const void* /* input */,
                     void* output)
 {
-  *((bool*) output) =
-      IsSerializable<std::remove_pointer_t<T>>(data);
+  *((bool*) output) = IsSerializable<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/print_doc.hpp b/src/mlpack/bindings/python/print_doc.hpp
index d9410c3a44..dfb49fa136 100644
--- a/src/mlpack/bindings/python/print_doc.hpp
+++ b/src/mlpack/bindings/python/print_doc.hpp
@@ -42,8 +42,7 @@ void PrintDoc(util::ParamData& d,
   oss << " - ";
   oss << GetValidName(d.name);
   oss << " (";
-  oss << GetPrintableType<std::remove_pointer_t<T>>(d) << "): "
-      << d.desc;
+  oss << GetPrintableType<std::remove_pointer_t<T>>(d) << "): " << d.desc;
 
   // Print a default, if possible.
   if (!d.required)
diff --git a/src/mlpack/bindings/python/print_input_processing.hpp b/src/mlpack/bindings/python/print_input_processing.hpp
index e20a28503d..f7a7ab98a8 100644
--- a/src/mlpack/bindings/python/print_input_processing.hpp
+++ b/src/mlpack/bindings/python/print_input_processing.hpp
@@ -550,8 +550,7 @@ void PrintInputProcessing(util::ParamData& d,
                           const void* input,
                           void* /* output */)
 {
-  PrintInputProcessing<std::remove_pointer_t<T>>(d,
-      *((size_t*) input));
+  PrintInputProcessing<std::remove_pointer_t<T>>(d, *((size_t*) input));
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/python/print_type_doc.hpp b/src/mlpack/bindings/python/print_type_doc.hpp
index 2f4b906b8c..e7981d89f9 100644
--- a/src/mlpack/bindings/python/print_type_doc.hpp
+++ b/src/mlpack/bindings/python/print_type_doc.hpp
@@ -73,8 +73,7 @@ void PrintTypeDoc(util::ParamData& data,
                   const void* /* input */,
                   void* output)
 {
-  *((std::string*) output) =
-      PrintTypeDoc<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = PrintTypeDoc<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace python
diff --git a/src/mlpack/bindings/tests/get_allocated_memory.hpp b/src/mlpack/bindings/tests/get_allocated_memory.hpp
index dccf4f2a6c..903b17420f 100644
--- a/src/mlpack/bindings/tests/get_allocated_memory.hpp
+++ b/src/mlpack/bindings/tests/get_allocated_memory.hpp
@@ -51,8 +51,7 @@ void GetAllocatedMemory(util::ParamData& d,
                         const void* /* input */,
                         void* output)
 {
-  *((void**) output) =
-      GetAllocatedMemory<std::remove_pointer_t<T>>(d);
+  *((void**) output) = GetAllocatedMemory<std::remove_pointer_t<T>>(d);
 }
 
 } // namespace tests
diff --git a/src/mlpack/bindings/tests/get_printable_param.hpp b/src/mlpack/bindings/tests/get_printable_param.hpp
index c7f12cd08f..bb72dd93a2 100644
--- a/src/mlpack/bindings/tests/get_printable_param.hpp
+++ b/src/mlpack/bindings/tests/get_printable_param.hpp
@@ -77,8 +77,7 @@ void GetPrintableParam(util::ParamData& data,
                        const void* /* input */,
                        void* output)
 {
-  *((std::string*) output) =
-      GetPrintableParam<std::remove_pointer_t<T>>(data);
+  *((std::string*) output) = GetPrintableParam<std::remove_pointer_t<T>>(data);
 }
 
 } // namespace tests
diff --git a/src/mlpack/core/cereal/is_loading.hpp b/src/mlpack/core/cereal/is_loading.hpp
index 3be9d12426..f6346abfce 100644
--- a/src/mlpack/core/cereal/is_loading.hpp
+++ b/src/mlpack/core/cereal/is_loading.hpp
@@ -38,16 +38,14 @@ struct is_cereal_archive
 
 template<typename Archive>
 bool is_loading(
-    const std::enable_if_t<
-        is_cereal_archive<Archive>::value, Archive>* = 0)
+    const std::enable_if_t<is_cereal_archive<Archive>::value, Archive>* = 0)
 {
   return true;
 }
 
 template<typename Archive>
 bool is_loading(
-    const std::enable_if_t<
-      !is_cereal_archive<Archive>::value, Archive>* = 0)
+    const std::enable_if_t<!is_cereal_archive<Archive>::value, Archive>* = 0)
 {
   return false;
 }
diff --git a/src/mlpack/core/cv/cv_base.hpp b/src/mlpack/core/cv/cv_base.hpp
index 832f65a694..1ca40368ff 100644
--- a/src/mlpack/core/cv/cv_base.hpp
+++ b/src/mlpack/core/cv/cv_base.hpp
@@ -206,8 +206,7 @@ class CVBase
    */
   template<bool ConstructableWithoutDatasetInfo,
            typename... MLAlgorithmArgs,
-           typename =
-               std::enable_if_t<ConstructableWithoutDatasetInfo>>
+           typename = std::enable_if_t<ConstructableWithoutDatasetInfo>>
   MLAlgorithm TrainModel(const MatType& xs,
                          const PredictionsType& ys,
                          const MLAlgorithmArgs&... args);
@@ -218,8 +217,7 @@ class CVBase
    */
   template<bool ConstructableWithoutDatasetInfo,
            typename... MLAlgorithmArgs,
-           typename =
-               std::enable_if_t<!ConstructableWithoutDatasetInfo>,
+           typename = std::enable_if_t<!ConstructableWithoutDatasetInfo>,
            typename = void>
   MLAlgorithm TrainModel(const MatType& xs,
                          const PredictionsType& ys,
diff --git a/src/mlpack/core/data/string_encoding_impl.hpp b/src/mlpack/core/data/string_encoding_impl.hpp
index 2a0f091161..764fbae11a 100644
--- a/src/mlpack/core/data/string_encoding_impl.hpp
+++ b/src/mlpack/core/data/string_encoding_impl.hpp
@@ -71,8 +71,8 @@ void StringEncoding<EncodingPolicyType, DictionaryType>::CreateMap(
 
   static_assert(
       std::is_same_v<std::remove_reference_t<decltype(token)>,
-                   std::remove_reference_t<typename DictionaryType::
-                      TokenType>>,
+                     std::remove_reference_t<typename DictionaryType::
+                        TokenType>>,
       "The dictionary token type doesn't match the return value type "
       "of the tokenizer.");
 
@@ -117,8 +117,8 @@ EncodeHelper(const std::vector<std::string>& input,
 
     static_assert(
         std::is_same_v<std::remove_reference_t<decltype(token)>,
-                     std::remove_reference_t<typename DictionaryType::
-                        TokenType>>,
+                       std::remove_reference_t<typename DictionaryType::
+                          TokenType>>,
         "The dictionary token type doesn't match the return value type "
         "of the tokenizer.");
 
@@ -177,8 +177,8 @@ EncodeHelper(const std::vector<std::string>& input,
 
     static_assert(
         std::is_same_v<std::remove_reference_t<decltype(token)>,
-                     std::remove_reference_t<typename DictionaryType::
-                        TokenType>>,
+                       std::remove_reference_t<typename DictionaryType::
+                          TokenType>>,
         "The dictionary token type doesn't match the return value type "
         "of the tokenizer.");
 
diff --git a/src/mlpack/core/hpt/hpt.hpp b/src/mlpack/core/hpt/hpt.hpp
index 9f20b7deb7..fdfc237f9f 100644
--- a/src/mlpack/core/hpt/hpt.hpp
+++ b/src/mlpack/core/hpt/hpt.hpp
@@ -201,8 +201,7 @@ class HyperParameterTuner
   //! A short alias for the full type of the cross-validation.
   using CVType = std::conditional_t<Metric::NeedsMinimization,
       CV<MLAlgorithm, Metric, MatType, PredictionsType, WeightsType>,
-      CV<MLAlgorithm, Negated<Metric>, MatType, PredictionsType,
-          WeightsType>>;
+      CV<MLAlgorithm, Negated<Metric>, MatType, PredictionsType, WeightsType>>;
 
 
   //! The cross-validation object for assessing sets of hyper-parameters.
diff --git a/src/mlpack/core/tree/address.hpp b/src/mlpack/core/tree/address.hpp
index e999e01144..e2e4250887 100644
--- a/src/mlpack/core/tree/address.hpp
+++ b/src/mlpack/core/tree/address.hpp
@@ -58,7 +58,7 @@ void PointToAddress(AddressType& address, const VecType& point)
   // Check that the arguments are compatible.
   typedef std::conditional_t<sizeof(VecElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>AddressElemType;
+                                    uint64_t> AddressElemType;
 
   static_assert(std::is_same_v<typename AddressType::elem_type,
       AddressElemType> == true, "The vector element type does not "
@@ -154,7 +154,7 @@ void AddressToPoint(VecType& point, const AddressType& address)
   // Check that the arguments are compatible.
   typedef std::conditional_t<sizeof(VecElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>AddressElemType;
+                                    uint64_t> AddressElemType;
 
   static_assert(std::is_same_v<typename AddressType::elem_type,
       AddressElemType> == true, "The vector element type does not "
diff --git a/src/mlpack/core/tree/binary_space_tree/ub_tree_split.hpp b/src/mlpack/core/tree/binary_space_tree/ub_tree_split.hpp
index 59d8add197..79e2ba818d 100644
--- a/src/mlpack/core/tree/binary_space_tree/ub_tree_split.hpp
+++ b/src/mlpack/core/tree/binary_space_tree/ub_tree_split.hpp
@@ -32,7 +32,7 @@ class UBTreeSplit
   typedef std::conditional_t<
       sizeof(typename MatType::elem_type) * CHAR_BIT <= 32,
       uint32_t,
-      uint64_t>AddressElemType;
+      uint64_t> AddressElemType;
 
   //! An information about the partition.
   struct SplitInfo
diff --git a/src/mlpack/core/tree/build_tree.hpp b/src/mlpack/core/tree/build_tree.hpp
index 3042684fd3..dc2b2570db 100644
--- a/src/mlpack/core/tree/build_tree.hpp
+++ b/src/mlpack/core/tree/build_tree.hpp
@@ -21,8 +21,7 @@ template<typename TreeType, typename MatType>
 TreeType* BuildTree(
     MatType&& dataset,
     std::vector<size_t>& oldFromNew,
-    const std::enable_if_t<
-        TreeTraits<TreeType>::RearrangesDataset>* = 0)
+    const std::enable_if_t<TreeTraits<TreeType>::RearrangesDataset>* = 0)
 {
   return new TreeType(std::forward<MatType>(dataset), oldFromNew);
 }
@@ -32,8 +31,7 @@ template<typename TreeType, typename MatType>
 TreeType* BuildTree(
     MatType&& dataset,
     const std::vector<size_t>& /* oldFromNew */,
-    const std::enable_if_t<
-        !TreeTraits<TreeType>::RearrangesDataset>* = 0)
+    const std::enable_if_t<!TreeTraits<TreeType>::RearrangesDataset>* = 0)
 {
   return new TreeType(std::forward<MatType>(dataset));
 }
diff --git a/src/mlpack/core/tree/cellbound.hpp b/src/mlpack/core/tree/cellbound.hpp
index 3fb2bfbb09..21b31dbe9f 100644
--- a/src/mlpack/core/tree/cellbound.hpp
+++ b/src/mlpack/core/tree/cellbound.hpp
@@ -78,7 +78,7 @@ class CellBound
   //! uint32_t or uint64_t.
   typedef std::conditional_t<sizeof(ElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>AddressElemType;
+                                    uint64_t> AddressElemType;
 
   /**
    * Empty constructor; creates a bound of dimensionality 0.
diff --git a/src/mlpack/core/tree/rectangle_tree/discrete_hilbert_value.hpp b/src/mlpack/core/tree/rectangle_tree/discrete_hilbert_value.hpp
index 3ccd204a75..62c1329b5f 100644
--- a/src/mlpack/core/tree/rectangle_tree/discrete_hilbert_value.hpp
+++ b/src/mlpack/core/tree/rectangle_tree/discrete_hilbert_value.hpp
@@ -32,7 +32,7 @@ class DiscreteHilbertValue
   //! uint32_t or uint64_t.
   typedef std::conditional_t<sizeof(TreeElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>HilbertElemType;
+                                    uint64_t> HilbertElemType;
 
   //! Default constructor.
   DiscreteHilbertValue();
diff --git a/src/mlpack/core/util/ens_traits.hpp b/src/mlpack/core/util/ens_traits.hpp
index cade7a7069..36faa4dcc8 100644
--- a/src/mlpack/core/util/ens_traits.hpp
+++ b/src/mlpack/core/util/ens_traits.hpp
@@ -55,8 +55,7 @@ struct IsEnsOptimizerInternal<OptimizerType, FunctionType, MatType, true>
 {
   // If OptimizerType is a reference type, then forming the types below will
   // fail.  So we need to strip the reference (and the const for good measure).
-  typedef std::remove_cv_t<
-      std::remove_reference_t<OptimizerType>>
+  typedef std::remove_cv_t<std::remove_reference_t<OptimizerType>>
       SafeOptimizerType;
 
   using OptimizeElemReturnForm =
@@ -85,9 +84,8 @@ template<typename CallbackType, typename... CallbackTypes>
 struct IsEnsCallbackTypes<CallbackType, CallbackTypes...>
 {
   constexpr static bool value =
-      std::is_class_v<std::remove_cv_t<
-          std::remove_reference_t<CallbackType>
-      >> && IsEnsCallbackTypes<CallbackTypes...>::value;
+      std::is_class_v<std::remove_cv_t<std::remove_reference_t<CallbackType>>>
+      && IsEnsCallbackTypes<CallbackTypes...>::value;
 };
 
 template<>
diff --git a/src/mlpack/core/util/first_element_is_arma.hpp b/src/mlpack/core/util/first_element_is_arma.hpp
index 7bec0f54e7..dd6d1fc11b 100644
--- a/src/mlpack/core/util/first_element_is_arma.hpp
+++ b/src/mlpack/core/util/first_element_is_arma.hpp
@@ -39,9 +39,7 @@ template<typename... CallbackTypes>
 struct FirstElementIsArma
 {
   static constexpr bool value = arma::is_arma_type<
-      std::remove_reference_t<
-          typename First<CallbackTypes...>::type
-      >>::value;
+      std::remove_reference_t<typename First<CallbackTypes...>::type>>::value;
 };
 
 } // namespace mlpack
diff --git a/src/mlpack/core/util/sfinae_utility.hpp b/src/mlpack/core/util/sfinae_utility.hpp
index b1747bd4a4..62b8c795f6 100644
--- a/src/mlpack/core/util/sfinae_utility.hpp
+++ b/src/mlpack/core/util/sfinae_utility.hpp
@@ -155,8 +155,7 @@ struct NAME                                                                    \
     using no = char[2];                                                        \
                                                                                \
     template<typename T, typename ResultType>                                  \
-    using EnableIfVoid =                                                       \
-        std::enable_if_t<std::is_void_v<T>, ResultType>;     \
+    using EnableIfVoid = std::enable_if_t<std::is_void_v<T>, ResultType>;      \
                                                                                \
     template<typename C>                                                       \
     static EnableIfVoid<decltype(MFD<C, MF, N>()(&C::METHOD)), yes&> chk(int); \
@@ -169,13 +168,13 @@ struct NAME                                                                    \
   template<size_t N>                                                           \
   struct WithGreaterOrEqualNumberOfAdditionalArgs                              \
   {                                                                            \
-    using type = typename std::conditional<                                    \
+    using type = std::conditional_t<                                           \
         WithNAdditionalArgs<N>::value,                                         \
         std::true_type,                                                        \
-        typename std::conditional<                                             \
+        std::conditional_t<                                                    \
             N < MAXN,                                                          \
             WithGreaterOrEqualNumberOfAdditionalArgs<N + 1>,                   \
-            std::false_type>::type>::type;                                     \
+            std::false_type>>;                                                 \
     static const bool value = type::value;                                     \
   };                                                                           \
                                                                                \
diff --git a/src/mlpack/core/util/size_checks.hpp b/src/mlpack/core/util/size_checks.hpp
index 2d55c25f23..6999ad31e3 100644
--- a/src/mlpack/core/util/size_checks.hpp
+++ b/src/mlpack/core/util/size_checks.hpp
@@ -39,8 +39,7 @@ inline void CheckSameSizes(
     const std::string& addInfo = "labels",
     const bool& isDataTranspose = false,
     const bool& isLabelTranspose = false,
-    const std::enable_if_t<
-        !std::is_integral_v<LabelsType>>* = 0)
+    const std::enable_if_t<!std::is_integral_v<LabelsType>>* = 0)
 {
   const size_t dataPoints = (isDataTranspose == true) ? data.n_rows :
       data.n_cols;
diff --git a/src/mlpack/methods/adaboost/adaboost.hpp b/src/mlpack/methods/adaboost/adaboost.hpp
index e6a71275d1..a4d8b79966 100644
--- a/src/mlpack/methods/adaboost/adaboost.hpp
+++ b/src/mlpack/methods/adaboost/adaboost.hpp
@@ -131,8 +131,7 @@ class AdaBoost
            const size_t maxIterations = 100,
            const ElemType tolerance = 1e-6,
            const std::enable_if_t<
-              std::is_same_v<WeakLearnerType, WeakLearnerInType>
-           >* = 0);
+              std::is_same_v<WeakLearnerType, WeakLearnerInType>>* = 0);
 
   //! Get the maximum number of weak learners allowed in the model.
   size_t MaxIterations() const { return maxIterations; }
diff --git a/src/mlpack/methods/ann/convolution_rules/fft_convolution.hpp b/src/mlpack/methods/ann/convolution_rules/fft_convolution.hpp
index 0405619572..5e2dfa4772 100644
--- a/src/mlpack/methods/ann/convolution_rules/fft_convolution.hpp
+++ b/src/mlpack/methods/ann/convolution_rules/fft_convolution.hpp
@@ -48,8 +48,7 @@ class FFTConvolution
    * @param output Output data that contains the results of the convolution.
    */
   template<typename MatType, typename Border = BorderMode>
-  static std::enable_if_t<
-      std::is_same_v<Border, ValidConvolution>, void>
+  static std::enable_if_t<std::is_same_v<Border, ValidConvolution>, void>
   Convolution(const MatType& input,
               const MatType& filter,
               MatType& output,
@@ -83,8 +82,7 @@ class FFTConvolution
    * @param output Output data that contains the results of the convolution.
    */
   template<typename MatType, typename Border = BorderMode>
-  static std::enable_if_t<
-      std::is_same_v<Border, FullConvolution>, void>
+  static std::enable_if_t<std::is_same_v<Border, FullConvolution>, void>
   Convolution(const MatType& input,
               const MatType& filter,
               MatType& output,
diff --git a/src/mlpack/methods/ann/convolution_rules/naive_convolution.hpp b/src/mlpack/methods/ann/convolution_rules/naive_convolution.hpp
index 1243479b74..a323c7b38f 100644
--- a/src/mlpack/methods/ann/convolution_rules/naive_convolution.hpp
+++ b/src/mlpack/methods/ann/convolution_rules/naive_convolution.hpp
@@ -49,8 +49,7 @@ class NaiveConvolution
    */
   template<typename InMatType, typename FilMatType, typename OutMatType,
       typename Border = BorderMode>
-  static std::enable_if_t<
-      std::is_same_v<Border, ValidConvolution>, void>
+  static std::enable_if_t<std::is_same_v<Border, ValidConvolution>, void>
   Convolution(const InMatType& input,
               const FilMatType& filter,
               OutMatType& output,
@@ -110,8 +109,7 @@ class NaiveConvolution
    */
   template<typename InMatType, typename FilMatType, typename OutMatType,
       typename Border = BorderMode>
-  static std::enable_if_t<
-      std::is_same_v<Border, FullConvolution>, void>
+  static std::enable_if_t<std::is_same_v<Border, FullConvolution>, void>
   Convolution(const InMatType& input,
               const FilMatType& filter,
               OutMatType& output,
diff --git a/src/mlpack/methods/ann/ffn.hpp b/src/mlpack/methods/ann/ffn.hpp
index 671d82f962..f4ca7ea933 100644
--- a/src/mlpack/methods/ann/ffn.hpp
+++ b/src/mlpack/methods/ann/ffn.hpp
@@ -487,8 +487,7 @@ class FFN
    */
   template<typename OptimizerType>
   std::enable_if_t<
-      ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void
-  >
+      ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void>
   WarnMessageMaxIterations(OptimizerType& optimizer, size_t samples) const;
 
   /**
@@ -501,8 +500,7 @@ class FFN
    */
   template<typename OptimizerType>
   std::enable_if_t<
-      !ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void
-  >
+      !ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void>
   WarnMessageMaxIterations(OptimizerType& optimizer, size_t samples) const;
 
   //! Instantiated output layer used to evaluate the network.
diff --git a/src/mlpack/methods/ann/ffn_impl.hpp b/src/mlpack/methods/ann/ffn_impl.hpp
index 980e3fd2a6..e41b2f2db8 100644
--- a/src/mlpack/methods/ann/ffn_impl.hpp
+++ b/src/mlpack/methods/ann/ffn_impl.hpp
@@ -695,8 +695,7 @@ template<typename OutputLayerType,
          typename MatType>
 template<typename OptimizerType>
 std::enable_if_t<
-    ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void
->
+    ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void>
 FFN<
     OutputLayerType,
     InitializationRuleType,
@@ -719,8 +718,7 @@ template<typename OutputLayerType,
          typename MatType>
 template<typename OptimizerType>
 std::enable_if_t<
-    !ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void
->
+    !ens::traits::HasMaxIterationsSignature<OptimizerType>::value, void>
 FFN<
     OutputLayerType,
     InitializationRuleType,
diff --git a/src/mlpack/methods/ann/not_adapted/gan/gan.hpp b/src/mlpack/methods/ann/not_adapted/gan/gan.hpp
index 2b754dddbe..0b2a43d0f8 100644
--- a/src/mlpack/methods/ann/not_adapted/gan/gan.hpp
+++ b/src/mlpack/methods/ann/not_adapted/gan/gan.hpp
@@ -135,7 +135,7 @@ class GAN
    */
   template<typename Policy = PolicyType>
   std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
-                          std::is_same_v<Policy, DCGAN>, double>
+                   std::is_same_v<Policy, DCGAN>, double>
   Evaluate(const arma::mat& parameters,
            const size_t i,
            const size_t batchSize);
@@ -149,8 +149,7 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename Policy = PolicyType>
-  std::enable_if_t<std::is_same_v<Policy, WGAN>,
-                          double>
+  std::enable_if_t<std::is_same_v<Policy, WGAN>, double>
   Evaluate(const arma::mat& parameters,
            const size_t i,
            const size_t batchSize);
@@ -164,8 +163,7 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename Policy = PolicyType>
-  std::enable_if_t<std::is_same_v<Policy, WGANGP>,
-                          double>
+  std::enable_if_t<std::is_same_v<Policy, WGANGP>, double>
   Evaluate(const arma::mat& parameters,
            const size_t i,
            const size_t batchSize);
@@ -182,7 +180,7 @@ class GAN
    */
   template<typename GradType, typename Policy = PolicyType>
   std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
-                          std::is_same_v<Policy, DCGAN>, double>
+                   std::is_same_v<Policy, DCGAN>, double>
   EvaluateWithGradient(const arma::mat& parameters,
                        const size_t i,
                        GradType& gradient,
@@ -199,8 +197,7 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename GradType, typename Policy = PolicyType>
-  std::enable_if_t<std::is_same_v<Policy, WGAN>,
-                          double>
+  std::enable_if_t<std::is_same_v<Policy, WGAN>, double>
   EvaluateWithGradient(const arma::mat& parameters,
                        const size_t i,
                        GradType& gradient,
@@ -217,8 +214,7 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename GradType, typename Policy = PolicyType>
-  std::enable_if_t<std::is_same_v<Policy, WGANGP>,
-                          double>
+  std::enable_if_t<std::is_same_v<Policy, WGANGP>, double>
   EvaluateWithGradient(const arma::mat& parameters,
                        const size_t i,
                        GradType& gradient,
@@ -236,7 +232,7 @@ class GAN
    */
   template<typename Policy = PolicyType>
   std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
-                          std::is_same_v<Policy, DCGAN>, void>
+                   std::is_same_v<Policy, DCGAN>, void>
   Gradient(const arma::mat& parameters,
            const size_t i,
            arma::mat& gradient,
@@ -270,8 +266,7 @@ class GAN
    * @param batchSize Variable to store the present number of inputs.
    */
   template<typename Policy = PolicyType>
-  std::enable_if_t<std::is_same_v<Policy, WGANGP>,
-                          void>
+  std::enable_if_t<std::is_same_v<Policy, WGANGP>, void>
   Gradient(const arma::mat& parameters,
            const size_t i,
            arma::mat& gradient,
diff --git a/src/mlpack/methods/ann/not_adapted/gan/gan_impl.hpp b/src/mlpack/methods/ann/not_adapted/gan/gan_impl.hpp
index 88371bab52..1e29a4c573 100644
--- a/src/mlpack/methods/ann/not_adapted/gan/gan_impl.hpp
+++ b/src/mlpack/methods/ann/not_adapted/gan/gan_impl.hpp
@@ -234,7 +234,7 @@ template<
 >
 template<typename Policy>
 std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
-                        std::is_same_v<Policy, DCGAN>, double>
+                 std::is_same_v<Policy, DCGAN>, double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::Evaluate(
     const arma::mat& /* parameters */,
     const size_t i,
@@ -289,7 +289,7 @@ template<
 >
 template<typename GradType, typename Policy>
 std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
-                        std::is_same_v<Policy, DCGAN>, double>
+                 std::is_same_v<Policy, DCGAN>, double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 EvaluateWithGradient(const arma::mat& /* parameters */,
                      const size_t i,
@@ -392,7 +392,7 @@ template<
 >
 template<typename Policy>
 std::enable_if_t<std::is_same_v<Policy, StandardGAN> ||
-                        std::is_same_v<Policy, DCGAN>, void>
+                 std::is_same_v<Policy, DCGAN>, void>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 Gradient(const arma::mat& parameters,
          const size_t i,
diff --git a/src/mlpack/methods/ann/not_adapted/gan/wgangp_impl.hpp b/src/mlpack/methods/ann/not_adapted/gan/wgangp_impl.hpp
index d4f49ace20..d983e48eb3 100644
--- a/src/mlpack/methods/ann/not_adapted/gan/wgangp_impl.hpp
+++ b/src/mlpack/methods/ann/not_adapted/gan/wgangp_impl.hpp
@@ -27,8 +27,7 @@ template<
   typename PolicyType
 >
 template<typename Policy>
-std::enable_if_t<std::is_same_v<Policy, WGANGP>,
-                        double>
+std::enable_if_t<std::is_same_v<Policy, WGANGP>, double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::Evaluate(
     const arma::mat& /* parameters */,
     const size_t i,
@@ -95,8 +94,7 @@ template<
   typename PolicyType
 >
 template<typename GradType, typename Policy>
-std::enable_if_t<std::is_same_v<Policy, WGANGP>,
-                        double>
+std::enable_if_t<std::is_same_v<Policy, WGANGP>, double>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 EvaluateWithGradient(const arma::mat& /* parameters */,
                      const size_t i,
@@ -209,8 +207,7 @@ template<
   typename PolicyType
 >
 template<typename Policy>
-std::enable_if_t<std::is_same_v<Policy, WGANGP>,
-                        void>
+std::enable_if_t<std::is_same_v<Policy, WGANGP>, void>
 GAN<Model, InitializationRuleType, Noise, PolicyType>::
 Gradient(const arma::mat& parameters,
          const size_t i,
diff --git a/src/mlpack/methods/ann/not_adapted/rbm/rbm.hpp b/src/mlpack/methods/ann/not_adapted/rbm/rbm.hpp
index cd15b08d01..b5afe73bf9 100644
--- a/src/mlpack/methods/ann/not_adapted/rbm/rbm.hpp
+++ b/src/mlpack/methods/ann/not_adapted/rbm/rbm.hpp
@@ -130,8 +130,7 @@ class RBM
    * @param input The visible layer neurons.
    */
   template<typename Policy = PolicyType, typename InputType = DataType>
-  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>,
-      double>
+  std::enable_if_t<std::is_same_v<Policy, SpikeSlabRBM>, double>
   FreeEnergy(const arma::Mat<ElemType>& input);
 
   /**
diff --git a/src/mlpack/methods/bayesian_linear_regression/bayesian_linear_regression.hpp b/src/mlpack/methods/bayesian_linear_regression/bayesian_linear_regression.hpp
index 84779e9723..06459fbd1f 100644
--- a/src/mlpack/methods/bayesian_linear_regression/bayesian_linear_regression.hpp
+++ b/src/mlpack/methods/bayesian_linear_regression/bayesian_linear_regression.hpp
@@ -140,8 +140,7 @@ class BayesianLinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   BayesianLinearRegression(const MatType& data,
                            const ResponsesType& responses,
                            const bool centerData = true,
@@ -176,8 +175,7 @@ class BayesianLinearRegression
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const std::optional<bool> centerData = std::nullopt,
@@ -188,8 +186,7 @@ class BayesianLinearRegression
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool centerData,
@@ -232,8 +229,7 @@ class BayesianLinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   void Predict(const MatType& points,
                ResponsesType& predictions) const;
 
@@ -250,8 +246,7 @@ class BayesianLinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   void Predict(const MatType& points,
                ResponsesType& predictions,
                ResponsesType& std) const;
@@ -267,8 +262,7 @@ class BayesianLinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType RMSE(const MatType& data,
                 const ResponsesType& responses) const;
 
diff --git a/src/mlpack/methods/decision_tree/decision_tree_impl.hpp b/src/mlpack/methods/decision_tree/decision_tree_impl.hpp
index b8102a2445..c677e34c47 100644
--- a/src/mlpack/methods/decision_tree/decision_tree_impl.hpp
+++ b/src/mlpack/methods/decision_tree/decision_tree_impl.hpp
@@ -536,8 +536,7 @@ double DecisionTree<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<
-        arma::is_arma_type<
-        std::remove_reference_t<WeightsType>>::value>*)
+        arma::is_arma_type<std::remove_reference_t<WeightsType>>::value>*)
 {
   // Sanity check on data.
   util::CheckSameSizes(data, labels, "DecisionTree::Train()");
@@ -581,8 +580,7 @@ double DecisionTree<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<
-        arma::is_arma_type<
-        std::remove_reference_t<WeightsType>>::value>*)
+        arma::is_arma_type<std::remove_reference_t<WeightsType>>::value>*)
 {
   // Sanity check on data.
   util::CheckSameSizes(data, labels, "DecisionTree::Train()");
diff --git a/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp b/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp
index b2fc5538a5..dd950a97f8 100644
--- a/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp
+++ b/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp
@@ -165,9 +165,8 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<
-        arma::is_arma_type<
-        std::remove_reference_t<
-        WeightsType>>::value>*) : splitInfo()
+        arma::is_arma_type<std::remove_reference_t<WeightsType>>::value>*)
+    : splitInfo()
 {
   using TrueMatType = std::decay_t<MatType>;
   using TrueResponsesType = std::decay_t<ResponsesType>;
@@ -246,11 +245,10 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<arma::is_arma_type<
-        std::remove_reference_t<
-        WeightsType>>::value>*):
-        splitInfo(std::move(other.splitInfo)),
-        NumericAuxiliarySplitInfo(other),
-        CategoricalAuxiliarySplitInfo(other)   // other info does need to copy
+        std::remove_reference_t<WeightsType>>::value>*)
+    : splitInfo(std::move(other.splitInfo)),
+      NumericAuxiliarySplitInfo(other),
+      CategoricalAuxiliarySplitInfo(other)   // other info does need to copy
 {
   using TrueMatType = std::decay_t<MatType>;
   using TrueResponsesType = std::decay_t<ResponsesType>;
@@ -521,9 +519,7 @@ double DecisionTreeRegressor<FitnessFunction,
     DimensionSelectionType dimensionSelector,
     FitnessFunction fitnessFunction,
     const std::enable_if_t<
-        arma::is_arma_type<
-        std::remove_reference_t<
-        WeightsType>>::value>*)
+        arma::is_arma_type<std::remove_reference_t<WeightsType>>::value>*)
 {
   // Sanity check on data.
   util::CheckSameSizes(data, responses, "DecisionTreeRegressor::Train()");
@@ -567,9 +563,7 @@ double DecisionTreeRegressor<FitnessFunction,
     DimensionSelectionType dimensionSelector,
     FitnessFunction fitnessFunction,
     const std::enable_if_t<
-        arma::is_arma_type<
-        std::remove_reference_t<
-        WeightsType>>::value>*)
+        arma::is_arma_type<std::remove_reference_t<WeightsType>>::value>*)
 {
   // Sanity check on data.
   util::CheckSameSizes(data, responses, "DecisionTreeRegressor::Train()");
diff --git a/src/mlpack/methods/det/dtree_impl.hpp b/src/mlpack/methods/det/dtree_impl.hpp
index e62c851f9e..78239a60de 100644
--- a/src/mlpack/methods/det/dtree_impl.hpp
+++ b/src/mlpack/methods/det/dtree_impl.hpp
@@ -29,8 +29,7 @@ void ExtractSplits(std::vector<std::pair<ElemType, size_t>>& splitVec,
                    const size_t end,
                    const size_t minLeafSize)
 {
-  static_assert(
-    std::is_same_v<typename MatType::elem_type, ElemType> == true,
+  static_assert(std::is_same_v<typename MatType::elem_type, ElemType>,
     "The ElemType does not correspond to the matrix's element type.");
 
   typedef std::pair<ElemType, size_t> SplitItem;
diff --git a/src/mlpack/methods/gmm/em_fit_impl.hpp b/src/mlpack/methods/gmm/em_fit_impl.hpp
index 485d147c02..26af885206 100644
--- a/src/mlpack/methods/gmm/em_fit_impl.hpp
+++ b/src/mlpack/methods/gmm/em_fit_impl.hpp
@@ -298,8 +298,8 @@ InitialClustering(const arma::mat& observations,
   std::vector<arma::vec> means(dists.size());
 
   // Conditional covariance instantiation.
-  std::vector<typename std::conditional<isDiagGaussDist,
-      arma::vec, arma::mat>::type> covs(dists.size());
+  std::vector<std::conditional_t<isDiagGaussDist, arma::vec, arma::mat>>
+      covs(dists.size());
 
   // Now calculate the means, covariances, and weights.
   weights.zeros();
diff --git a/src/mlpack/methods/gmm/positive_definite_constraint.hpp b/src/mlpack/methods/gmm/positive_definite_constraint.hpp
index a153533ded..29d1e12f67 100644
--- a/src/mlpack/methods/gmm/positive_definite_constraint.hpp
+++ b/src/mlpack/methods/gmm/positive_definite_constraint.hpp
@@ -35,8 +35,7 @@ class PositiveDefiniteConstraint
   template<typename MatType>
   static void ApplyConstraint(
       MatType& covariance,
-      const std::enable_if_t<!IsVector<MatType>::value>*
-          /* junk */ = 0)
+      const std::enable_if_t<!IsVector<MatType>::value>* /* junk */ = 0)
   {
     typedef typename MatType::elem_type ElemType;
     typedef typename GetColType<MatType>::type VecType;
@@ -82,8 +81,7 @@ class PositiveDefiniteConstraint
   template<typename VecType>
   static void ApplyConstraint(
       VecType& diagCovariance,
-      const std::enable_if_t<IsVector<VecType>::value>*
-          /* junk */ = 0)
+      const std::enable_if_t<IsVector<VecType>::value>* /* junk */ = 0)
   {
     typedef typename VecType::elem_type ElemType;
 
diff --git a/src/mlpack/methods/kmeans/dual_tree_kmeans_impl.hpp b/src/mlpack/methods/kmeans/dual_tree_kmeans_impl.hpp
index 691e8b75e8..f5c7df5a58 100644
--- a/src/mlpack/methods/kmeans/dual_tree_kmeans_impl.hpp
+++ b/src/mlpack/methods/kmeans/dual_tree_kmeans_impl.hpp
@@ -27,8 +27,7 @@ template<typename TreeType, typename MatType>
 TreeType* BuildForcedLeafSizeTree(
     MatType&& dataset,
     std::vector<size_t>& oldFromNew,
-    const std::enable_if_t<
-        TreeTraits<TreeType>::RearrangesDataset>* = 0)
+    const std::enable_if_t<TreeTraits<TreeType>::RearrangesDataset>* = 0)
 {
   // This is a hack.  I know this will be BinarySpaceTree, so force a leaf size
   // of one.
@@ -40,8 +39,7 @@ template<typename TreeType, typename MatType>
 TreeType* BuildForcedLeafSizeTree(
     MatType&& dataset,
     const std::vector<size_t>& /* oldFromNew */,
-    const std::enable_if_t<
-        !TreeTraits<TreeType>::RearrangesDataset>* = 0)
+    const std::enable_if_t<!TreeTraits<TreeType>::RearrangesDataset>* = 0)
 {
   return new TreeType(std::forward<MatType>(dataset));
 }
diff --git a/src/mlpack/methods/lars/lars.hpp b/src/mlpack/methods/lars/lars.hpp
index fa001aba96..0700b686f5 100644
--- a/src/mlpack/methods/lars/lars.hpp
+++ b/src/mlpack/methods/lars/lars.hpp
@@ -166,8 +166,7 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   LARS(const MatType& data,
        const ResponsesType& responses,
        bool colMajor = true,
@@ -205,8 +204,7 @@ class LARS
   template<typename MatType,
            typename ResponsesType,
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   LARS(const MatType& data,
        const ResponsesType& responses,
        const bool colMajor,
@@ -297,11 +295,9 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >,
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>,
            typename = std::enable_if_t<
-               !std::is_same_v<ResponsesType, arma::rowvec>
-           >>
+               !std::is_same_v<ResponsesType, arma::rowvec>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor = true);
@@ -310,8 +306,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -321,8 +316,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -333,8 +327,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -346,8 +339,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -360,8 +352,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -375,8 +366,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -408,8 +398,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -420,8 +409,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -433,8 +421,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -447,8 +434,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -462,8 +448,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
@@ -478,8 +463,7 @@ class LARS
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& data,
                  const ResponsesType& responses,
                  const bool colMajor,
diff --git a/src/mlpack/methods/linear_regression/linear_regression.hpp b/src/mlpack/methods/linear_regression/linear_regression.hpp
index 639d23eb01..d36c855d7d 100644
--- a/src/mlpack/methods/linear_regression/linear_regression.hpp
+++ b/src/mlpack/methods/linear_regression/linear_regression.hpp
@@ -44,8 +44,7 @@ class LinearRegression
   template<typename MatType,
            typename ResponsesType,
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   LinearRegression(const MatType& predictors,
                    const ResponsesType& responses,
                    const double lambda = 0,
@@ -64,11 +63,9 @@ class LinearRegression
            typename ResponsesType,
            typename WeightsType,
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >,
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>,
            typename = std::enable_if_t<
-               std::is_same_v<typename WeightsType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename WeightsType::elem_type, ElemType>>>
   LinearRegression(const MatType& predictors,
                    const ResponsesType& responses,
                    const WeightsType& weights,
@@ -103,8 +100,7 @@ class LinearRegression
   double Train(const arma::mat& predictors,
                const arma::rowvec& responses,
                const T intercept,
-               const std::enable_if_t<std::is_same_v<T, bool>
-                   >* = 0);
+               const std::enable_if_t<std::is_same_v<T, bool>>* = 0);
 
   /**
    * Train the LinearRegression model on the given data and instance weights.
@@ -129,8 +125,7 @@ class LinearRegression
                const arma::rowvec& responses,
                const arma::rowvec& weights,
                const T intercept,
-               const std::enable_if_t<std::is_same_v<T, bool>
-                   >* = 0);
+               const std::enable_if_t<std::is_same_v<T, bool>>* = 0);
 
   /**
    * Train the LinearRegression model.  This is a dummy overload so that
@@ -158,8 +153,7 @@ class LinearRegression
            typename ResponsesType,
            typename = void, /* so MetaInfoExtractor does not get confused */
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>>
   ElemType Train(const MatType& predictors,
                  const ResponsesType& responses,
                  const std::optional<double> lambda = std::nullopt,
@@ -193,11 +187,9 @@ class LinearRegression
            typename ResponsesType,
            typename WeightsType,
            typename = std::enable_if_t<
-               std::is_same_v<typename ResponsesType::elem_type, ElemType>
-           >,
+               std::is_same_v<typename ResponsesType::elem_type, ElemType>>,
            typename = std::enable_if_t<
-               std::is_same_v<typename WeightsType::elem_type, ElemType>
-           >>
+               std::is_same_v<typename WeightsType::elem_type, ElemType>>>
   ElemType Train(const MatType& predictors,
                  const ResponsesType& responses,
                  const WeightsType& weights,
diff --git a/src/mlpack/methods/lmnn/lmnn.hpp b/src/mlpack/methods/lmnn/lmnn.hpp
index 6f62734b4b..e2ba1edebc 100644
--- a/src/mlpack/methods/lmnn/lmnn.hpp
+++ b/src/mlpack/methods/lmnn/lmnn.hpp
@@ -101,8 +101,7 @@ class LMNN
                CallbackTypes...
            >::value>,
            typename = std::enable_if_t<
-               !FirstElementIsArma<CallbackTypes...>::value
-           >>
+               !FirstElementIsArma<CallbackTypes...>::value>>
   [[deprecated("Will be removed in mlpack 5.0.0.  Use the version that takes a "
                "dataset as a parameter.")]]
   void LearnDistance(arma::mat& outputMatrix, CallbackTypes&&... callbacks);
diff --git a/src/mlpack/methods/lsh/lsh_search_impl.hpp b/src/mlpack/methods/lsh/lsh_search_impl.hpp
index 151c84f238..c45a9eebc2 100644
--- a/src/mlpack/methods/lsh/lsh_search_impl.hpp
+++ b/src/mlpack/methods/lsh/lsh_search_impl.hpp
@@ -647,8 +647,7 @@ void LSHSearch<SortPolicy, MatType>::GetAdditionalProbingBins(
   std::priority_queue<
     std::pair<double, size_t>,        // contents: pairs of (score, index)
     std::vector<                      // container: vector of pairs
-      std::pair<double, size_t>
-      >,
+      std::pair<double, size_t>>,
     std::greater< std::pair<double, size_t> > // comparator of pairs
   > minHeap; // our minheap
 
diff --git a/src/mlpack/methods/naive_bayes/naive_bayes_classifier_impl.hpp b/src/mlpack/methods/naive_bayes/naive_bayes_classifier_impl.hpp
index 7e8ced7b3c..16343bc01c 100644
--- a/src/mlpack/methods/naive_bayes/naive_bayes_classifier_impl.hpp
+++ b/src/mlpack/methods/naive_bayes/naive_bayes_classifier_impl.hpp
@@ -274,7 +274,7 @@ void NaiveBayesClassifier<ModelMatType>::Classify(
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
   static_assert(std::is_same_v<ElemType,
-                             typename ProbabilitiesVecType::elem_type>,
+                               typename ProbabilitiesVecType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
@@ -349,7 +349,7 @@ void NaiveBayesClassifier<ModelMatType>::Classify(
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
   static_assert(std::is_same_v<ElemType,
-                             typename ProbabilitiesMatType::elem_type>,
+                               typename ProbabilitiesMatType::elem_type>,
       "NaiveBayesClassifier: element type of given data must match the element "
       "type of the model!");
 
diff --git a/src/mlpack/methods/nca/nca.hpp b/src/mlpack/methods/nca/nca.hpp
index 1d68ef4db3..189e5236d5 100644
--- a/src/mlpack/methods/nca/nca.hpp
+++ b/src/mlpack/methods/nca/nca.hpp
@@ -81,11 +81,9 @@ class NCA
    */
   template<typename... CallbackTypes,
            typename = std::enable_if_t<IsEnsCallbackTypes<
-               CallbackTypes...
-           >::value>,
+               CallbackTypes...>::value>,
            typename = std::enable_if_t<
-               !FirstElementIsArma<CallbackTypes...>::value
-           >>
+               !FirstElementIsArma<CallbackTypes...>::value>>
   [[deprecated("Will be removed in mlpack 5.0.0.  Use the version that takes a "
                "dataset as a parameter.")]]
   void LearnDistance(arma::mat& outputMatrix, CallbackTypes&&... callbacks);
@@ -111,9 +109,8 @@ class NCA
                SoftmaxErrorFunction<MatType, LabelsType, DistanceType>,
                MatType
            >::value>,
-           typename = std::enable_if_t<IsEnsCallbackTypes<
-               CallbackTypes...
-           >::value>>
+           typename = std::enable_if_t<
+               IsEnsCallbackTypes<CallbackTypes...>::value>>
   void LearnDistance(const MatType& dataset,
                      const LabelsType& labels,
                      MatType& outputMatrix,
diff --git a/src/mlpack/methods/pca/pca_impl.hpp b/src/mlpack/methods/pca/pca_impl.hpp
index d8da5362bc..d4d4784036 100644
--- a/src/mlpack/methods/pca/pca_impl.hpp
+++ b/src/mlpack/methods/pca/pca_impl.hpp
@@ -48,7 +48,7 @@ void PCA<DecompositionPolicy>::Apply(const MatType& data,
   static_assert(IsBaseMatType<VecType>::value,
       "PCA::Apply(): eigVal must be a vector type!");
   static_assert(std::is_same_v<typename MatType::elem_type,
-                             typename OutMatType::elem_type>,
+                               typename OutMatType::elem_type>,
       "PCA::Apply(): data and transformedData must have the same element "
       "types!");
 
@@ -82,7 +82,7 @@ void PCA<DecompositionPolicy>::Apply(const MatType& data,
   static_assert(IsBaseMatType<VecType>::value,
       "PCA::Apply(): eigVal must be a vector type!");
   static_assert(std::is_same_v<typename MatType::elem_type,
-                             typename OutMatType::elem_type>,
+                               typename OutMatType::elem_type>,
       "PCA::Apply(): data and transformedData must have the same element "
       "types!");
 
@@ -105,7 +105,7 @@ void PCA<DecompositionPolicy>::Apply(const MatType& data,
   static_assert(IsBaseMatType<OutMatType>::value,
       "PCA::Apply(): transformedData must be a matrix type!");
   static_assert(std::is_same_v<typename MatType::elem_type,
-                             typename OutMatType::elem_type>,
+                               typename OutMatType::elem_type>,
       "PCA::Apply(): data and transformedData must have the same element "
       "types!");
 
diff --git a/src/mlpack/methods/perceptron/perceptron_impl.hpp b/src/mlpack/methods/perceptron/perceptron_impl.hpp
index b8dcc740e8..c03533889c 100644
--- a/src/mlpack/methods/perceptron/perceptron_impl.hpp
+++ b/src/mlpack/methods/perceptron/perceptron_impl.hpp
@@ -83,8 +83,7 @@ Perceptron<LearnPolicy, WeightInitializationPolicy, MatType>::Perceptron(
     const size_t numClasses,
     const WeightsType& instanceWeights,
     const size_t maxIterations,
-    const std::enable_if_t<
-        arma::is_arma_type<WeightsType>::value>*) :
+    const std::enable_if_t<arma::is_arma_type<WeightsType>::value>*) :
     maxIterations(maxIterations)
 {
   // Start training.
@@ -114,8 +113,7 @@ Perceptron<LearnPolicy, WeightInitializationPolicy, MatType>::Perceptron(
     const arma::Row<size_t>& labels,
     const size_t numClasses,
     const WeightsType& instanceWeights,
-    const std::enable_if_t<
-        arma::is_arma_type<WeightsType>::value>*) :
+    const std::enable_if_t<arma::is_arma_type<WeightsType>::value>*) :
     maxIterations(other.maxIterations)
 {
   TrainInternal<true>(data, labels, numClasses, instanceWeights);
diff --git a/src/mlpack/methods/softmax_regression/softmax_regression.hpp b/src/mlpack/methods/softmax_regression/softmax_regression.hpp
index 8ce97ab28d..838bace925 100644
--- a/src/mlpack/methods/softmax_regression/softmax_regression.hpp
+++ b/src/mlpack/methods/softmax_regression/softmax_regression.hpp
@@ -96,9 +96,8 @@ class SoftmaxRegression
            typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
            >::value>,
-           typename = std::enable_if_t<IsEnsCallbackTypes<
-               CallbackTypes...
-           >::value>>
+           typename = std::enable_if_t<
+               IsEnsCallbackTypes<CallbackTypes...>::value>>
   SoftmaxRegression(const MatType& data,
                     const arma::Row<size_t>& labels,
                     const size_t numClasses,
@@ -128,9 +127,8 @@ class SoftmaxRegression
            typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
            >::value>,
-           typename = std::enable_if_t<IsEnsCallbackTypes<
-               CallbackTypes...
-           >::value>>
+           typename = std::enable_if_t<
+               IsEnsCallbackTypes<CallbackTypes...>::value>>
   SoftmaxRegression(const MatType& data,
                     const arma::Row<size_t>& labels,
                     const size_t numClasses,
@@ -161,12 +159,9 @@ class SoftmaxRegression
            typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
            >::value>,
+           typename = std::enable_if_t<std::is_class_v<FirstCallbackType>>,
            typename = std::enable_if_t<
-              std::is_class_v<FirstCallbackType>
-           >,
-           typename = std::enable_if_t<IsEnsCallbackTypes<
-               CallbackTypes...
-           >::value>>
+               IsEnsCallbackTypes<CallbackTypes...>::value>>
   [[deprecated("Will be removed in mlpack 5.0.0, use other Train() variants")]]
   double Train(const MatType& data,
                const arma::Row<size_t>& labels,
@@ -194,9 +189,8 @@ class SoftmaxRegression
            typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
            >::value>,
-           typename = std::enable_if_t<IsEnsCallbackTypes<
-               CallbackTypes...
-           >::value>>
+           typename = std::enable_if_t<
+               IsEnsCallbackTypes<CallbackTypes...>::value>>
   ElemType Train(const MatType& data,
                  const arma::Row<size_t>& labels,
                  const size_t numClasses,
@@ -224,9 +218,8 @@ class SoftmaxRegression
            typename = std::enable_if_t<IsEnsOptimizer<
                OptimizerType, SoftmaxRegressionFunction<MatType>, DenseMatType
            >::value>,
-           typename = std::enable_if_t<IsEnsCallbackTypes<
-               CallbackTypes...
-           >::value>>
+           typename = std::enable_if_t<
+               IsEnsCallbackTypes<CallbackTypes...>::value>>
   ElemType Train(const MatType& data,
                  const arma::Row<size_t>& labels,
                  const size_t numClasses,
diff --git a/src/mlpack/tests/cv_test.cpp b/src/mlpack/tests/cv_test.cpp
index a5ff8dc001..059dd80642 100644
--- a/src/mlpack/tests/cv_test.cpp
+++ b/src/mlpack/tests/cv_test.cpp
@@ -299,8 +299,7 @@ void CheckPredictionsType()
 {
   using Extractor = MetaInfoExtractor<Class, PassedMT, PassedPT>;
   using ActualPT = typename Extractor::PredictionsType;
-  static_assert(std::is_same_v<ExpectedPT, ActualPT>,
-      "Should be the same");
+  static_assert(std::is_same_v<ExpectedPT, ActualPT>, "Should be the same");
 }
 
 /**
diff --git a/src/mlpack/tests/lars_test.cpp b/src/mlpack/tests/lars_test.cpp
index c143fbd426..95220bccff 100644
--- a/src/mlpack/tests/lars_test.cpp
+++ b/src/mlpack/tests/lars_test.cpp
@@ -1244,8 +1244,7 @@ TEMPLATE_TEST_CASE("LARSSelectBetaTest", "[LARSTest]", arma::fmat, arma::mat)
 
   // Now step through numerous different lambda values.
   ElemType lastError = std::numeric_limits<ElemType>::max();
-  const ElemType errorTol = (std::is_same_v<ElemType, double>) ? 1e-8 :
-      0.05;
+  const ElemType errorTol = (std::is_same_v<ElemType, double>) ? 1e-8 : 0.05;
   for (ElemType i = 5.0; i >= -5.0; i -= 0.1)
   {
     const ElemType selLambda1 = std::pow(10.0, (ElemType) i);
diff --git a/src/mlpack/tests/main_tests/main_test_fixture.hpp b/src/mlpack/tests/main_tests/main_test_fixture.hpp
index 5c9cf94bac..1b7357513b 100644
--- a/src/mlpack/tests/main_tests/main_test_fixture.hpp
+++ b/src/mlpack/tests/main_tests/main_test_fixture.hpp
@@ -106,8 +106,7 @@ class MainTestFixture
   template<typename T>
   void SetInputParam(const std::string& name, T&& value)
   {
-    params.Get<std::remove_reference_t<T>>(name) =
-        std::forward<T>(value);
+    params.Get<std::remove_reference_t<T>>(name) = std::forward<T>(value);
     params.SetPassed(name);
   }
 
diff --git a/src/mlpack/tests/test_catch_tools.hpp b/src/mlpack/tests/test_catch_tools.hpp
index 1377b7359a..229063ab9e 100644
--- a/src/mlpack/tests/test_catch_tools.hpp
+++ b/src/mlpack/tests/test_catch_tools.hpp
@@ -55,7 +55,7 @@ template <typename MatTypeA, typename MatTypeB,
     typename = std::enable_if_t<arma::is_arma_type<MatTypeA>::value
         && arma::is_arma_type<MatTypeB>::value
         && std::is_same_v<typename MatTypeA::elem_type,
-                        typename MatTypeB::elem_type>
+                          typename MatTypeB::elem_type>
         && !std::is_integral_v<typename MatTypeA::elem_type>>>
 inline void CheckMatrices(const MatTypeA& _a,
                           const MatTypeB& _b,
@@ -137,7 +137,7 @@ template <typename CubeTypeA, typename CubeTypeB,
     typename = std::enable_if_t<arma::is_arma_cube_type<CubeTypeA>::value
         && arma::is_arma_cube_type<CubeTypeB>::value
         && std::is_same_v<typename CubeTypeA::elem_type,
-                        typename CubeTypeB::elem_type>
+                          typename CubeTypeB::elem_type>
         && !std::is_integral_v<typename CubeTypeA::elem_type>>,
     typename = void>
 inline void CheckMatrices(const CubeTypeA& _a,
diff --git a/src/mlpack/tests/ub_tree_test.cpp b/src/mlpack/tests/ub_tree_test.cpp
index 874c5bab18..baf811019d 100644
--- a/src/mlpack/tests/ub_tree_test.cpp
+++ b/src/mlpack/tests/ub_tree_test.cpp
@@ -19,9 +19,9 @@ using namespace mlpack;
 TEST_CASE("AddressTest", "[UBTreeTest]")
 {
   typedef double ElemType;
-  typedef typename std::conditional<sizeof(ElemType) * CHAR_BIT <= 32,
+  typedef std::conditional_t<sizeof(ElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>::type AddressElemType;
+                                    uint64_t> AddressElemType;
   arma::Mat<ElemType> dataset(8, 1000);
 
   dataset.randu();
@@ -46,7 +46,7 @@ void CheckSplit(const TreeType& tree)
   typedef typename TreeType::ElemType ElemType;
   typedef std::conditional_t<sizeof(ElemType) * CHAR_BIT <= 32,
                                     uint32_t,
-                                    uint64_t>AddressElemType;
+                                    uint64_t> AddressElemType;
 
   if (tree.IsLeaf())
     return;

From c9263b5615e084e084181bbc1d02d5d3a3aee4ce Mon Sep 17 00:00:00 2001
From: Omar Shrit <omar@shrit.me>
Date: Sun, 20 Oct 2024 23:21:45 +0200
Subject: [PATCH 19/24] Update src/mlpack/tests/cv_test.cpp

Co-authored-by: Ryan Curtin <ryan@ratml.org>
---
 src/mlpack/tests/cv_test.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/mlpack/tests/cv_test.cpp b/src/mlpack/tests/cv_test.cpp
index 059dd80642..f7c4f66625 100644
--- a/src/mlpack/tests/cv_test.cpp
+++ b/src/mlpack/tests/cv_test.cpp
@@ -349,8 +349,7 @@ void CheckWeightsType()
 {
   using Extractor = MetaInfoExtractor<Class, PassedMT, PassedPT, PassedWT>;
   using ActualWT = typename Extractor::WeightsType;
-  static_assert(std::is_same_v<ExpectedWT, ActualWT>,
-      "Should be the same");
+  static_assert(std::is_same_v<ExpectedWT, ActualWT>, "Should be the same");
 }
 
 /**

From 324b7dfc32d9bdd1a7d2c93fc18d2bdbf03b9bbe Mon Sep 17 00:00:00 2001
From: Martin Lambertsen <github@lambertsen.one>
Date: Mon, 21 Oct 2024 06:32:18 +0200
Subject: [PATCH 20/24] Fix line length

---
 src/mlpack/bindings/go/get_printable_param.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/mlpack/bindings/go/get_printable_param.hpp b/src/mlpack/bindings/go/get_printable_param.hpp
index 01b94df15a..2c89eb7fb7 100644
--- a/src/mlpack/bindings/go/get_printable_param.hpp
+++ b/src/mlpack/bindings/go/get_printable_param.hpp
@@ -96,8 +96,8 @@ std::string GetPrintableParam(
   const arma::mat& matrix = std::get<1>(tuple);
 
   std::ostringstream oss;
-  oss << matrix.n_rows << "x" << matrix.n_cols << " matrix with dimension type "
-      << "information";
+  oss << matrix.n_rows << "x" << matrix.n_cols
+      << " matrix with dimension type information";
   return oss.str();
 }
 

From 2e47805d5e9171cdef3ccc12b08cb5885bd20449 Mon Sep 17 00:00:00 2001
From: Martin Lambertsen <github@lambertsen.one>
Date: Mon, 21 Oct 2024 17:03:33 +0200
Subject: [PATCH 21/24] More formatting

---
 src/mlpack/core/util/sfinae_utility.hpp       |  2 +-
 .../decision_tree_regressor_impl.hpp          | 20 +++++++++----------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/mlpack/core/util/sfinae_utility.hpp b/src/mlpack/core/util/sfinae_utility.hpp
index 62b8c795f6..e9cfc7eb54 100644
--- a/src/mlpack/core/util/sfinae_utility.hpp
+++ b/src/mlpack/core/util/sfinae_utility.hpp
@@ -202,7 +202,7 @@ struct NAME                                                                   \
   template <typename Q = T>                                                   \
   static                                                                      \
   std::enable_if_t<std::is_member_function_pointer_v<decltype(&Q::FUNC)>, int>\
-  f(int) { return 1;}                                                         \
+  f(int) { return 1; }                                                        \
                                                                               \
   template <typename Q = T>                                                   \
   static char f(char) { return 0; }                                           \
diff --git a/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp b/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp
index dd950a97f8..73b226c89b 100644
--- a/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp
+++ b/src/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp
@@ -165,8 +165,8 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<
-        arma::is_arma_type<std::remove_reference_t<WeightsType>>::value>*)
-    : splitInfo()
+        arma::is_arma_type<std::remove_reference_t<WeightsType>>::value>*) :
+    splitInfo()
 {
   using TrueMatType = std::decay_t<MatType>;
   using TrueResponsesType = std::decay_t<ResponsesType>;
@@ -205,10 +205,10 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t minimumLeafSize,
     const double minimumGainSplit,
     const std::enable_if_t<arma::is_arma_type<
-        std::remove_reference_t<WeightsType>>::value>*):
-        splitInfo(std::move(other.splitInfo)),
-        NumericAuxiliarySplitInfo(other),
-        CategoricalAuxiliarySplitInfo(other)
+        std::remove_reference_t<WeightsType>>::value>*) :
+    splitInfo(std::move(other.splitInfo)),
+    NumericAuxiliarySplitInfo(other),
+    CategoricalAuxiliarySplitInfo(other)
 {
   using TrueMatType = std::decay_t<MatType>;
   using TrueResponsesType = std::decay_t<ResponsesType>;
@@ -245,10 +245,10 @@ DecisionTreeRegressor<FitnessFunction,
     const size_t maximumDepth,
     DimensionSelectionType dimensionSelector,
     const std::enable_if_t<arma::is_arma_type<
-        std::remove_reference_t<WeightsType>>::value>*)
-    : splitInfo(std::move(other.splitInfo)),
-      NumericAuxiliarySplitInfo(other),
-      CategoricalAuxiliarySplitInfo(other)   // other info does need to copy
+        std::remove_reference_t<WeightsType>>::value>*) :
+    splitInfo(std::move(other.splitInfo)),
+    NumericAuxiliarySplitInfo(other),
+    CategoricalAuxiliarySplitInfo(other)   // other info does need to copy
 {
   using TrueMatType = std::decay_t<MatType>;
   using TrueResponsesType = std::decay_t<ResponsesType>;

From 61844246907242ebb3e77007dc556c9ea80d9cfe Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Mon, 21 Oct 2024 21:29:14 -0400
Subject: [PATCH 22/24] Fix link.

---
 doc/user/core/trees/binary_space_tree.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/user/core/trees/binary_space_tree.md b/doc/user/core/trees/binary_space_tree.md
index 0d51f7cdf1..c6ce2d08ea 100644
--- a/doc/user/core/trees/binary_space_tree.md
+++ b/doc/user/core/trees/binary_space_tree.md
@@ -1680,7 +1680,7 @@ For implementation details, see
 The `VantagePointSplit` class is a splitting strategy that can be used by
 [`BinarySpaceTree`](#binaryspacetree).  It is the default strategy for splitting
 [`VPTree`s](vptree.md), and is detailed in
-[the paper](https://www.mlpack.org/paper/uhlmann91.pdf).
+[the paper](https://www.mlpack.org/papers/uhlmann91.pdf).
 Due to the nature of the split, ***`VantagePointSplit` should always be used
 with the [`HollowBallBound`](#hollowballbound)***.
 

From 8f5bf8da77f5e0232d8c5198096f8295f7ba6c98 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Tue, 22 Oct 2024 09:18:01 -0400
Subject: [PATCH 23/24] Just use the direct ACM paper link instead of
 archive.org.

---
 doc/user/core/trees/vptree.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/user/core/trees/vptree.md b/doc/user/core/trees/vptree.md
index f4f6c5e400..b0b916651d 100644
--- a/doc/user/core/trees/vptree.md
+++ b/doc/user/core/trees/vptree.md
@@ -32,7 +32,7 @@ additional functionality specific to vantage point trees.
  * [Vantage point tree on Wikipedia](https://en.wikipedia.org/wiki/Vantage-point_tree)
  * [`BinarySpaceTree`](binary_space_tree.md)
  * [Binary space partitioning on Wikipedia](https://dl.acm.org/doi/pdf/10.1145/361002.361007)
- * [Data structures and algorithms for nearest neighbor search in general metric spaces (pdf)](https://scholar.archive.org/work/og2s6vjmcngfbkmesu3dbsazpq/access/wayback/https://dl.acm.org/doi/pdf/10.5555/313559.313789)
+ * [Data structures and algorithms for nearest neighbor search in general metric spaces (pdf)](https://dl.acm.org/doi/pdf/10.5555/313559.313789)
  * [Satisfying General Proximity/Similarity Queries with Metric Trees (pdf)](https://www.mlpack.org/papers/uhlmann91.pdf)
  * [Tree-Independent Dual-Tree Algorithms (pdf)](https://www.ratml.org/pub/pdf/2013tree.pdf)
 

From 48333f91107e18eb418e877cb38b1f73cf229975 Mon Sep 17 00:00:00 2001
From: Ryan Curtin <ryan@ratml.org>
Date: Mon, 21 Oct 2024 21:31:26 -0400
Subject: [PATCH 24/24] Fix link to HMM regression PDF.

---
 doc/user/core/distributions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/user/core/distributions.md b/doc/user/core/distributions.md
index 5fcedd558c..a01057b1ab 100644
--- a/doc/user/core/distributions.md
+++ b/doc/user/core/distributions.md
@@ -849,7 +849,7 @@ regression model's prediction on `x`.
 
 This class is meant to be used with mlpack's
 [HMM](/src/mlpack/methods/hmm/hmm.hpp) class for the task of
-[HMM regression (pdf)](https://conservancy.umn.edu/bitstream/handle/11299/2532/1195.pdf).
+[HMM regression (pdf)](https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=93a56eb64e77ac83404fddfd0036e95a742fcee6).
 
 ### Constructors