Internal

GAP.versioninfo — Function

versioninfo(io::IO = stdout; jll::Bool = false, full::Bool = false)

Print the version numbers of GAP.jl and GAP, and version numbers and installation paths of all currently loaded GAP packages. Note that these paths can be nonstandard because Julia's package manager does not control which available version of a GAP package gets loaded.

If jll or full is true then also the underlying binary packages (jll), if available, of all installed (not necessarily loaded) packages are included in the output.

source

GAP.get_symbols_in_module — Function

get_symbols_in_module(m::Module) :: Vector{Symbol}

Return all symbols in the module m. This is used in a GAP method for RecNames.

source

GAP.GAP — Module

GAP.jl is the Julia interface to the GAP-System.

For the package manual see https://oscar-system.github.io/GAP.jl/.

For more information about GAP see https://www.gap-system.org/.

source

GAP.RecDict_g — Type

RecDict_g = IdDict{Any,Any}

An internal type of GAP.jl used for tracking conversion results in julia_to_gap. The value stored at the key obj is the result of the Julia to GAP conversion of obj.

source

GAP.RecDict_j — Type

RecDict_j = IdDict{Tuple{Any, Type}, Any}

An internal type of GAP.jl used for tracking conversion results in gap_to_julia. The value stored at the key (obj, T) is the result of the GAP to Julia conversion of obj that has type T. Note that several Julia types can occur for the same GAP object.

Lookups for the key (obj, T) in an IdDict are successful if the conversion result of an object identical to obj with target type T has been stored in the dictionary.

Note that comparing two GapObjs with === yields the same result as comparing them with GAP.Globals.IsIdenticalObj because GapObj is a mutable type.

source

GAP.GapObj_internal — Function

GapObj_internal(x::Any, rec_dict::GapCacheDict, ::Val{recursive}) where recursive

Return a GapObj that corresponds to the Julia object x.

The value of recursive can be GAP.BoolVal(true) or GAP.BoolVal(false), the former meaning that subobjects of x shall get converted recursively, the latter meaning that no recursion is requested. In the case of recursive conversion, a dictionary is used as the value of rec_dict in order to make sure that identical subobjects of x correspond to identical subobjects in the result of the conversion. This dictionary is created automatically on demand, it should never be supplied by the user.

The function GapObj_internal may call GapObj, but the other direction is not allowed.

New methods for Julia-to-GAP conversions must be implemented via methods for GapObj_internal not for GapObj.

source

GAP.gap_to_julia_internal — Function

gap_to_julia_internal(::Type{T}, x::Any, rec_dict::JuliaCacheDict, ::Val{recursive}) where {T, recursive}

Return an object of type T that corresponds to the GAP object x.

The value of recursive can be Val(true) or Val(false), the former meaning that subobjects of x shall get converted recursively, the latter meaning that no recursion is requested. In the case of recursive conversion, a dictionary is used as the value of rec_dict in order to make sure that identical subobjects of x correspond to identical subobjects in the result of the conversion. This dictionary is created automatically on demand, it should never be supplied by the user.

The function gap_to_julia may call gap_to_julia_internal, but the other direction is not allowed.

New methods for GAP-to-Julia conversions must be implemented via methods for gap_to_julia_internal not for gap_to_julia.

source

GAP._gap_to_julia — Function

_gap_to_julia([::Type{T}, ]x::Obj[, recursive::Bool])

This function implements the GAP function GAPToJulia. It just delegates to gap_to_julia. Its purpose is to turn the recursive argument into a keyword argument, which is easier in Julia than in GAP.

source

GAP._default_type — Function

_default_type(x::GapObj, recursive::Bool)

Return T, rec where T is a Julia type to which x will be converted by gap_to_julia if no type is prescribed, and rec is a Boolean indicating whether recursive conversion of x makes sense.

T depends on the GAP filters of x. If recursive is false then rec is also false.

The return value Any, false means that no default is provided, that is, converting x to Julia with gap_to_julia requires a type as the first argument.

source

GAP.kwarg_wrapper — Function

kwarg_wrapper(func, args::Vector{T1}, kwargs::Dict{Symbol,T2}) where {T1, T2}

Call the function func with arguments args and keyword arguments given by the keys and values of kwargs.

This function is used on the GAP side, in calls of Julia functions that require keyword arguments.

Examples

julia> range(2, length = 5, step = 2)
2:2:10

julia> GAP.kwarg_wrapper(range, [2], Dict(:length => 5, :step => 2))
2:2:10

source