Private API

struct ADNLPTag <: CTSolvers.AbstractTag

Tag type for ADNLP-specific implementation dispatch.

__adnlp_model_backend() -> Symbol

Return the default automatic differentiation backend for Modelers.ADNLP.

Default is :optimized.

__consistent_backend(
    _::Type{<:CTSolvers.Strategies.AbstractStrategyParameter},
    backend
) -> Bool

Check if backend is consistent with parameter type.

Arguments

• parameter_type::Type{<:AbstractStrategyParameter}: CPU or GPU parameter
• backend: Backend to check consistency for

Returns

• Bool: true if consistent, false otherwise

Notes

• Default implementation returns true (all combinations allowed)
• Specific implementations in extensions provide actual consistency checks

__exa_model_backend()

Return the default execution backend for Modelers.Exa.

Default is nothing (CPU).

__exa_model_backend(_::Type{CTSolvers.Strategies.CPU})

Return the default execution backend for CPU parameter.

Always returns nothing for CPU execution.

__exa_model_backend(P::Type{CTSolvers.Strategies.GPU})

Return the default execution backend for GPU parameter.

Returns CUDA backend if available, throws ExtensionError otherwise.

__exa_model_base_type() -> Type{Float64}

Return the default floating-point type for Modelers.Exa.

Default is Float64.

__get_cuda_backend(_::Type{<:CTSolvers.Strategies.GPU})

Get CUDA backend for GPU execution.

This function checks if CUDA.jl is available and functional, and returns an appropriate CUDA backend.

Returns

• CUDA backend object if CUDA is available and functional

Throws

• CTBase.Exceptions.ExtensionError: If CUDA is not loaded or not functional

Notes

• Issues a warning if CUDA is loaded but not functional
• Uses CUDA.CUDABackend() for GPU execution

get_validate_adnlp_backend(
    T::Type{<:CTSolvers.AbstractTag}
) -> CTSolvers.Modelers.var"#get_validate_adnlp_backend##0#get_validate_adnlp_backend##1"

Factory function that returns a backend validator for the specified tag type.

Arguments

• T::Type{<:AbstractTag}: Tag type for dispatch (e.g., ADNLPTag, DummyTag)

Returns

• Function: Validator function that takes backend and validates it

Examples

julia> using CTSolvers.Modelers

