Add point capability to _produce_type to improve GPU compatibility (#577)

* Add point capability to `_produce_type` to improve GPU compatibility

* fixes

* fix two issues

* slightly nicer fix

* improve coverage

* we actually need a copy there

* set date in changelog

Author: mateuszbaran

Changelog.md

@@ -6,13 +6,18 @@ The file was started with Version `0.4`.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.5.33] unreleased
+## [0.5.33] February 18, 2026
 
 ### Added
 
 * A clarification on the use of AI in the [CONTRIBUTING.md](https://manoptjl.org/stable/contributing/) (#573)
+* `_produce_type` now accepts the point `p` as an optional third argument, which can be used to produce objects with specific point type for internal buffers. The addition has been utilized in `DirectionUpdateRule`s and `Stepsize`s to improve GPU and custom floating point type compatibility. (#577)
 * Added another package and paper using `Manopt.jl` to the about page (#576).
 
+### Fixed
+
+* `DistanceOverGradientsStepsize` now requires explicitly passing a point as the second argument because it logically depends on receiving the initial point. (#577)
+
 ## [0.5.32] January 15, 2026
 
 ### Fixed

Project.toml

@@ -1,6 +1,6 @@
 name = "Manopt"
 uuid = "0fc0a36d-df90-57f3-8f93-d78a9fc72bb5"
-version = "0.5.32"
+version = "0.5.33"
 authors = ["Ronny Bergmann <manopt@ronnybergmann.net>"]
 
 [workspace]
@@ -54,7 +54,7 @@ LineSearches = "7.2.0"
 LinearAlgebra = "1.10"
 ManifoldDiff = "0.3.8, 0.4"
 Manifolds = "0.11.2"
-ManifoldsBase = "2.2.0"
+ManifoldsBase = "2.3.1"
 Markdown = "1.10"
 Plots = "1.30"
 Preferences = "1.4"

src/plans/first_order_plan.jl

@@ -643,6 +643,7 @@ $(_fields(:X; name = "X_old"))
 
 
     MomentumGradientRule(M::AbstractManifold; kwargs...)
+    MomentumGradientRule(M::AbstractManifold, p; kwargs...)
 
 Initialize a momentum gradient rule to `s`, where `p` and `X` are memory for interim values.
 
@@ -665,6 +666,9 @@ mutable struct MomentumGradientRule{
     vector_transport_method::VTM
     X_old::T
 end
+function MomentumGradientRule(M::AbstractManifold, p; kwargs...)
+    return MomentumGradientRule(M; p = copy(M, p), kwargs...)
+end
 function MomentumGradientRule(
         M::AbstractManifold;
         p::P = rand(M),
@@ -715,7 +719,7 @@ $(_kwargs(:vector_transport_method))
 $(_note(:ManifoldDefaultFactory, "MomentumGradientRule"))
 """
 function MomentumGradient(args...; kwargs...)
-    return ManifoldDefaultsFactory(Manopt.MomentumGradientRule, args...; kwargs...)
+    return ManifoldDefaultsFactory(Manopt.MomentumGradientRule, args...; requires_point = true, kwargs...)
 end
 
 """
@@ -744,6 +748,7 @@ $(_kwargs(:vector_transport_method))
         last_iterate = deepcopy(x0),
         vector_transport_method = default_vector_transport_method(M, typeof(p))
     )
+    AverageGradientRule(M::AbstractManifold, p; kwargs...)
 
 Add average to a gradient problem, where
 
@@ -761,6 +766,9 @@ mutable struct AverageGradientRule{
     direction::D
     vector_transport_method::VTM
 end
+function AverageGradientRule(M::AbstractManifold, p; kwargs...)
+    return AverageGradientRule(M; p = copy(M, p), kwargs...)
+end
 function AverageGradientRule(
         M::AbstractManifold;
         p::P = rand(M),
@@ -813,7 +821,7 @@ $(_kwargs([:X, :vector_transport_method]))
 $(_note(:ManifoldDefaultFactory, "AverageGradientRule"))
 """
 function AverageGradient(args...; kwargs...)
-    return ManifoldDefaultsFactory(Manopt.AverageGradientRule, args...; kwargs...)
+    return ManifoldDefaultsFactory(Manopt.AverageGradientRule, args...; requires_point = true, kwargs...)
 end
 
 @doc """
@@ -832,6 +840,7 @@ $(_kwargs(:inverse_retraction_method))
 # Constructor
 
     NesterovRule(M::AbstractManifold; kwargs...)
+    NesterovRule(M::AbstractManifold, p; kwargs...)
 
 ## Keyword arguments
 
@@ -852,6 +861,9 @@ mutable struct NesterovRule{P, R <: Real} <: DirectionUpdateRule
     shrinkage::Function
     inverse_retraction_method::AbstractInverseRetractionMethod
 end
+function NesterovRule(M::AbstractManifold, p; kwargs...)
+    return NesterovRule(M; p = copy(M, p), kwargs...)
+end
 function NesterovRule(
         M::AbstractManifold;
         p::P = rand(M),
@@ -926,7 +938,7 @@ $(_kwargs(:inverse_retraction_method))
 $(_note(:ManifoldDefaultFactory, "NesterovRule"))
 """
 function Nesterov(args...; kwargs...)
-    return ManifoldDefaultsFactory(Manopt.NesterovRule, args...; kwargs...)
+    return ManifoldDefaultsFactory(Manopt.NesterovRule, args...; requires_point = true, kwargs...)
 end
 
 """

src/plans/manifold_default_factory.jl

@@ -56,31 +56,63 @@ struct ManifoldDefaultsFactory{T, TM <: Union{<:AbstractManifold, Nothing}, A, K
     args::A
     kwargs::K
     constructor_requires_manifold::Bool
+    constructor_requires_point::Bool
 end
 function ManifoldDefaultsFactory(
-        T::Type, M::TM, args...; requires_manifold = true, kwargs...
+        T::Type, M::TM, args...; requires_manifold = true, requires_point = false, kwargs...
     ) where {TM <: AbstractManifold}
     return ManifoldDefaultsFactory{T, TM, typeof(args), typeof(kwargs)}(
-        M, args, kwargs, requires_manifold
+        M, args, kwargs, requires_manifold, requires_point
     )
 end
-function ManifoldDefaultsFactory(T::Type, args...; requires_manifold = true, kwargs...)
+function ManifoldDefaultsFactory(T::Type, args...; requires_manifold = true, requires_point = false, kwargs...)
     return ManifoldDefaultsFactory{T, Nothing, typeof(args), typeof(kwargs)}(
-        nothing, args, kwargs, requires_manifold
+        nothing, args, kwargs, requires_manifold, requires_point
     )
 end
+function (mdf::ManifoldDefaultsFactory{T})(M::AbstractManifold, p) where {T}
+    return if mdf.constructor_requires_manifold
+        if mdf.constructor_requires_point
+            return T(M, p, mdf.args...; mdf.kwargs...)
+        else
+            return T(M, mdf.args...; mdf.kwargs...)
+        end
+    else
+        if mdf.constructor_requires_point
+            return T(p, mdf.args...; mdf.kwargs...)
+        else
+            return T(mdf.args...; mdf.kwargs...)
+        end
+    end
+end
 function (mdf::ManifoldDefaultsFactory{T})(M::AbstractManifold) where {T}
-    if mdf.constructor_requires_manifold
-        return T(M, mdf.args...; mdf.kwargs...)
+    return if mdf.constructor_requires_manifold
+        if mdf.constructor_requires_point
+            return T(M, rand(M), mdf.args...; mdf.kwargs...)
+        else
+            return T(M, mdf.args...; mdf.kwargs...)
+        end
     else
-        return T(mdf.args...; mdf.kwargs...)
+        if mdf.constructor_requires_point
+            return T(rand(mdf.M), mdf.args...; mdf.kwargs...)
+        else
+            return T(mdf.args...; mdf.kwargs...)
+        end
     end
 end
 function (mdf::ManifoldDefaultsFactory{T, <:AbstractManifold})() where {T}
-    if mdf.constructor_requires_manifold
-        return T(mdf.M, mdf.args...; mdf.kwargs...)
+    return if mdf.constructor_requires_manifold
+        if mdf.constructor_requires_point
+            return T(mdf.M, rand(mdf.M), mdf.args...; mdf.kwargs...)
+        else
+            return T(mdf.M, mdf.args...; mdf.kwargs...)
+        end
     else
-        return T(mdf.args...; mdf.kwargs...)
+        if mdf.constructor_requires_point
+            return T(rand(mdf.M), mdf.args...; mdf.kwargs...)
+        else
+            return T(mdf.args...; mdf.kwargs...)
+        end
     end
 end
 function (mdf::ManifoldDefaultsFactory{T, Nothing})() where {T}
@@ -90,13 +122,20 @@ end
 """
     _produce_type(t::T, M::AbstractManifold)
     _produce_type(t::ManifoldDefaultsFactory{T}, M::AbstractManifold)
+    _produce_type(t::ManifoldDefaultsFactory{T}, M::AbstractManifold, p)
 
 Use the [`ManifoldDefaultsFactory`](@ref)`{T}` to produce an instance of type `T`.
 This acts transparent in the way that if you provide an instance `t::T` already, this will
 just be returned.
+
+If a point `p` on manifold `M` is provided, it is passed to the constructor `t` as a
+template for allocating points. It is no supposed to be modified by the constructor or
+stored in the produced object.
 """
 _produce_type(t, M::AbstractManifold) = t
+_produce_type(t, M::AbstractManifold, p) = t
 _produce_type(t::ManifoldDefaultsFactory, M::AbstractManifold) = t(M)
+_produce_type(t::ManifoldDefaultsFactory, M::AbstractManifold, p) = t(M, p)
 
 function show(io::IO, mdf::ManifoldDefaultsFactory{T, M}) where {T, M}
     rm = mdf.constructor_requires_manifold

src/plans/stepsize/stepsize.jl

@@ -104,6 +104,10 @@ mutable struct ArmijoLinesearchStepsize{TRM <: AbstractRetractionMethod, P, I, F
         )
     end
 end
+function ArmijoLinesearchStepsize(M::AbstractManifold, p; kwargs...)
+    return ArmijoLinesearchStepsize(M; candidate_point = allocate(p), kwargs...)
+end
+
 function (a::ArmijoLinesearchStepsize)(
         mp::AbstractManoptProblem,
         s::AbstractManoptSolverState,
@@ -222,7 +226,7 @@ For the stop safe guards you can pass `:Messages` to a `debug=` to see `@info` m
 $(_note(:ManifoldDefaultFactory, "ArmijoLinesearchStepsize"))
 """
 function ArmijoLinesearch(args...; kwargs...)
-    return ManifoldDefaultsFactory(Manopt.ArmijoLinesearchStepsize, args...; kwargs...)
+    return ManifoldDefaultsFactory(Manopt.ArmijoLinesearchStepsize, args...; requires_point = true, kwargs...)
 end
 
 @doc """
@@ -293,6 +297,9 @@ function AdaptiveWNGradientStepsize(
         0,
     )
 end
+function AdaptiveWNGradientStepsize(M::AbstractManifold, p; kwargs...)
+    return AdaptiveWNGradientStepsize(M; p = p, kwargs...)
+end
 function (awng::AdaptiveWNGradientStepsize)(
         mp::AbstractManoptProblem,
         s::AbstractGradientSolverState,
@@ -402,7 +409,7 @@ $(_kwargs(:p)) only used to define the `gradient_bound`
 $(_kwargs(:X)) only used to define the `gradient_bound`
 """
 function AdaptiveWNGradient(args...; kwargs...)
-    return ManifoldDefaultsFactory(Manopt.AdaptiveWNGradientStepsize, args...; kwargs...)
+    return ManifoldDefaultsFactory(Manopt.AdaptiveWNGradientStepsize, args...; requires_point = true, kwargs...)
 end
 
 """
@@ -508,6 +515,7 @@ $(_fields(:vector_transport_method))
 # Constructor
 
     CubicBracketingLinesearchStepsize(M::AbstractManifold; kwargs...)
+    CubicBracketingLinesearchStepsize(M::AbstractManifold, p; kwargs...)
 
 ## Keyword arguments
 
@@ -559,6 +567,13 @@ mutable struct CubicBracketingLinesearchStepsize{
         return new{R, I, TRM, VTM, P, T}(candidate_direction, candidate_point, initial_stepsize, initial_stepsize, retraction_method, stepsize_increase, max_iterations, sufficient_curvature, min_bracket_width, hybrid, vector_transport_method, max_stepsize)
     end
 end
+function CubicBracketingLinesearchStepsize(M::AbstractManifold, p; kwargs...)
+    candidate_point = allocate(p)
+    candidate_direction = zero_vector(M, candidate_point)
+    return CubicBracketingLinesearchStepsize(
+        M; candidate_point = candidate_point, candidate_direction = candidate_direction, kwargs...
+    )
+end
 
 """
     UnivariateTriple{R <: Real}
@@ -848,7 +863,7 @@ $(_kwargs(:vector_transport_method))
 $(_note(:ManifoldDefaultFactory, "CubicBracketingLinesearch"))
 """
 function CubicBracketingLinesearch(args...; kwargs...)
-    return ManifoldDefaultsFactory(CubicBracketingLinesearchStepsize, args...; kwargs...)
+    return ManifoldDefaultsFactory(CubicBracketingLinesearchStepsize, args...; requires_point = true, kwargs...)
 end
 
 
@@ -992,8 +1007,8 @@ mutable struct DistanceOverGradientsStepsize{R <: Real, P} <: Stepsize
 end
 
 function DistanceOverGradientsStepsize(
-        M::AbstractManifold;
-        p = rand(M),
+        M::AbstractManifold,
+        p;
         initial_distance::R1 = 1.0e-3,
         use_curvature::Bool = false,
         sectional_curvature_bound::R2 = 0.0,
@@ -1164,7 +1179,7 @@ $(doc_DoG_main)
 $(_note(:ManifoldDefaultFactory, "DistanceOverGradientsStepsize"))
 """
 function DistanceOverGradients(args...; kwargs...)
-    return ManifoldDefaultsFactory(Manopt.DistanceOverGradientsStepsize, args...; kwargs...)
+    return ManifoldDefaultsFactory(Manopt.DistanceOverGradientsStepsize, args...; requires_point = true, kwargs...)
 end
 
 @doc """
@@ -1194,6 +1209,7 @@ $(_kwargs(:vector_transport_method))
 # Constructor
 
     NonmonotoneLinesearchStepsize(M::AbstractManifold; kwargs...)
+    NonmonotoneLinesearchStepsize(M::AbstractManifold, p; kwargs...)
 
 ## Keyword arguments
 
@@ -1315,6 +1331,9 @@ mutable struct NonmonotoneLinesearchStepsize{
         )
     end
 end
+function NonmonotoneLinesearchStepsize(M::AbstractManifold, p; kwargs...)
+    return NonmonotoneLinesearchStepsize(M; p = allocate(p), kwargs...)
+end
 function (a::NonmonotoneLinesearchStepsize)(
         mp::AbstractManoptProblem,
         s::AbstractManoptSolverState,
@@ -1529,7 +1548,7 @@ $(_kwargs(:retraction_method))
 * `stop_decreasing_at_step=1000`: last step size to decrease the stepsize (phase 2),
 """
 function NonmonotoneLinesearch(args...; kwargs...)
-    return ManifoldDefaultsFactory(NonmonotoneLinesearchStepsize, args...; kwargs...)
+    return ManifoldDefaultsFactory(NonmonotoneLinesearchStepsize, args...; requires_point = true, kwargs...)
 end
 
 @doc """
@@ -1640,6 +1659,7 @@ $(_fields(:vector_transport_method))
 # Constructor
 
     WolfePowellLinesearchStepsize(M::AbstractManifold; kwargs...)
+    WolfePowellLinesearchStepsize(M::AbstractManifold, p; kwargs...)
 
 ## Keyword arguments
 
@@ -1705,6 +1725,13 @@ mutable struct WolfePowellLinesearchStepsize{
         )
     end
 end
+function WolfePowellLinesearchStepsize(M::AbstractManifold, p; kwargs...)
+    candidate_point = allocate(p)
+    candidate_direction = zero_vector(M, candidate_point)
+    return WolfePowellLinesearchStepsize(
+        M; p = candidate_point, X = candidate_direction, kwargs...
+    )
+end
 function (a::WolfePowellLinesearchStepsize)(
         mp::AbstractManoptProblem,
         ams::AbstractManoptSolverState,
@@ -1847,7 +1874,7 @@ $(_kwargs(:retraction_method))
 $(_kwargs(:vector_transport_method))
 """
 function WolfePowellLinesearch(args...; kwargs...)
-    return ManifoldDefaultsFactory(WolfePowellLinesearchStepsize, args...; kwargs...)
+    return ManifoldDefaultsFactory(WolfePowellLinesearchStepsize, args...; requires_point = true, kwargs...)
 end
 
 @doc """

src/solvers/FrankWolfe.jl

@@ -284,8 +284,10 @@ function Frank_Wolfe_method!(
                     M;
                     p = copy(M, p),
                     stopping_criterion = sub_stopping_criterion,
-                    stepsize = default_stepsize(
-                        M, GradientDescentState; retraction_method = retraction_method
+                    stepsize = _produce_type(
+                        default_stepsize(
+                            M, GradientDescentState; retraction_method = retraction_method
+                        ), M, p
                     ),
                     sub_kwargs...,
                 );
@@ -309,7 +311,7 @@ function Frank_Wolfe_method!(
         p = p,
         X = X,
         retraction_method = retraction_method,
-        stepsize = _produce_type(stepsize, M),
+        stepsize = _produce_type(stepsize, M, p),
         stopping_criterion = stopping_criterion,
     )
     dfws = decorate_state!(fws; kwargs...)

src/solvers/conjugate_gradient_descent.jl

@@ -160,8 +160,8 @@ function conjugate_gradient_descent!(
         M;
         p = p,
         stopping_criterion = stopping_criterion,
-        stepsize = _produce_type(stepsize, M),
-        coefficient = _produce_type(coefficient, M),
+        stepsize = _produce_type(stepsize, M, p),
+        coefficient = _produce_type(coefficient, M, p),
         restart_condition = restart_condition,
         retraction_method = retraction_method,
         vector_transport_method = vector_transport_method,