pymomentum-cpu 0.1.93.post0__cp312-cp312-macosx_14_0_arm64.whl

include/momentum/character_solver/fwd.h

@@ -0,0 +1,943 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// This file is @generated by gen_fwd.py
+// Do not edit this file directly, instead update gen_fwd_input.toml and run:
+// buck run @arvr/mode/platform010/opt //arvr/libraries/momentum:gen_fwd
+
+#pragma once
+
+#include <memory>
+
+namespace momentum {
+
+struct ConstraintData;
+
+using ConstraintData_p = ::std::shared_ptr<ConstraintData>;
+using ConstraintData_u = ::std::unique_ptr<ConstraintData>;
+using ConstraintData_w = ::std::weak_ptr<ConstraintData>;
+using ConstraintData_const_p = ::std::shared_ptr<const ConstraintData>;
+using ConstraintData_const_u = ::std::unique_ptr<const ConstraintData>;
+using ConstraintData_const_w = ::std::weak_ptr<const ConstraintData>;
+
+struct GaussNewtonSolverQROptions;
+
+using GaussNewtonSolverQROptions_p = ::std::shared_ptr<GaussNewtonSolverQROptions>;
+using GaussNewtonSolverQROptions_u = ::std::unique_ptr<GaussNewtonSolverQROptions>;
+using GaussNewtonSolverQROptions_w = ::std::weak_ptr<GaussNewtonSolverQROptions>;
+using GaussNewtonSolverQROptions_const_p = ::std::shared_ptr<const GaussNewtonSolverQROptions>;
+using GaussNewtonSolverQROptions_const_u = ::std::unique_ptr<const GaussNewtonSolverQROptions>;
+using GaussNewtonSolverQROptions_const_w = ::std::weak_ptr<const GaussNewtonSolverQROptions>;
+
+struct SimdNormalConstraints;
+
+using SimdNormalConstraints_p = ::std::shared_ptr<SimdNormalConstraints>;
+using SimdNormalConstraints_u = ::std::unique_ptr<SimdNormalConstraints>;
+using SimdNormalConstraints_w = ::std::weak_ptr<SimdNormalConstraints>;
+using SimdNormalConstraints_const_p = ::std::shared_ptr<const SimdNormalConstraints>;
+using SimdNormalConstraints_const_u = ::std::unique_ptr<const SimdNormalConstraints>;
+using SimdNormalConstraints_const_w = ::std::weak_ptr<const SimdNormalConstraints>;
+
+struct SimdPlaneConstraints;
+
+using SimdPlaneConstraints_p = ::std::shared_ptr<SimdPlaneConstraints>;
+using SimdPlaneConstraints_u = ::std::unique_ptr<SimdPlaneConstraints>;
+using SimdPlaneConstraints_w = ::std::weak_ptr<SimdPlaneConstraints>;
+using SimdPlaneConstraints_const_p = ::std::shared_ptr<const SimdPlaneConstraints>;
+using SimdPlaneConstraints_const_u = ::std::unique_ptr<const SimdPlaneConstraints>;
+using SimdPlaneConstraints_const_w = ::std::weak_ptr<const SimdPlaneConstraints>;
+
+struct SimdPositionConstraints;
+
+using SimdPositionConstraints_p = ::std::shared_ptr<SimdPositionConstraints>;
+using SimdPositionConstraints_u = ::std::unique_ptr<SimdPositionConstraints>;
+using SimdPositionConstraints_w = ::std::weak_ptr<SimdPositionConstraints>;
+using SimdPositionConstraints_const_p = ::std::shared_ptr<const SimdPositionConstraints>;
+using SimdPositionConstraints_const_u = ::std::unique_ptr<const SimdPositionConstraints>;
+using SimdPositionConstraints_const_w = ::std::weak_ptr<const SimdPositionConstraints>;
+
+template <typename T>
+struct AimDataT;
+using AimData = AimDataT<float>;
+using AimDatad = AimDataT<double>;
+
+using AimData_p = ::std::shared_ptr<AimData>;
+using AimData_u = ::std::unique_ptr<AimData>;
+using AimData_w = ::std::weak_ptr<AimData>;
+using AimData_const_p = ::std::shared_ptr<const AimData>;
+using AimData_const_u = ::std::unique_ptr<const AimData>;
+using AimData_const_w = ::std::weak_ptr<const AimData>;
+
+using AimDatad_p = ::std::shared_ptr<AimDatad>;
+using AimDatad_u = ::std::unique_ptr<AimDatad>;
+using AimDatad_w = ::std::weak_ptr<AimDatad>;
+using AimDatad_const_p = ::std::shared_ptr<const AimDatad>;
+using AimDatad_const_u = ::std::unique_ptr<const AimDatad>;
+using AimDatad_const_w = ::std::weak_ptr<const AimDatad>;
+
+template <typename T>
+struct FixedAxisDataT;
+using FixedAxisData = FixedAxisDataT<float>;
+using FixedAxisDatad = FixedAxisDataT<double>;
+
+using FixedAxisData_p = ::std::shared_ptr<FixedAxisData>;
+using FixedAxisData_u = ::std::unique_ptr<FixedAxisData>;
+using FixedAxisData_w = ::std::weak_ptr<FixedAxisData>;
+using FixedAxisData_const_p = ::std::shared_ptr<const FixedAxisData>;
+using FixedAxisData_const_u = ::std::unique_ptr<const FixedAxisData>;
+using FixedAxisData_const_w = ::std::weak_ptr<const FixedAxisData>;
+
+using FixedAxisDatad_p = ::std::shared_ptr<FixedAxisDatad>;
+using FixedAxisDatad_u = ::std::unique_ptr<FixedAxisDatad>;
+using FixedAxisDatad_w = ::std::weak_ptr<FixedAxisDatad>;
+using FixedAxisDatad_const_p = ::std::shared_ptr<const FixedAxisDatad>;
+using FixedAxisDatad_const_u = ::std::unique_ptr<const FixedAxisDatad>;
+using FixedAxisDatad_const_w = ::std::weak_ptr<const FixedAxisDatad>;
+
+template <typename T>
+struct NormalDataT;
+using NormalData = NormalDataT<float>;
+using NormalDatad = NormalDataT<double>;
+
+using NormalData_p = ::std::shared_ptr<NormalData>;
+using NormalData_u = ::std::unique_ptr<NormalData>;
+using NormalData_w = ::std::weak_ptr<NormalData>;
+using NormalData_const_p = ::std::shared_ptr<const NormalData>;
+using NormalData_const_u = ::std::unique_ptr<const NormalData>;
+using NormalData_const_w = ::std::weak_ptr<const NormalData>;
+
+using NormalDatad_p = ::std::shared_ptr<NormalDatad>;
+using NormalDatad_u = ::std::unique_ptr<NormalDatad>;
+using NormalDatad_w = ::std::weak_ptr<NormalDatad>;
+using NormalDatad_const_p = ::std::shared_ptr<const NormalDatad>;
+using NormalDatad_const_u = ::std::unique_ptr<const NormalDatad>;
+using NormalDatad_const_w = ::std::weak_ptr<const NormalDatad>;
+
+template <typename T>
+struct OrientationDataT;
+using OrientationData = OrientationDataT<float>;
+using OrientationDatad = OrientationDataT<double>;
+
+using OrientationData_p = ::std::shared_ptr<OrientationData>;
+using OrientationData_u = ::std::unique_ptr<OrientationData>;
+using OrientationData_w = ::std::weak_ptr<OrientationData>;
+using OrientationData_const_p = ::std::shared_ptr<const OrientationData>;
+using OrientationData_const_u = ::std::unique_ptr<const OrientationData>;
+using OrientationData_const_w = ::std::weak_ptr<const OrientationData>;
+
+using OrientationDatad_p = ::std::shared_ptr<OrientationDatad>;
+using OrientationDatad_u = ::std::unique_ptr<OrientationDatad>;
+using OrientationDatad_w = ::std::weak_ptr<OrientationDatad>;
+using OrientationDatad_const_p = ::std::shared_ptr<const OrientationDatad>;
+using OrientationDatad_const_u = ::std::unique_ptr<const OrientationDatad>;
+using OrientationDatad_const_w = ::std::weak_ptr<const OrientationDatad>;
+
+template <typename T>
+struct PointTriangleVertexConstraintT;
+using PointTriangleVertexConstraint = PointTriangleVertexConstraintT<float>;
+using PointTriangleVertexConstraintd = PointTriangleVertexConstraintT<double>;
+
+using PointTriangleVertexConstraint_p = ::std::shared_ptr<PointTriangleVertexConstraint>;
+using PointTriangleVertexConstraint_u = ::std::unique_ptr<PointTriangleVertexConstraint>;
+using PointTriangleVertexConstraint_w = ::std::weak_ptr<PointTriangleVertexConstraint>;
+using PointTriangleVertexConstraint_const_p =
+    ::std::shared_ptr<const PointTriangleVertexConstraint>;
+using PointTriangleVertexConstraint_const_u =
+    ::std::unique_ptr<const PointTriangleVertexConstraint>;
+using PointTriangleVertexConstraint_const_w = ::std::weak_ptr<const PointTriangleVertexConstraint>;
+
+using PointTriangleVertexConstraintd_p = ::std::shared_ptr<PointTriangleVertexConstraintd>;
+using PointTriangleVertexConstraintd_u = ::std::unique_ptr<PointTriangleVertexConstraintd>;
+using PointTriangleVertexConstraintd_w = ::std::weak_ptr<PointTriangleVertexConstraintd>;
+using PointTriangleVertexConstraintd_const_p =
+    ::std::shared_ptr<const PointTriangleVertexConstraintd>;
+using PointTriangleVertexConstraintd_const_u =
+    ::std::unique_ptr<const PointTriangleVertexConstraintd>;
+using PointTriangleVertexConstraintd_const_w =
+    ::std::weak_ptr<const PointTriangleVertexConstraintd>;
+
+template <typename T>
+struct PlaneDataT;
+using PlaneData = PlaneDataT<float>;
+using PlaneDatad = PlaneDataT<double>;
+
+using PlaneData_p = ::std::shared_ptr<PlaneData>;
+using PlaneData_u = ::std::unique_ptr<PlaneData>;
+using PlaneData_w = ::std::weak_ptr<PlaneData>;
+using PlaneData_const_p = ::std::shared_ptr<const PlaneData>;
+using PlaneData_const_u = ::std::unique_ptr<const PlaneData>;
+using PlaneData_const_w = ::std::weak_ptr<const PlaneData>;
+
+using PlaneDatad_p = ::std::shared_ptr<PlaneDatad>;
+using PlaneDatad_u = ::std::unique_ptr<PlaneDatad>;
+using PlaneDatad_w = ::std::weak_ptr<PlaneDatad>;
+using PlaneDatad_const_p = ::std::shared_ptr<const PlaneDatad>;
+using PlaneDatad_const_u = ::std::unique_ptr<const PlaneDatad>;
+using PlaneDatad_const_w = ::std::weak_ptr<const PlaneDatad>;
+
+template <typename T>
+struct PositionDataT;
+using PositionData = PositionDataT<float>;
+using PositionDatad = PositionDataT<double>;
+
+using PositionData_p = ::std::shared_ptr<PositionData>;
+using PositionData_u = ::std::unique_ptr<PositionData>;
+using PositionData_w = ::std::weak_ptr<PositionData>;
+using PositionData_const_p = ::std::shared_ptr<const PositionData>;
+using PositionData_const_u = ::std::unique_ptr<const PositionData>;
+using PositionData_const_w = ::std::weak_ptr<const PositionData>;
+
+using PositionDatad_p = ::std::shared_ptr<PositionDatad>;
+using PositionDatad_u = ::std::unique_ptr<PositionDatad>;
+using PositionDatad_w = ::std::weak_ptr<PositionDatad>;
+using PositionDatad_const_p = ::std::shared_ptr<const PositionDatad>;
+using PositionDatad_const_u = ::std::unique_ptr<const PositionDatad>;
+using PositionDatad_const_w = ::std::weak_ptr<const PositionDatad>;
+
+template <typename T>
+struct SkinnedLocatorConstraintT;
+using SkinnedLocatorConstraint = SkinnedLocatorConstraintT<float>;
+using SkinnedLocatorConstraintd = SkinnedLocatorConstraintT<double>;
+
+using SkinnedLocatorConstraint_p = ::std::shared_ptr<SkinnedLocatorConstraint>;
+using SkinnedLocatorConstraint_u = ::std::unique_ptr<SkinnedLocatorConstraint>;
+using SkinnedLocatorConstraint_w = ::std::weak_ptr<SkinnedLocatorConstraint>;
+using SkinnedLocatorConstraint_const_p = ::std::shared_ptr<const SkinnedLocatorConstraint>;
+using SkinnedLocatorConstraint_const_u = ::std::unique_ptr<const SkinnedLocatorConstraint>;
+using SkinnedLocatorConstraint_const_w = ::std::weak_ptr<const SkinnedLocatorConstraint>;
+
+using SkinnedLocatorConstraintd_p = ::std::shared_ptr<SkinnedLocatorConstraintd>;
+using SkinnedLocatorConstraintd_u = ::std::unique_ptr<SkinnedLocatorConstraintd>;
+using SkinnedLocatorConstraintd_w = ::std::weak_ptr<SkinnedLocatorConstraintd>;
+using SkinnedLocatorConstraintd_const_p = ::std::shared_ptr<const SkinnedLocatorConstraintd>;
+using SkinnedLocatorConstraintd_const_u = ::std::unique_ptr<const SkinnedLocatorConstraintd>;
+using SkinnedLocatorConstraintd_const_w = ::std::weak_ptr<const SkinnedLocatorConstraintd>;
+
+template <typename T>
+struct SkinnedLocatorTriangleConstraintT;
+using SkinnedLocatorTriangleConstraint = SkinnedLocatorTriangleConstraintT<float>;
+using SkinnedLocatorTriangleConstraintd = SkinnedLocatorTriangleConstraintT<double>;
+
+using SkinnedLocatorTriangleConstraint_p = ::std::shared_ptr<SkinnedLocatorTriangleConstraint>;
+using SkinnedLocatorTriangleConstraint_u = ::std::unique_ptr<SkinnedLocatorTriangleConstraint>;
+using SkinnedLocatorTriangleConstraint_w = ::std::weak_ptr<SkinnedLocatorTriangleConstraint>;
+using SkinnedLocatorTriangleConstraint_const_p =
+    ::std::shared_ptr<const SkinnedLocatorTriangleConstraint>;
+using SkinnedLocatorTriangleConstraint_const_u =
+    ::std::unique_ptr<const SkinnedLocatorTriangleConstraint>;
+using SkinnedLocatorTriangleConstraint_const_w =
+    ::std::weak_ptr<const SkinnedLocatorTriangleConstraint>;
+
+using SkinnedLocatorTriangleConstraintd_p = ::std::shared_ptr<SkinnedLocatorTriangleConstraintd>;
+using SkinnedLocatorTriangleConstraintd_u = ::std::unique_ptr<SkinnedLocatorTriangleConstraintd>;
+using SkinnedLocatorTriangleConstraintd_w = ::std::weak_ptr<SkinnedLocatorTriangleConstraintd>;
+using SkinnedLocatorTriangleConstraintd_const_p =
+    ::std::shared_ptr<const SkinnedLocatorTriangleConstraintd>;
+using SkinnedLocatorTriangleConstraintd_const_u =
+    ::std::unique_ptr<const SkinnedLocatorTriangleConstraintd>;
+using SkinnedLocatorTriangleConstraintd_const_w =
+    ::std::weak_ptr<const SkinnedLocatorTriangleConstraintd>;
+
+template <typename T>
+struct VertexConstraintT;
+using VertexConstraint = VertexConstraintT<float>;
+using VertexConstraintd = VertexConstraintT<double>;
+
+using VertexConstraint_p = ::std::shared_ptr<VertexConstraint>;
+using VertexConstraint_u = ::std::unique_ptr<VertexConstraint>;
+using VertexConstraint_w = ::std::weak_ptr<VertexConstraint>;
+using VertexConstraint_const_p = ::std::shared_ptr<const VertexConstraint>;
+using VertexConstraint_const_u = ::std::unique_ptr<const VertexConstraint>;
+using VertexConstraint_const_w = ::std::weak_ptr<const VertexConstraint>;
+
+using VertexConstraintd_p = ::std::shared_ptr<VertexConstraintd>;
+using VertexConstraintd_u = ::std::unique_ptr<VertexConstraintd>;
+using VertexConstraintd_w = ::std::weak_ptr<VertexConstraintd>;
+using VertexConstraintd_const_p = ::std::shared_ptr<const VertexConstraintd>;
+using VertexConstraintd_const_u = ::std::unique_ptr<const VertexConstraintd>;
+using VertexConstraintd_const_w = ::std::weak_ptr<const VertexConstraintd>;
+
+template <typename T>
+struct VertexProjectionConstraintT;
+using VertexProjectionConstraint = VertexProjectionConstraintT<float>;
+using VertexProjectionConstraintd = VertexProjectionConstraintT<double>;
+
+using VertexProjectionConstraint_p = ::std::shared_ptr<VertexProjectionConstraint>;
+using VertexProjectionConstraint_u = ::std::unique_ptr<VertexProjectionConstraint>;
+using VertexProjectionConstraint_w = ::std::weak_ptr<VertexProjectionConstraint>;
+using VertexProjectionConstraint_const_p = ::std::shared_ptr<const VertexProjectionConstraint>;
+using VertexProjectionConstraint_const_u = ::std::unique_ptr<const VertexProjectionConstraint>;
+using VertexProjectionConstraint_const_w = ::std::weak_ptr<const VertexProjectionConstraint>;
+
+using VertexProjectionConstraintd_p = ::std::shared_ptr<VertexProjectionConstraintd>;
+using VertexProjectionConstraintd_u = ::std::unique_ptr<VertexProjectionConstraintd>;
+using VertexProjectionConstraintd_w = ::std::weak_ptr<VertexProjectionConstraintd>;
+using VertexProjectionConstraintd_const_p = ::std::shared_ptr<const VertexProjectionConstraintd>;
+using VertexProjectionConstraintd_const_u = ::std::unique_ptr<const VertexProjectionConstraintd>;
+using VertexProjectionConstraintd_const_w = ::std::weak_ptr<const VertexProjectionConstraintd>;
+
+class SimdNormalErrorFunction;
+
+using SimdNormalErrorFunction_p = ::std::shared_ptr<SimdNormalErrorFunction>;
+using SimdNormalErrorFunction_u = ::std::unique_ptr<SimdNormalErrorFunction>;
+using SimdNormalErrorFunction_w = ::std::weak_ptr<SimdNormalErrorFunction>;
+using SimdNormalErrorFunction_const_p = ::std::shared_ptr<const SimdNormalErrorFunction>;
+using SimdNormalErrorFunction_const_u = ::std::unique_ptr<const SimdNormalErrorFunction>;
+using SimdNormalErrorFunction_const_w = ::std::weak_ptr<const SimdNormalErrorFunction>;
+
+class SimdPlaneErrorFunction;
+
+using SimdPlaneErrorFunction_p = ::std::shared_ptr<SimdPlaneErrorFunction>;
+using SimdPlaneErrorFunction_u = ::std::unique_ptr<SimdPlaneErrorFunction>;
+using SimdPlaneErrorFunction_w = ::std::weak_ptr<SimdPlaneErrorFunction>;
+using SimdPlaneErrorFunction_const_p = ::std::shared_ptr<const SimdPlaneErrorFunction>;
+using SimdPlaneErrorFunction_const_u = ::std::unique_ptr<const SimdPlaneErrorFunction>;
+using SimdPlaneErrorFunction_const_w = ::std::weak_ptr<const SimdPlaneErrorFunction>;
+
+class SimdPositionErrorFunction;
+
+using SimdPositionErrorFunction_p = ::std::shared_ptr<SimdPositionErrorFunction>;
+using SimdPositionErrorFunction_u = ::std::unique_ptr<SimdPositionErrorFunction>;
+using SimdPositionErrorFunction_w = ::std::weak_ptr<SimdPositionErrorFunction>;
+using SimdPositionErrorFunction_const_p = ::std::shared_ptr<const SimdPositionErrorFunction>;
+using SimdPositionErrorFunction_const_u = ::std::unique_ptr<const SimdPositionErrorFunction>;
+using SimdPositionErrorFunction_const_w = ::std::weak_ptr<const SimdPositionErrorFunction>;
+
+class SimdNormalErrorFunctionAVX;
+
+using SimdNormalErrorFunctionAVX_p = ::std::shared_ptr<SimdNormalErrorFunctionAVX>;
+using SimdNormalErrorFunctionAVX_u = ::std::unique_ptr<SimdNormalErrorFunctionAVX>;
+using SimdNormalErrorFunctionAVX_w = ::std::weak_ptr<SimdNormalErrorFunctionAVX>;
+using SimdNormalErrorFunctionAVX_const_p = ::std::shared_ptr<const SimdNormalErrorFunctionAVX>;
+using SimdNormalErrorFunctionAVX_const_u = ::std::unique_ptr<const SimdNormalErrorFunctionAVX>;
+using SimdNormalErrorFunctionAVX_const_w = ::std::weak_ptr<const SimdNormalErrorFunctionAVX>;
+
+class SimdPlaneErrorFunctionAVX;
+
+using SimdPlaneErrorFunctionAVX_p = ::std::shared_ptr<SimdPlaneErrorFunctionAVX>;
+using SimdPlaneErrorFunctionAVX_u = ::std::unique_ptr<SimdPlaneErrorFunctionAVX>;
+using SimdPlaneErrorFunctionAVX_w = ::std::weak_ptr<SimdPlaneErrorFunctionAVX>;
+using SimdPlaneErrorFunctionAVX_const_p = ::std::shared_ptr<const SimdPlaneErrorFunctionAVX>;
+using SimdPlaneErrorFunctionAVX_const_u = ::std::unique_ptr<const SimdPlaneErrorFunctionAVX>;
+using SimdPlaneErrorFunctionAVX_const_w = ::std::weak_ptr<const SimdPlaneErrorFunctionAVX>;
+
+class SimdPositionErrorFunctionAVX;
+
+using SimdPositionErrorFunctionAVX_p = ::std::shared_ptr<SimdPositionErrorFunctionAVX>;
+using SimdPositionErrorFunctionAVX_u = ::std::unique_ptr<SimdPositionErrorFunctionAVX>;
+using SimdPositionErrorFunctionAVX_w = ::std::weak_ptr<SimdPositionErrorFunctionAVX>;
+using SimdPositionErrorFunctionAVX_const_p = ::std::shared_ptr<const SimdPositionErrorFunctionAVX>;
+using SimdPositionErrorFunctionAVX_const_u = ::std::unique_ptr<const SimdPositionErrorFunctionAVX>;
+using SimdPositionErrorFunctionAVX_const_w = ::std::weak_ptr<const SimdPositionErrorFunctionAVX>;
+
+template <typename T>
+class AimDirErrorFunctionT;
+using AimDirErrorFunction = AimDirErrorFunctionT<float>;
+using AimDirErrorFunctiond = AimDirErrorFunctionT<double>;
+
+using AimDirErrorFunction_p = ::std::shared_ptr<AimDirErrorFunction>;
+using AimDirErrorFunction_u = ::std::unique_ptr<AimDirErrorFunction>;
+using AimDirErrorFunction_w = ::std::weak_ptr<AimDirErrorFunction>;
+using AimDirErrorFunction_const_p = ::std::shared_ptr<const AimDirErrorFunction>;
+using AimDirErrorFunction_const_u = ::std::unique_ptr<const AimDirErrorFunction>;
+using AimDirErrorFunction_const_w = ::std::weak_ptr<const AimDirErrorFunction>;
+
+using AimDirErrorFunctiond_p = ::std::shared_ptr<AimDirErrorFunctiond>;
+using AimDirErrorFunctiond_u = ::std::unique_ptr<AimDirErrorFunctiond>;
+using AimDirErrorFunctiond_w = ::std::weak_ptr<AimDirErrorFunctiond>;
+using AimDirErrorFunctiond_const_p = ::std::shared_ptr<const AimDirErrorFunctiond>;
+using AimDirErrorFunctiond_const_u = ::std::unique_ptr<const AimDirErrorFunctiond>;
+using AimDirErrorFunctiond_const_w = ::std::weak_ptr<const AimDirErrorFunctiond>;
+
+template <typename T>
+class AimDistErrorFunctionT;
+using AimDistErrorFunction = AimDistErrorFunctionT<float>;
+using AimDistErrorFunctiond = AimDistErrorFunctionT<double>;
+
+using AimDistErrorFunction_p = ::std::shared_ptr<AimDistErrorFunction>;
+using AimDistErrorFunction_u = ::std::unique_ptr<AimDistErrorFunction>;
+using AimDistErrorFunction_w = ::std::weak_ptr<AimDistErrorFunction>;
+using AimDistErrorFunction_const_p = ::std::shared_ptr<const AimDistErrorFunction>;
+using AimDistErrorFunction_const_u = ::std::unique_ptr<const AimDistErrorFunction>;
+using AimDistErrorFunction_const_w = ::std::weak_ptr<const AimDistErrorFunction>;
+
+using AimDistErrorFunctiond_p = ::std::shared_ptr<AimDistErrorFunctiond>;
+using AimDistErrorFunctiond_u = ::std::unique_ptr<AimDistErrorFunctiond>;
+using AimDistErrorFunctiond_w = ::std::weak_ptr<AimDistErrorFunctiond>;
+using AimDistErrorFunctiond_const_p = ::std::shared_ptr<const AimDistErrorFunctiond>;
+using AimDistErrorFunctiond_const_u = ::std::unique_ptr<const AimDistErrorFunctiond>;
+using AimDistErrorFunctiond_const_w = ::std::weak_ptr<const AimDistErrorFunctiond>;
+
+template <typename T>
+class CollisionErrorFunctionT;
+using CollisionErrorFunction = CollisionErrorFunctionT<float>;
+using CollisionErrorFunctiond = CollisionErrorFunctionT<double>;
+
+using CollisionErrorFunction_p = ::std::shared_ptr<CollisionErrorFunction>;
+using CollisionErrorFunction_u = ::std::unique_ptr<CollisionErrorFunction>;
+using CollisionErrorFunction_w = ::std::weak_ptr<CollisionErrorFunction>;
+using CollisionErrorFunction_const_p = ::std::shared_ptr<const CollisionErrorFunction>;
+using CollisionErrorFunction_const_u = ::std::unique_ptr<const CollisionErrorFunction>;
+using CollisionErrorFunction_const_w = ::std::weak_ptr<const CollisionErrorFunction>;
+
+using CollisionErrorFunctiond_p = ::std::shared_ptr<CollisionErrorFunctiond>;
+using CollisionErrorFunctiond_u = ::std::unique_ptr<CollisionErrorFunctiond>;
+using CollisionErrorFunctiond_w = ::std::weak_ptr<CollisionErrorFunctiond>;
+using CollisionErrorFunctiond_const_p = ::std::shared_ptr<const CollisionErrorFunctiond>;
+using CollisionErrorFunctiond_const_u = ::std::unique_ptr<const CollisionErrorFunctiond>;
+using CollisionErrorFunctiond_const_w = ::std::weak_ptr<const CollisionErrorFunctiond>;
+
+template <typename T>
+class CollisionErrorFunctionStatelessT;
+using CollisionErrorFunctionStateless = CollisionErrorFunctionStatelessT<float>;
+using CollisionErrorFunctionStatelessd = CollisionErrorFunctionStatelessT<double>;
+
+using CollisionErrorFunctionStateless_p = ::std::shared_ptr<CollisionErrorFunctionStateless>;
+using CollisionErrorFunctionStateless_u = ::std::unique_ptr<CollisionErrorFunctionStateless>;
+using CollisionErrorFunctionStateless_w = ::std::weak_ptr<CollisionErrorFunctionStateless>;
+using CollisionErrorFunctionStateless_const_p =
+    ::std::shared_ptr<const CollisionErrorFunctionStateless>;
+using CollisionErrorFunctionStateless_const_u =
+    ::std::unique_ptr<const CollisionErrorFunctionStateless>;
+using CollisionErrorFunctionStateless_const_w =
+    ::std::weak_ptr<const CollisionErrorFunctionStateless>;
+
+using CollisionErrorFunctionStatelessd_p = ::std::shared_ptr<CollisionErrorFunctionStatelessd>;
+using CollisionErrorFunctionStatelessd_u = ::std::unique_ptr<CollisionErrorFunctionStatelessd>;
+using CollisionErrorFunctionStatelessd_w = ::std::weak_ptr<CollisionErrorFunctionStatelessd>;
+using CollisionErrorFunctionStatelessd_const_p =
+    ::std::shared_ptr<const CollisionErrorFunctionStatelessd>;
+using CollisionErrorFunctionStatelessd_const_u =
+    ::std::unique_ptr<const CollisionErrorFunctionStatelessd>;
+using CollisionErrorFunctionStatelessd_const_w =
+    ::std::weak_ptr<const CollisionErrorFunctionStatelessd>;
+
+template <typename T>
+class DistanceErrorFunctionT;
+using DistanceErrorFunction = DistanceErrorFunctionT<float>;
+using DistanceErrorFunctiond = DistanceErrorFunctionT<double>;
+
+using DistanceErrorFunction_p = ::std::shared_ptr<DistanceErrorFunction>;
+using DistanceErrorFunction_u = ::std::unique_ptr<DistanceErrorFunction>;
+using DistanceErrorFunction_w = ::std::weak_ptr<DistanceErrorFunction>;
+using DistanceErrorFunction_const_p = ::std::shared_ptr<const DistanceErrorFunction>;
+using DistanceErrorFunction_const_u = ::std::unique_ptr<const DistanceErrorFunction>;
+using DistanceErrorFunction_const_w = ::std::weak_ptr<const DistanceErrorFunction>;
+
+using DistanceErrorFunctiond_p = ::std::shared_ptr<DistanceErrorFunctiond>;
+using DistanceErrorFunctiond_u = ::std::unique_ptr<DistanceErrorFunctiond>;
+using DistanceErrorFunctiond_w = ::std::weak_ptr<DistanceErrorFunctiond>;
+using DistanceErrorFunctiond_const_p = ::std::shared_ptr<const DistanceErrorFunctiond>;
+using DistanceErrorFunctiond_const_u = ::std::unique_ptr<const DistanceErrorFunctiond>;
+using DistanceErrorFunctiond_const_w = ::std::weak_ptr<const DistanceErrorFunctiond>;
+
+template <typename T>
+class FixedAxisAngleErrorFunctionT;
+using FixedAxisAngleErrorFunction = FixedAxisAngleErrorFunctionT<float>;
+using FixedAxisAngleErrorFunctiond = FixedAxisAngleErrorFunctionT<double>;
+
+using FixedAxisAngleErrorFunction_p = ::std::shared_ptr<FixedAxisAngleErrorFunction>;
+using FixedAxisAngleErrorFunction_u = ::std::unique_ptr<FixedAxisAngleErrorFunction>;
+using FixedAxisAngleErrorFunction_w = ::std::weak_ptr<FixedAxisAngleErrorFunction>;
+using FixedAxisAngleErrorFunction_const_p = ::std::shared_ptr<const FixedAxisAngleErrorFunction>;
+using FixedAxisAngleErrorFunction_const_u = ::std::unique_ptr<const FixedAxisAngleErrorFunction>;
+using FixedAxisAngleErrorFunction_const_w = ::std::weak_ptr<const FixedAxisAngleErrorFunction>;
+
+using FixedAxisAngleErrorFunctiond_p = ::std::shared_ptr<FixedAxisAngleErrorFunctiond>;
+using FixedAxisAngleErrorFunctiond_u = ::std::unique_ptr<FixedAxisAngleErrorFunctiond>;
+using FixedAxisAngleErrorFunctiond_w = ::std::weak_ptr<FixedAxisAngleErrorFunctiond>;
+using FixedAxisAngleErrorFunctiond_const_p = ::std::shared_ptr<const FixedAxisAngleErrorFunctiond>;
+using FixedAxisAngleErrorFunctiond_const_u = ::std::unique_ptr<const FixedAxisAngleErrorFunctiond>;
+using FixedAxisAngleErrorFunctiond_const_w = ::std::weak_ptr<const FixedAxisAngleErrorFunctiond>;
+
+template <typename T>
+class FixedAxisCosErrorFunctionT;
+using FixedAxisCosErrorFunction = FixedAxisCosErrorFunctionT<float>;
+using FixedAxisCosErrorFunctiond = FixedAxisCosErrorFunctionT<double>;
+
+using FixedAxisCosErrorFunction_p = ::std::shared_ptr<FixedAxisCosErrorFunction>;
+using FixedAxisCosErrorFunction_u = ::std::unique_ptr<FixedAxisCosErrorFunction>;
+using FixedAxisCosErrorFunction_w = ::std::weak_ptr<FixedAxisCosErrorFunction>;
+using FixedAxisCosErrorFunction_const_p = ::std::shared_ptr<const FixedAxisCosErrorFunction>;
+using FixedAxisCosErrorFunction_const_u = ::std::unique_ptr<const FixedAxisCosErrorFunction>;
+using FixedAxisCosErrorFunction_const_w = ::std::weak_ptr<const FixedAxisCosErrorFunction>;
+
+using FixedAxisCosErrorFunctiond_p = ::std::shared_ptr<FixedAxisCosErrorFunctiond>;
+using FixedAxisCosErrorFunctiond_u = ::std::unique_ptr<FixedAxisCosErrorFunctiond>;
+using FixedAxisCosErrorFunctiond_w = ::std::weak_ptr<FixedAxisCosErrorFunctiond>;
+using FixedAxisCosErrorFunctiond_const_p = ::std::shared_ptr<const FixedAxisCosErrorFunctiond>;
+using FixedAxisCosErrorFunctiond_const_u = ::std::unique_ptr<const FixedAxisCosErrorFunctiond>;
+using FixedAxisCosErrorFunctiond_const_w = ::std::weak_ptr<const FixedAxisCosErrorFunctiond>;
+
+template <typename T>
+class FixedAxisDiffErrorFunctionT;
+using FixedAxisDiffErrorFunction = FixedAxisDiffErrorFunctionT<float>;
+using FixedAxisDiffErrorFunctiond = FixedAxisDiffErrorFunctionT<double>;
+
+using FixedAxisDiffErrorFunction_p = ::std::shared_ptr<FixedAxisDiffErrorFunction>;
+using FixedAxisDiffErrorFunction_u = ::std::unique_ptr<FixedAxisDiffErrorFunction>;
+using FixedAxisDiffErrorFunction_w = ::std::weak_ptr<FixedAxisDiffErrorFunction>;
+using FixedAxisDiffErrorFunction_const_p = ::std::shared_ptr<const FixedAxisDiffErrorFunction>;
+using FixedAxisDiffErrorFunction_const_u = ::std::unique_ptr<const FixedAxisDiffErrorFunction>;
+using FixedAxisDiffErrorFunction_const_w = ::std::weak_ptr<const FixedAxisDiffErrorFunction>;
+
+using FixedAxisDiffErrorFunctiond_p = ::std::shared_ptr<FixedAxisDiffErrorFunctiond>;
+using FixedAxisDiffErrorFunctiond_u = ::std::unique_ptr<FixedAxisDiffErrorFunctiond>;
+using FixedAxisDiffErrorFunctiond_w = ::std::weak_ptr<FixedAxisDiffErrorFunctiond>;
+using FixedAxisDiffErrorFunctiond_const_p = ::std::shared_ptr<const FixedAxisDiffErrorFunctiond>;
+using FixedAxisDiffErrorFunctiond_const_u = ::std::unique_ptr<const FixedAxisDiffErrorFunctiond>;
+using FixedAxisDiffErrorFunctiond_const_w = ::std::weak_ptr<const FixedAxisDiffErrorFunctiond>;
+
+template <typename T>
+class GaussNewtonSolverQRT;
+using GaussNewtonSolverQR = GaussNewtonSolverQRT<float>;
+using GaussNewtonSolverQRd = GaussNewtonSolverQRT<double>;
+
+using GaussNewtonSolverQR_p = ::std::shared_ptr<GaussNewtonSolverQR>;
+using GaussNewtonSolverQR_u = ::std::unique_ptr<GaussNewtonSolverQR>;
+using GaussNewtonSolverQR_w = ::std::weak_ptr<GaussNewtonSolverQR>;
+using GaussNewtonSolverQR_const_p = ::std::shared_ptr<const GaussNewtonSolverQR>;
+using GaussNewtonSolverQR_const_u = ::std::unique_ptr<const GaussNewtonSolverQR>;
+using GaussNewtonSolverQR_const_w = ::std::weak_ptr<const GaussNewtonSolverQR>;
+
+using GaussNewtonSolverQRd_p = ::std::shared_ptr<GaussNewtonSolverQRd>;
+using GaussNewtonSolverQRd_u = ::std::unique_ptr<GaussNewtonSolverQRd>;
+using GaussNewtonSolverQRd_w = ::std::weak_ptr<GaussNewtonSolverQRd>;
+using GaussNewtonSolverQRd_const_p = ::std::shared_ptr<const GaussNewtonSolverQRd>;
+using GaussNewtonSolverQRd_const_u = ::std::unique_ptr<const GaussNewtonSolverQRd>;
+using GaussNewtonSolverQRd_const_w = ::std::weak_ptr<const GaussNewtonSolverQRd>;
+
+template <typename T>
+class HeightErrorFunctionT;
+using HeightErrorFunction = HeightErrorFunctionT<float>;
+using HeightErrorFunctiond = HeightErrorFunctionT<double>;
+
+using HeightErrorFunction_p = ::std::shared_ptr<HeightErrorFunction>;
+using HeightErrorFunction_u = ::std::unique_ptr<HeightErrorFunction>;
+using HeightErrorFunction_w = ::std::weak_ptr<HeightErrorFunction>;
+using HeightErrorFunction_const_p = ::std::shared_ptr<const HeightErrorFunction>;
+using HeightErrorFunction_const_u = ::std::unique_ptr<const HeightErrorFunction>;
+using HeightErrorFunction_const_w = ::std::weak_ptr<const HeightErrorFunction>;
+
+using HeightErrorFunctiond_p = ::std::shared_ptr<HeightErrorFunctiond>;
+using HeightErrorFunctiond_u = ::std::unique_ptr<HeightErrorFunctiond>;
+using HeightErrorFunctiond_w = ::std::weak_ptr<HeightErrorFunctiond>;
+using HeightErrorFunctiond_const_p = ::std::shared_ptr<const HeightErrorFunctiond>;
+using HeightErrorFunctiond_const_u = ::std::unique_ptr<const HeightErrorFunctiond>;
+using HeightErrorFunctiond_const_w = ::std::weak_ptr<const HeightErrorFunctiond>;
+
+template <typename T>
+class LimitErrorFunctionT;
+using LimitErrorFunction = LimitErrorFunctionT<float>;
+using LimitErrorFunctiond = LimitErrorFunctionT<double>;
+
+using LimitErrorFunction_p = ::std::shared_ptr<LimitErrorFunction>;
+using LimitErrorFunction_u = ::std::unique_ptr<LimitErrorFunction>;
+using LimitErrorFunction_w = ::std::weak_ptr<LimitErrorFunction>;
+using LimitErrorFunction_const_p = ::std::shared_ptr<const LimitErrorFunction>;
+using LimitErrorFunction_const_u = ::std::unique_ptr<const LimitErrorFunction>;
+using LimitErrorFunction_const_w = ::std::weak_ptr<const LimitErrorFunction>;
+
+using LimitErrorFunctiond_p = ::std::shared_ptr<LimitErrorFunctiond>;
+using LimitErrorFunctiond_u = ::std::unique_ptr<LimitErrorFunctiond>;
+using LimitErrorFunctiond_w = ::std::weak_ptr<LimitErrorFunctiond>;
+using LimitErrorFunctiond_const_p = ::std::shared_ptr<const LimitErrorFunctiond>;
+using LimitErrorFunctiond_const_u = ::std::unique_ptr<const LimitErrorFunctiond>;
+using LimitErrorFunctiond_const_w = ::std::weak_ptr<const LimitErrorFunctiond>;
+
+template <typename T>
+class ModelParametersErrorFunctionT;
+using ModelParametersErrorFunction = ModelParametersErrorFunctionT<float>;
+using ModelParametersErrorFunctiond = ModelParametersErrorFunctionT<double>;
+
+using ModelParametersErrorFunction_p = ::std::shared_ptr<ModelParametersErrorFunction>;
+using ModelParametersErrorFunction_u = ::std::unique_ptr<ModelParametersErrorFunction>;
+using ModelParametersErrorFunction_w = ::std::weak_ptr<ModelParametersErrorFunction>;
+using ModelParametersErrorFunction_const_p = ::std::shared_ptr<const ModelParametersErrorFunction>;
+using ModelParametersErrorFunction_const_u = ::std::unique_ptr<const ModelParametersErrorFunction>;
+using ModelParametersErrorFunction_const_w = ::std::weak_ptr<const ModelParametersErrorFunction>;
+
+using ModelParametersErrorFunctiond_p = ::std::shared_ptr<ModelParametersErrorFunctiond>;
+using ModelParametersErrorFunctiond_u = ::std::unique_ptr<ModelParametersErrorFunctiond>;
+using ModelParametersErrorFunctiond_w = ::std::weak_ptr<ModelParametersErrorFunctiond>;
+using ModelParametersErrorFunctiond_const_p =
+    ::std::shared_ptr<const ModelParametersErrorFunctiond>;
+using ModelParametersErrorFunctiond_const_u =
+    ::std::unique_ptr<const ModelParametersErrorFunctiond>;
+using ModelParametersErrorFunctiond_const_w = ::std::weak_ptr<const ModelParametersErrorFunctiond>;
+
+template <typename T>
+class NormalErrorFunctionT;
+using NormalErrorFunction = NormalErrorFunctionT<float>;
+using NormalErrorFunctiond = NormalErrorFunctionT<double>;
+
+using NormalErrorFunction_p = ::std::shared_ptr<NormalErrorFunction>;
+using NormalErrorFunction_u = ::std::unique_ptr<NormalErrorFunction>;
+using NormalErrorFunction_w = ::std::weak_ptr<NormalErrorFunction>;
+using NormalErrorFunction_const_p = ::std::shared_ptr<const NormalErrorFunction>;
+using NormalErrorFunction_const_u = ::std::unique_ptr<const NormalErrorFunction>;
+using NormalErrorFunction_const_w = ::std::weak_ptr<const NormalErrorFunction>;
+
+using NormalErrorFunctiond_p = ::std::shared_ptr<NormalErrorFunctiond>;
+using NormalErrorFunctiond_u = ::std::unique_ptr<NormalErrorFunctiond>;
+using NormalErrorFunctiond_w = ::std::weak_ptr<NormalErrorFunctiond>;
+using NormalErrorFunctiond_const_p = ::std::shared_ptr<const NormalErrorFunctiond>;
+using NormalErrorFunctiond_const_u = ::std::unique_ptr<const NormalErrorFunctiond>;
+using NormalErrorFunctiond_const_w = ::std::weak_ptr<const NormalErrorFunctiond>;
+
+template <typename T>
+class OrientationErrorFunctionT;
+using OrientationErrorFunction = OrientationErrorFunctionT<float>;
+using OrientationErrorFunctiond = OrientationErrorFunctionT<double>;
+
+using OrientationErrorFunction_p = ::std::shared_ptr<OrientationErrorFunction>;
+using OrientationErrorFunction_u = ::std::unique_ptr<OrientationErrorFunction>;
+using OrientationErrorFunction_w = ::std::weak_ptr<OrientationErrorFunction>;
+using OrientationErrorFunction_const_p = ::std::shared_ptr<const OrientationErrorFunction>;
+using OrientationErrorFunction_const_u = ::std::unique_ptr<const OrientationErrorFunction>;
+using OrientationErrorFunction_const_w = ::std::weak_ptr<const OrientationErrorFunction>;
+
+using OrientationErrorFunctiond_p = ::std::shared_ptr<OrientationErrorFunctiond>;
+using OrientationErrorFunctiond_u = ::std::unique_ptr<OrientationErrorFunctiond>;
+using OrientationErrorFunctiond_w = ::std::weak_ptr<OrientationErrorFunctiond>;
+using OrientationErrorFunctiond_const_p = ::std::shared_ptr<const OrientationErrorFunctiond>;
+using OrientationErrorFunctiond_const_u = ::std::unique_ptr<const OrientationErrorFunctiond>;
+using OrientationErrorFunctiond_const_w = ::std::weak_ptr<const OrientationErrorFunctiond>;
+
+template <typename T>
+class PlaneErrorFunctionT;
+using PlaneErrorFunction = PlaneErrorFunctionT<float>;
+using PlaneErrorFunctiond = PlaneErrorFunctionT<double>;
+
+using PlaneErrorFunction_p = ::std::shared_ptr<PlaneErrorFunction>;
+using PlaneErrorFunction_u = ::std::unique_ptr<PlaneErrorFunction>;
+using PlaneErrorFunction_w = ::std::weak_ptr<PlaneErrorFunction>;
+using PlaneErrorFunction_const_p = ::std::shared_ptr<const PlaneErrorFunction>;
+using PlaneErrorFunction_const_u = ::std::unique_ptr<const PlaneErrorFunction>;
+using PlaneErrorFunction_const_w = ::std::weak_ptr<const PlaneErrorFunction>;
+
+using PlaneErrorFunctiond_p = ::std::shared_ptr<PlaneErrorFunctiond>;
+using PlaneErrorFunctiond_u = ::std::unique_ptr<PlaneErrorFunctiond>;
+using PlaneErrorFunctiond_w = ::std::weak_ptr<PlaneErrorFunctiond>;
+using PlaneErrorFunctiond_const_p = ::std::shared_ptr<const PlaneErrorFunctiond>;
+using PlaneErrorFunctiond_const_u = ::std::unique_ptr<const PlaneErrorFunctiond>;
+using PlaneErrorFunctiond_const_w = ::std::weak_ptr<const PlaneErrorFunctiond>;
+
+template <typename T>
+class PointTriangleVertexErrorFunctionT;
+using PointTriangleVertexErrorFunction = PointTriangleVertexErrorFunctionT<float>;
+using PointTriangleVertexErrorFunctiond = PointTriangleVertexErrorFunctionT<double>;
+
+using PointTriangleVertexErrorFunction_p = ::std::shared_ptr<PointTriangleVertexErrorFunction>;
+using PointTriangleVertexErrorFunction_u = ::std::unique_ptr<PointTriangleVertexErrorFunction>;
+using PointTriangleVertexErrorFunction_w = ::std::weak_ptr<PointTriangleVertexErrorFunction>;
+using PointTriangleVertexErrorFunction_const_p =
+    ::std::shared_ptr<const PointTriangleVertexErrorFunction>;
+using PointTriangleVertexErrorFunction_const_u =
+    ::std::unique_ptr<const PointTriangleVertexErrorFunction>;
+using PointTriangleVertexErrorFunction_const_w =
+    ::std::weak_ptr<const PointTriangleVertexErrorFunction>;
+
+using PointTriangleVertexErrorFunctiond_p = ::std::shared_ptr<PointTriangleVertexErrorFunctiond>;
+using PointTriangleVertexErrorFunctiond_u = ::std::unique_ptr<PointTriangleVertexErrorFunctiond>;
+using PointTriangleVertexErrorFunctiond_w = ::std::weak_ptr<PointTriangleVertexErrorFunctiond>;
+using PointTriangleVertexErrorFunctiond_const_p =
+    ::std::shared_ptr<const PointTriangleVertexErrorFunctiond>;
+using PointTriangleVertexErrorFunctiond_const_u =
+    ::std::unique_ptr<const PointTriangleVertexErrorFunctiond>;
+using PointTriangleVertexErrorFunctiond_const_w =
+    ::std::weak_ptr<const PointTriangleVertexErrorFunctiond>;
+
+template <typename T>
+class PosePriorErrorFunctionT;
+using PosePriorErrorFunction = PosePriorErrorFunctionT<float>;
+using PosePriorErrorFunctiond = PosePriorErrorFunctionT<double>;
+
+using PosePriorErrorFunction_p = ::std::shared_ptr<PosePriorErrorFunction>;
+using PosePriorErrorFunction_u = ::std::unique_ptr<PosePriorErrorFunction>;
+using PosePriorErrorFunction_w = ::std::weak_ptr<PosePriorErrorFunction>;
+using PosePriorErrorFunction_const_p = ::std::shared_ptr<const PosePriorErrorFunction>;
+using PosePriorErrorFunction_const_u = ::std::unique_ptr<const PosePriorErrorFunction>;
+using PosePriorErrorFunction_const_w = ::std::weak_ptr<const PosePriorErrorFunction>;
+
+using PosePriorErrorFunctiond_p = ::std::shared_ptr<PosePriorErrorFunctiond>;
+using PosePriorErrorFunctiond_u = ::std::unique_ptr<PosePriorErrorFunctiond>;
+using PosePriorErrorFunctiond_w = ::std::weak_ptr<PosePriorErrorFunctiond>;
+using PosePriorErrorFunctiond_const_p = ::std::shared_ptr<const PosePriorErrorFunctiond>;
+using PosePriorErrorFunctiond_const_u = ::std::unique_ptr<const PosePriorErrorFunctiond>;
+using PosePriorErrorFunctiond_const_w = ::std::weak_ptr<const PosePriorErrorFunctiond>;
+
+template <typename T>
+class PoseTransformSolverT;
+using PoseTransformSolver = PoseTransformSolverT<float>;
+using PoseTransformSolverd = PoseTransformSolverT<double>;
+
+using PoseTransformSolver_p = ::std::shared_ptr<PoseTransformSolver>;
+using PoseTransformSolver_u = ::std::unique_ptr<PoseTransformSolver>;
+using PoseTransformSolver_w = ::std::weak_ptr<PoseTransformSolver>;
+using PoseTransformSolver_const_p = ::std::shared_ptr<const PoseTransformSolver>;
+using PoseTransformSolver_const_u = ::std::unique_ptr<const PoseTransformSolver>;
+using PoseTransformSolver_const_w = ::std::weak_ptr<const PoseTransformSolver>;
+
+using PoseTransformSolverd_p = ::std::shared_ptr<PoseTransformSolverd>;
+using PoseTransformSolverd_u = ::std::unique_ptr<PoseTransformSolverd>;
+using PoseTransformSolverd_w = ::std::weak_ptr<PoseTransformSolverd>;
+using PoseTransformSolverd_const_p = ::std::shared_ptr<const PoseTransformSolverd>;
+using PoseTransformSolverd_const_u = ::std::unique_ptr<const PoseTransformSolverd>;
+using PoseTransformSolverd_const_w = ::std::weak_ptr<const PoseTransformSolverd>;
+
+template <typename T>
+class PositionErrorFunctionT;
+using PositionErrorFunction = PositionErrorFunctionT<float>;
+using PositionErrorFunctiond = PositionErrorFunctionT<double>;
+
+using PositionErrorFunction_p = ::std::shared_ptr<PositionErrorFunction>;
+using PositionErrorFunction_u = ::std::unique_ptr<PositionErrorFunction>;
+using PositionErrorFunction_w = ::std::weak_ptr<PositionErrorFunction>;
+using PositionErrorFunction_const_p = ::std::shared_ptr<const PositionErrorFunction>;
+using PositionErrorFunction_const_u = ::std::unique_ptr<const PositionErrorFunction>;
+using PositionErrorFunction_const_w = ::std::weak_ptr<const PositionErrorFunction>;
+
+using PositionErrorFunctiond_p = ::std::shared_ptr<PositionErrorFunctiond>;
+using PositionErrorFunctiond_u = ::std::unique_ptr<PositionErrorFunctiond>;
+using PositionErrorFunctiond_w = ::std::weak_ptr<PositionErrorFunctiond>;
+using PositionErrorFunctiond_const_p = ::std::shared_ptr<const PositionErrorFunctiond>;
+using PositionErrorFunctiond_const_u = ::std::unique_ptr<const PositionErrorFunctiond>;
+using PositionErrorFunctiond_const_w = ::std::weak_ptr<const PositionErrorFunctiond>;
+
+template <typename T>
+class ProjectionErrorFunctionT;
+using ProjectionErrorFunction = ProjectionErrorFunctionT<float>;
+using ProjectionErrorFunctiond = ProjectionErrorFunctionT<double>;
+
+using ProjectionErrorFunction_p = ::std::shared_ptr<ProjectionErrorFunction>;
+using ProjectionErrorFunction_u = ::std::unique_ptr<ProjectionErrorFunction>;
+using ProjectionErrorFunction_w = ::std::weak_ptr<ProjectionErrorFunction>;
+using ProjectionErrorFunction_const_p = ::std::shared_ptr<const ProjectionErrorFunction>;
+using ProjectionErrorFunction_const_u = ::std::unique_ptr<const ProjectionErrorFunction>;
+using ProjectionErrorFunction_const_w = ::std::weak_ptr<const ProjectionErrorFunction>;
+
+using ProjectionErrorFunctiond_p = ::std::shared_ptr<ProjectionErrorFunctiond>;
+using ProjectionErrorFunctiond_u = ::std::unique_ptr<ProjectionErrorFunctiond>;
+using ProjectionErrorFunctiond_w = ::std::weak_ptr<ProjectionErrorFunctiond>;
+using ProjectionErrorFunctiond_const_p = ::std::shared_ptr<const ProjectionErrorFunctiond>;
+using ProjectionErrorFunctiond_const_u = ::std::unique_ptr<const ProjectionErrorFunctiond>;
+using ProjectionErrorFunctiond_const_w = ::std::weak_ptr<const ProjectionErrorFunctiond>;
+
+template <typename T>
+class SimdCollisionErrorFunctionT;
+using SimdCollisionErrorFunction = SimdCollisionErrorFunctionT<float>;
+using SimdCollisionErrorFunctiond = SimdCollisionErrorFunctionT<double>;
+
+using SimdCollisionErrorFunction_p = ::std::shared_ptr<SimdCollisionErrorFunction>;
+using SimdCollisionErrorFunction_u = ::std::unique_ptr<SimdCollisionErrorFunction>;
+using SimdCollisionErrorFunction_w = ::std::weak_ptr<SimdCollisionErrorFunction>;
+using SimdCollisionErrorFunction_const_p = ::std::shared_ptr<const SimdCollisionErrorFunction>;
+using SimdCollisionErrorFunction_const_u = ::std::unique_ptr<const SimdCollisionErrorFunction>;
+using SimdCollisionErrorFunction_const_w = ::std::weak_ptr<const SimdCollisionErrorFunction>;
+
+using SimdCollisionErrorFunctiond_p = ::std::shared_ptr<SimdCollisionErrorFunctiond>;
+using SimdCollisionErrorFunctiond_u = ::std::unique_ptr<SimdCollisionErrorFunctiond>;
+using SimdCollisionErrorFunctiond_w = ::std::weak_ptr<SimdCollisionErrorFunctiond>;
+using SimdCollisionErrorFunctiond_const_p = ::std::shared_ptr<const SimdCollisionErrorFunctiond>;
+using SimdCollisionErrorFunctiond_const_u = ::std::unique_ptr<const SimdCollisionErrorFunctiond>;
+using SimdCollisionErrorFunctiond_const_w = ::std::weak_ptr<const SimdCollisionErrorFunctiond>;
+
+template <typename T>
+class SkeletonErrorFunctionT;
+using SkeletonErrorFunction = SkeletonErrorFunctionT<float>;
+using SkeletonErrorFunctiond = SkeletonErrorFunctionT<double>;
+
+using SkeletonErrorFunction_p = ::std::shared_ptr<SkeletonErrorFunction>;
+using SkeletonErrorFunction_u = ::std::unique_ptr<SkeletonErrorFunction>;
+using SkeletonErrorFunction_w = ::std::weak_ptr<SkeletonErrorFunction>;
+using SkeletonErrorFunction_const_p = ::std::shared_ptr<const SkeletonErrorFunction>;
+using SkeletonErrorFunction_const_u = ::std::unique_ptr<const SkeletonErrorFunction>;
+using SkeletonErrorFunction_const_w = ::std::weak_ptr<const SkeletonErrorFunction>;
+
+using SkeletonErrorFunctiond_p = ::std::shared_ptr<SkeletonErrorFunctiond>;
+using SkeletonErrorFunctiond_u = ::std::unique_ptr<SkeletonErrorFunctiond>;
+using SkeletonErrorFunctiond_w = ::std::weak_ptr<SkeletonErrorFunctiond>;
+using SkeletonErrorFunctiond_const_p = ::std::shared_ptr<const SkeletonErrorFunctiond>;
+using SkeletonErrorFunctiond_const_u = ::std::unique_ptr<const SkeletonErrorFunctiond>;
+using SkeletonErrorFunctiond_const_w = ::std::weak_ptr<const SkeletonErrorFunctiond>;
+
+template <typename T>
+class SkeletonSolverFunctionT;
+using SkeletonSolverFunction = SkeletonSolverFunctionT<float>;
+using SkeletonSolverFunctiond = SkeletonSolverFunctionT<double>;
+
+using SkeletonSolverFunction_p = ::std::shared_ptr<SkeletonSolverFunction>;
+using SkeletonSolverFunction_u = ::std::unique_ptr<SkeletonSolverFunction>;
+using SkeletonSolverFunction_w = ::std::weak_ptr<SkeletonSolverFunction>;
+using SkeletonSolverFunction_const_p = ::std::shared_ptr<const SkeletonSolverFunction>;
+using SkeletonSolverFunction_const_u = ::std::unique_ptr<const SkeletonSolverFunction>;
+using SkeletonSolverFunction_const_w = ::std::weak_ptr<const SkeletonSolverFunction>;
+
+using SkeletonSolverFunctiond_p = ::std::shared_ptr<SkeletonSolverFunctiond>;
+using SkeletonSolverFunctiond_u = ::std::unique_ptr<SkeletonSolverFunctiond>;
+using SkeletonSolverFunctiond_w = ::std::weak_ptr<SkeletonSolverFunctiond>;
+using SkeletonSolverFunctiond_const_p = ::std::shared_ptr<const SkeletonSolverFunctiond>;
+using SkeletonSolverFunctiond_const_u = ::std::unique_ptr<const SkeletonSolverFunctiond>;
+using SkeletonSolverFunctiond_const_w = ::std::weak_ptr<const SkeletonSolverFunctiond>;
+
+template <typename T>
+class SkinnedLocatorErrorFunctionT;
+using SkinnedLocatorErrorFunction = SkinnedLocatorErrorFunctionT<float>;
+using SkinnedLocatorErrorFunctiond = SkinnedLocatorErrorFunctionT<double>;
+
+using SkinnedLocatorErrorFunction_p = ::std::shared_ptr<SkinnedLocatorErrorFunction>;
+using SkinnedLocatorErrorFunction_u = ::std::unique_ptr<SkinnedLocatorErrorFunction>;
+using SkinnedLocatorErrorFunction_w = ::std::weak_ptr<SkinnedLocatorErrorFunction>;
+using SkinnedLocatorErrorFunction_const_p = ::std::shared_ptr<const SkinnedLocatorErrorFunction>;
+using SkinnedLocatorErrorFunction_const_u = ::std::unique_ptr<const SkinnedLocatorErrorFunction>;
+using SkinnedLocatorErrorFunction_const_w = ::std::weak_ptr<const SkinnedLocatorErrorFunction>;
+
+using SkinnedLocatorErrorFunctiond_p = ::std::shared_ptr<SkinnedLocatorErrorFunctiond>;
+using SkinnedLocatorErrorFunctiond_u = ::std::unique_ptr<SkinnedLocatorErrorFunctiond>;
+using SkinnedLocatorErrorFunctiond_w = ::std::weak_ptr<SkinnedLocatorErrorFunctiond>;
+using SkinnedLocatorErrorFunctiond_const_p = ::std::shared_ptr<const SkinnedLocatorErrorFunctiond>;
+using SkinnedLocatorErrorFunctiond_const_u = ::std::unique_ptr<const SkinnedLocatorErrorFunctiond>;
+using SkinnedLocatorErrorFunctiond_const_w = ::std::weak_ptr<const SkinnedLocatorErrorFunctiond>;
+
+template <typename T>
+class SkinnedLocatorTriangleErrorFunctionT;
+using SkinnedLocatorTriangleErrorFunction = SkinnedLocatorTriangleErrorFunctionT<float>;
+using SkinnedLocatorTriangleErrorFunctiond = SkinnedLocatorTriangleErrorFunctionT<double>;
+
+using SkinnedLocatorTriangleErrorFunction_p =
+    ::std::shared_ptr<SkinnedLocatorTriangleErrorFunction>;
+using SkinnedLocatorTriangleErrorFunction_u =
+    ::std::unique_ptr<SkinnedLocatorTriangleErrorFunction>;
+using SkinnedLocatorTriangleErrorFunction_w = ::std::weak_ptr<SkinnedLocatorTriangleErrorFunction>;
+using SkinnedLocatorTriangleErrorFunction_const_p =
+    ::std::shared_ptr<const SkinnedLocatorTriangleErrorFunction>;
+using SkinnedLocatorTriangleErrorFunction_const_u =
+    ::std::unique_ptr<const SkinnedLocatorTriangleErrorFunction>;
+using SkinnedLocatorTriangleErrorFunction_const_w =
+    ::std::weak_ptr<const SkinnedLocatorTriangleErrorFunction>;
+
+using SkinnedLocatorTriangleErrorFunctiond_p =
+    ::std::shared_ptr<SkinnedLocatorTriangleErrorFunctiond>;
+using SkinnedLocatorTriangleErrorFunctiond_u =
+    ::std::unique_ptr<SkinnedLocatorTriangleErrorFunctiond>;
+using SkinnedLocatorTriangleErrorFunctiond_w =
+    ::std::weak_ptr<SkinnedLocatorTriangleErrorFunctiond>;
+using SkinnedLocatorTriangleErrorFunctiond_const_p =
+    ::std::shared_ptr<const SkinnedLocatorTriangleErrorFunctiond>;
+using SkinnedLocatorTriangleErrorFunctiond_const_u =
+    ::std::unique_ptr<const SkinnedLocatorTriangleErrorFunctiond>;
+using SkinnedLocatorTriangleErrorFunctiond_const_w =
+    ::std::weak_ptr<const SkinnedLocatorTriangleErrorFunctiond>;
+
+template <typename T>
+class StateErrorFunctionT;
+using StateErrorFunction = StateErrorFunctionT<float>;
+using StateErrorFunctiond = StateErrorFunctionT<double>;
+
+using StateErrorFunction_p = ::std::shared_ptr<StateErrorFunction>;
+using StateErrorFunction_u = ::std::unique_ptr<StateErrorFunction>;
+using StateErrorFunction_w = ::std::weak_ptr<StateErrorFunction>;
+using StateErrorFunction_const_p = ::std::shared_ptr<const StateErrorFunction>;
+using StateErrorFunction_const_u = ::std::unique_ptr<const StateErrorFunction>;
+using StateErrorFunction_const_w = ::std::weak_ptr<const StateErrorFunction>;
+
+using StateErrorFunctiond_p = ::std::shared_ptr<StateErrorFunctiond>;
+using StateErrorFunctiond_u = ::std::unique_ptr<StateErrorFunctiond>;
+using StateErrorFunctiond_w = ::std::weak_ptr<StateErrorFunctiond>;
+using StateErrorFunctiond_const_p = ::std::shared_ptr<const StateErrorFunctiond>;
+using StateErrorFunctiond_const_u = ::std::unique_ptr<const StateErrorFunctiond>;
+using StateErrorFunctiond_const_w = ::std::weak_ptr<const StateErrorFunctiond>;
+
+template <typename T>
+class TrustRegionQRT;
+using TrustRegionQR = TrustRegionQRT<float>;
+using TrustRegionQRd = TrustRegionQRT<double>;
+
+using TrustRegionQR_p = ::std::shared_ptr<TrustRegionQR>;
+using TrustRegionQR_u = ::std::unique_ptr<TrustRegionQR>;
+using TrustRegionQR_w = ::std::weak_ptr<TrustRegionQR>;
+using TrustRegionQR_const_p = ::std::shared_ptr<const TrustRegionQR>;
+using TrustRegionQR_const_u = ::std::unique_ptr<const TrustRegionQR>;
+using TrustRegionQR_const_w = ::std::weak_ptr<const TrustRegionQR>;
+
+using TrustRegionQRd_p = ::std::shared_ptr<TrustRegionQRd>;
+using TrustRegionQRd_u = ::std::unique_ptr<TrustRegionQRd>;
+using TrustRegionQRd_w = ::std::weak_ptr<TrustRegionQRd>;
+using TrustRegionQRd_const_p = ::std::shared_ptr<const TrustRegionQRd>;
+using TrustRegionQRd_const_u = ::std::unique_ptr<const TrustRegionQRd>;
+using TrustRegionQRd_const_w = ::std::weak_ptr<const TrustRegionQRd>;
+
+template <typename T>
+class VertexErrorFunctionT;
+using VertexErrorFunction = VertexErrorFunctionT<float>;
+using VertexErrorFunctiond = VertexErrorFunctionT<double>;
+
+using VertexErrorFunction_p = ::std::shared_ptr<VertexErrorFunction>;
+using VertexErrorFunction_u = ::std::unique_ptr<VertexErrorFunction>;
+using VertexErrorFunction_w = ::std::weak_ptr<VertexErrorFunction>;
+using VertexErrorFunction_const_p = ::std::shared_ptr<const VertexErrorFunction>;
+using VertexErrorFunction_const_u = ::std::unique_ptr<const VertexErrorFunction>;
+using VertexErrorFunction_const_w = ::std::weak_ptr<const VertexErrorFunction>;
+
+using VertexErrorFunctiond_p = ::std::shared_ptr<VertexErrorFunctiond>;
+using VertexErrorFunctiond_u = ::std::unique_ptr<VertexErrorFunctiond>;
+using VertexErrorFunctiond_w = ::std::weak_ptr<VertexErrorFunctiond>;
+using VertexErrorFunctiond_const_p = ::std::shared_ptr<const VertexErrorFunctiond>;
+using VertexErrorFunctiond_const_u = ::std::unique_ptr<const VertexErrorFunctiond>;
+using VertexErrorFunctiond_const_w = ::std::weak_ptr<const VertexErrorFunctiond>;
+
+template <typename T>
+class VertexProjectionErrorFunctionT;
+using VertexProjectionErrorFunction = VertexProjectionErrorFunctionT<float>;
+using VertexProjectionErrorFunctiond = VertexProjectionErrorFunctionT<double>;
+
+using VertexProjectionErrorFunction_p = ::std::shared_ptr<VertexProjectionErrorFunction>;
+using VertexProjectionErrorFunction_u = ::std::unique_ptr<VertexProjectionErrorFunction>;
+using VertexProjectionErrorFunction_w = ::std::weak_ptr<VertexProjectionErrorFunction>;
+using VertexProjectionErrorFunction_const_p =
+    ::std::shared_ptr<const VertexProjectionErrorFunction>;
+using VertexProjectionErrorFunction_const_u =
+    ::std::unique_ptr<const VertexProjectionErrorFunction>;
+using VertexProjectionErrorFunction_const_w = ::std::weak_ptr<const VertexProjectionErrorFunction>;
+
+using VertexProjectionErrorFunctiond_p = ::std::shared_ptr<VertexProjectionErrorFunctiond>;
+using VertexProjectionErrorFunctiond_u = ::std::unique_ptr<VertexProjectionErrorFunctiond>;
+using VertexProjectionErrorFunctiond_w = ::std::weak_ptr<VertexProjectionErrorFunctiond>;
+using VertexProjectionErrorFunctiond_const_p =
+    ::std::shared_ptr<const VertexProjectionErrorFunctiond>;
+using VertexProjectionErrorFunctiond_const_u =
+    ::std::unique_ptr<const VertexProjectionErrorFunctiond>;
+using VertexProjectionErrorFunctiond_const_w =
+    ::std::weak_ptr<const VertexProjectionErrorFunctiond>;
+
+template <typename T>
+class VertexVertexDistanceErrorFunctionT;
+using VertexVertexDistanceErrorFunction = VertexVertexDistanceErrorFunctionT<float>;
+using VertexVertexDistanceErrorFunctiond = VertexVertexDistanceErrorFunctionT<double>;
+
+using VertexVertexDistanceErrorFunction_p = ::std::shared_ptr<VertexVertexDistanceErrorFunction>;
+using VertexVertexDistanceErrorFunction_u = ::std::unique_ptr<VertexVertexDistanceErrorFunction>;
+using VertexVertexDistanceErrorFunction_w = ::std::weak_ptr<VertexVertexDistanceErrorFunction>;
+using VertexVertexDistanceErrorFunction_const_p =
+    ::std::shared_ptr<const VertexVertexDistanceErrorFunction>;
+using VertexVertexDistanceErrorFunction_const_u =
+    ::std::unique_ptr<const VertexVertexDistanceErrorFunction>;
+using VertexVertexDistanceErrorFunction_const_w =
+    ::std::weak_ptr<const VertexVertexDistanceErrorFunction>;
+
+using VertexVertexDistanceErrorFunctiond_p = ::std::shared_ptr<VertexVertexDistanceErrorFunctiond>;
+using VertexVertexDistanceErrorFunctiond_u = ::std::unique_ptr<VertexVertexDistanceErrorFunctiond>;
+using VertexVertexDistanceErrorFunctiond_w = ::std::weak_ptr<VertexVertexDistanceErrorFunctiond>;
+using VertexVertexDistanceErrorFunctiond_const_p =
+    ::std::shared_ptr<const VertexVertexDistanceErrorFunctiond>;
+using VertexVertexDistanceErrorFunctiond_const_u =
+    ::std::unique_ptr<const VertexVertexDistanceErrorFunctiond>;
+using VertexVertexDistanceErrorFunctiond_const_w =
+    ::std::weak_ptr<const VertexVertexDistanceErrorFunctiond>;
+
+} // namespace momentum