julia> # Get validator for ADNLP (with extensions loaded)
julia> validator = get_validate_adnlp_backend(ADNLPTag)
(backend)->validate_adnlp_backend(#=method=#1, #=generic#=)

julia> validator(:default)
:default

julia> validator(:enzyme)  # Works with CTSolversEnzyme extension
:enzyme

julia> # Get validator for dummy tag (no extensions)
julia> dummy_validator = get_validate_adnlp_backend(DummyTag)
(backend)->validate_adnlp_backend(#=method=#1, #=generic#=)

julia> dummy_validator(:enzyme)  # Throws ExtensionError
ERROR: Control Toolbox Error
❌ Error: CTBase.Exceptions.ExtensionError, to use Enzyme backend with ADNLP modeler

Notes

• Creates a closure that converts Symbol to Val for type-safe dispatch
• Used by ADNLP metadata system for runtime validation
• Extensions enable specific backends for their tag types
• Default implementations throw ExtensionError for Enzyme/Zygote backends

See also: validate_adnlp_backend, ADNLPTag, Modelers.ADNLP

validate_adnlp_backend(
    tag::CTSolvers.AbstractTag,
    backend::Val
) -> Symbol

Fallback method for invalid ADNLP backends using tag dispatch.

Arguments

• tag::AbstractTag: Tag for dispatch (e.g., ADNLPTag, DummyTag)
• backend::Val: Backend type as Val for dispatch (invalid backend)

Throws

• CTBase.Exceptions.IncorrectArgument: Always thrown for invalid backends

Notes

• This method is called when no more specific method matches the backend
• Provides comprehensive error message with valid backend options
• Uses structured exception with got/expected/suggestion fields

See also: validate_adnlp_backend(::AbstractTag, ::Val{:default}), get_validate_adnlp_backend

validate_adnlp_backend(
    tag::CTSolvers.AbstractTag,
    _::Val{:default}
) -> Symbol

Validate always-available ADNLP backends using tag dispatch.

Arguments

• tag::AbstractTag: Tag for dispatch (e.g., ADNLPTag, DummyTag)
• backend::Val{:default}: Default backend type
• backend::Val{:optimized}: Optimized backend type
• backend::Val{:generic}: Generic backend type
• backend::Val{:manual}: Manual backend type

Returns

• Symbol: Validated backend symbol (unchanged)

Notes

• These methods handle backends that are always available regardless of extensions
• Uses Julia's multiple dispatch for type-safe validation
• Extensions can override these methods for tag-specific behavior

See also: validate_adnlp_backend(::AbstractTag, ::Val{:enzyme}), get_validate_adnlp_backend

validate_adnlp_backend(
    tag::CTSolvers.AbstractTag,
    _::Val{:enzyme}
)

Validate Enzyme backend using tag dispatch.

Arguments

• tag::AbstractTag: Tag for dispatch (e.g., ADNLPTag, DummyTag)
• backend::Val{:enzyme}: Enzyme backend type

Throws

• CTBase.Exceptions.ExtensionError: If CTSolversEnzyme extension is not loaded

Notes

• Default implementation throws ExtensionError for all tags except ADNLPTag with extension
• CTSolversEnzyme extension overrides this method for ADNLPTag when Enzyme is available
• Provides clear error message directing users to load the extension

See also: validate_adnlp_backend(::AbstractTag, ::Val{:zygote}), get_validate_adnlp_backend

validate_adnlp_backend(
    tag::CTSolvers.AbstractTag,
    _::Val{:zygote}
)

Validate Zygote backend using tag dispatch.

Arguments

• tag::AbstractTag: Tag for dispatch (e.g., ADNLPTag, DummyTag)
• backend::Val{:zygote}: Zygote backend type

Throws

• CTBase.Exceptions.ExtensionError: If CTSolversZygote extension is not loaded

Notes

• Default implementation throws ExtensionError for all tags except ADNLPTag with extension
• CTSolversZygote extension overrides this method for ADNLPTag when Zygote is available
• Provides clear error message directing users to load the extension

See also: validate_adnlp_backend(::AbstractTag, ::Val{:enzyme}), get_validate_adnlp_backend

validate_backend_override(
    backend
) -> Union{Nothing, ADNLPModels.ADBackend, Type}

Validate that a backend override is either nothing, a Type{<:ADBackend}, or an ADBackend instance.

ADNLPModels.jl accepts both types (to be constructed internally) and pre-constructed instances.

Arguments

• backend: The backend to validate (any value accepted for dispatch)

Throws

• CTBase.Exceptions.IncorrectArgument: If the backend is not nothing, a Type{<:ADBackend}, or an ADBackend instance

Examples

validate_backend_override(nothing)
validate_backend_override(ADNLPModels.ForwardDiffADGradient)
validate_backend_override(ADNLPModels.ForwardDiffADGradient())

# Throws CTBase.Exceptions.IncorrectArgument
validate_backend_override("invalid")

validate_exa_base_type(
    T::Type{<:AbstractFloat}
) -> Type{<:AbstractFloat}

Validate that the specified base type is appropriate for ExaModels.

Arguments

• T::Type{<:AbstractFloat}: The floating-point type to validate

Returns

• Type{<:AbstractFloat}: The validated type (unchanged)

Notes

• Uses Julia's dispatch system for type-safe validation
• Valid types include Float64, Float32, Float16, BigFloat
• Invalid types throw IncorrectArgument with helpful error message

Examples

julia> using CTSolvers.Modelers

julia> validate_exa_base_type(Float64)
Float64

julia> validate_exa_base_type(Float32)
Float32

# Throws IncorrectArgument for invalid types
julia> validate_exa_base_type(Int)
ERROR: Control Toolbox Error
❌ Error: CTBase.Exceptions.IncorrectArgument, Invalid base type for Modelers.Exa

See also: Modelers.Exa

validate_exa_base_type(T) -> Type{<:AbstractFloat}

Fallback method for invalid base types in ExaModels validation.

Arguments

• T::Type: The type to validate (not a subtype of AbstractFloat)

Throws

• CTBase.Exceptions.IncorrectArgument: Always thrown for invalid types

Notes

• This method is called when no more specific method matches
• Provides clear error message with suggestions for valid types
• Uses structured exception with got/expected/suggestion fields

See also: validate_exa_base_type(::Type{<:AbstractFloat})

validate_matrix_free(matrix_free::Bool) -> Bool
validate_matrix_free(
    matrix_free::Bool,
    problem_size::Int64
) -> Bool

Validate matrix-free mode setting and provide recommendations.

Arguments

• matrix_free::Bool: Whether to use matrix-free mode
• problem_size::Int: Size of the optimization problem (default: 1000)

Returns

• Bool: Validated matrix-free setting

Examples

validate_matrix_free(true, 10_000)
validate_matrix_free(false, 1_000_000)

validate_model_name(name::String) -> String

Validate that the model name is appropriate.

Arguments

• name::String: The model name to validate

Throws

• CTBase.Exceptions.IncorrectArgument: If the name is invalid

Examples

validate_model_name("MyProblem")

# Throws CTBase.Exceptions.IncorrectArgument
validate_model_name("")

validate_optimization_direction(minimize::Bool) -> Bool

Validate that the optimization direction is a boolean value.

Arguments

• minimize::Bool: The optimization direction to validate

Throws

• CTBase.Exceptions.IncorrectArgument: If the value is not a boolean

Examples

validate_optimization_direction(true)
validate_optimization_direction(false)