Use trailing return syntax for complex types

Author: Q-Minh

source/pbat/fem/DeformationGradient.h

@@ -36,8 +36,9 @@ namespace fem {
  *
  */
 template <CElement TElement, class TDerivedx, class TDerivedX>
-Matrix<TDerivedx::RowsAtCompileTime, TElement::kDims>
-DeformationGradient(Eigen::MatrixBase<TDerivedx> const& x, Eigen::MatrixBase<TDerivedX> const& GP)
+auto DeformationGradient(
+    Eigen::MatrixBase<TDerivedx> const& x,
+    Eigen::MatrixBase<TDerivedX> const& GP) -> Matrix<TDerivedx::RowsAtCompileTime, TElement::kDims>
 {
     return x * GP;
 }
@@ -65,8 +66,8 @@ template <
     math::linalg::mini::CMatrix TMatrixGF,
     math::linalg::mini::CMatrix TMatrixGP,
     class ScalarType = typename TMatrixGF::ScalarType>
-math::linalg::mini::SVector<ScalarType, Dims>
-GradientSegmentWrtDofs(TMatrixGF const& GF, TMatrixGP const& GP, auto i)
+auto GradientSegmentWrtDofs(TMatrixGF const& GF, TMatrixGP const& GP, auto i)
+    -> math::linalg::mini::SVector<ScalarType, Dims>
 {
     using namespace math::linalg::mini;
     SVector<ScalarType, Dims> dPsidx = Zeros<ScalarType, Dims, 1>{};
@@ -123,8 +124,8 @@ template <
     math::linalg::mini::CMatrix TMatrixGF,
     math::linalg::mini::CMatrix TMatrixGP,
     class ScalarType = typename TMatrixGF::ScalarType>
-math::linalg::mini::SVector<ScalarType, TElement::kNodes * Dims>
-GradientWrtDofs(TMatrixGF const& GF, TMatrixGP const& GP)
+auto GradientWrtDofs(TMatrixGF const& GF, TMatrixGP const& GP)
+    -> math::linalg::mini::SVector<ScalarType, TElement::kNodes * Dims>
 {
     auto constexpr kRows = TElement::kNodes * Dims;
     using namespace math::linalg::mini;
@@ -166,8 +167,8 @@ template <
     math::linalg::mini::CMatrix TMatrixHF,
     math::linalg::mini::CMatrix TMatrixGP,
     class ScalarType = typename TMatrixHF::ScalarType>
-math::linalg::mini::SMatrix<ScalarType, Dims, Dims>
-HessianBlockWrtDofs(TMatrixHF const& HF, TMatrixGP const& GP, auto i, auto j)
+auto HessianBlockWrtDofs(TMatrixHF const& HF, TMatrixGP const& GP, auto i, auto j)
+    -> math::linalg::mini::SMatrix<ScalarType, Dims, Dims>
 {
     using namespace math::linalg::mini;
     SMatrix<ScalarType, Dims, Dims> d2Psidx2 = Zeros<ScalarType, Dims, Dims>{};
@@ -228,8 +229,8 @@ template <
     math::linalg::mini::CMatrix TMatrixHF,
     math::linalg::mini::CMatrix TMatrixGP,
     class ScalarType = typename TMatrixHF::ScalarType>
-math::linalg::mini::SMatrix<ScalarType, TElement::kNodes * Dims, TElement::kNodes * Dims>
-HessianWrtDofs(TMatrixHF const& HF, TMatrixGP const& GP)
+auto HessianWrtDofs(TMatrixHF const& HF, TMatrixGP const& GP)
+    -> math::linalg::mini::SMatrix<ScalarType, TElement::kNodes * Dims, TElement::kNodes * Dims>
 {
     auto constexpr kRows = TElement::kNodes * Dims;
     auto constexpr kCols = TElement::kNodes * Dims;

source/pbat/fem/Jacobian.h

@@ -38,8 +38,9 @@ namespace fem {
  * @return Matrix<TDerived::RowsAtCompileTime, TElement::kDims>
  */
 template <CElement TElement, class TDerived>
-[[maybe_unused]] Matrix<TDerived::RowsAtCompileTime, TElement::kDims>
+[[maybe_unused]] auto
 Jacobian(Vector<TElement::kDims> const& X, Eigen::MatrixBase<TDerived> const& x)
+    -> Matrix<TDerived::RowsAtCompileTime, TElement::kDims>
 {
     assert(x.cols() == TElement::kNodes);
     auto constexpr kDimsOut                   = TDerived::RowsAtCompileTime;
@@ -188,7 +189,7 @@ MatrixX InnerProductWeights(TMesh const& mesh, Eigen::MatrixBase<TDerivedDetJe>
  * the element whose vertices are \f$ x \f$.
  *
  * We use Gauss-Newton iterations on \f$ \min f \f$.
- * This gives the iteration 
+ * This gives the iteration
  * \f[
  * dx^{k+1} = [H(\xi^k)]^{-1} J_x(\xi^k)^T (x(\xi^k) - X)
  * \f]

source/pbat/fem/ShapeFunctions.h

@@ -36,8 +36,8 @@ namespace fem {
  * of dimensions |# element nodes| x |# quad.pts.|
  */
 template <CElement TElement, int QuadratureOrder>
-Matrix<TElement::kNodes, TElement::template QuadratureType<QuadratureOrder>::kPoints>
-ShapeFunctions()
+auto ShapeFunctions()
+    -> Matrix<TElement::kNodes, TElement::template QuadratureType<QuadratureOrder>::kPoints>
 {
     using QuadratureRuleType = typename TElement::template QuadratureType<QuadratureOrder>;
     using ElementType        = TElement;
@@ -275,15 +275,15 @@ MatrixX IntegratedShapeFunctions(TMesh const& mesh, Eigen::DenseBase<TDerived> c
  * \f{eqnarray*}{
  * \xi &= J^{-1} (X - X_0) \\
  * \nabla_X N(\xi(X)) &= \nabla_\xi N * J^{-1} \\
- * \nabla_X \phi^T  &= J^{-T} \left[ \nabla_\xi N \right]^T 
+ * \nabla_X \phi^T  &= J^{-T} \left[ \nabla_\xi N \right]^T
  * \f}
  * @note
  * If J is rectangular, then
  * \f{eqnarray*}{
  * (J^T J) \xi      &= J^T (X - X_0) \\
  * \xi              &= (J^T J)^{-1} J^T (X - X_0) \\
  * \nabla_X N(\xi(X)) &= \nabla_\xi N * (J^T J)^{-1} J^T \\
- * \left[ \nabla_X \phi \right]^T  &= J (J^T J)^{-1} \left[ \nabla_\xi N \right]^T 
+ * \left[ \nabla_X \phi \right]^T  &= J (J^T J)^{-1} \left[ \nabla_\xi N \right]^T
  * \f}
  * @note
  * For non-linear elements, like hexahedra or quadrilaterals, the accuracy of the gradients
@@ -299,9 +299,9 @@ MatrixX IntegratedShapeFunctions(TMesh const& mesh, Eigen::DenseBase<TDerived> c
  * @return |# nodes|x|Dims| matrix of basis function gradients in rows
  */
 template <CElement TElement, class TDerivedXi, class TDerivedX>
-Matrix<TElement::kNodes, TDerivedX::RowsAtCompileTime> ShapeFunctionGradients(
+auto ShapeFunctionGradients(
     Eigen::MatrixBase<TDerivedXi> const& Xi,
-    Eigen::MatrixBase<TDerivedX> const& X)
+    Eigen::MatrixBase<TDerivedX> const& X) -> Matrix<TElement::kNodes, TDerivedX::RowsAtCompileTime>
 {
     auto constexpr kInputDims           = TElement::kDims;
     auto constexpr kOutputDims          = TDerivedX::RowsAtCompileTime;