  
  [1X2 [33X[0;0YUsing [5XJulia[105X[101X[1X from [5XGAP[105X[101X[1X[133X[101X
  
  
  [1X2.1 [33X[0;0YFilters for [5XJuliaInterface[105X[101X[1X[133X[101X
  
  [1X2.1-1 IsJuliaObject[101X
  
  [33X[1;0Y[29X[2XIsJuliaObject[102X( [3Xobj[103X ) [32X Category[133X
  [6XReturns:[106X  [33X[0;10Y[9Xtrue[109X or [9Xfalse[109X[133X
  
  [33X[0;0YThe result is [9Xtrue[109X if and only if [3Xobj[103X is a pointer to a [5XJulia[105X object.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27Xjulia_fun:= JuliaEvalString( "sqrt" );[127X[104X
    [4X[28X<Julia: sqrt>[128X[104X
    [4X[25Xgap>[125X [27XIsJuliaObject( julia_fun );[127X[104X
    [4X[28Xtrue[128X[104X
    [4X[25Xgap>[125X [27Xjulia_val:= julia_fun( 2 );[127X[104X
    [4X[28X<Julia: 1.4142135623730951>[128X[104X
    [4X[25Xgap>[125X [27XIsJuliaObject( julia_val );[127X[104X
    [4X[28Xtrue[128X[104X
  [4X[32X[104X
  
  [33X[0;0YHowever  not  every  object  living on the Julia side is in this filter. For
  example  Julia  booleans and small [10XInt[110X values are directly translated to GAP
  booleans  and  small  integers, while for Julia functions dedicated wrappers
  are used to improve efficiency and add features.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27XJuliaEvalString( "x = 4" );;[127X[104X
    [4X[25Xgap>[125X [27XJulia.x;[127X[104X
    [4X[28X4[128X[104X
    [4X[25Xgap>[125X [27XIsJuliaObject( Julia.x );[127X[104X
    [4X[28Xfalse[128X[104X
    [4X[25Xgap>[125X [27XIsJuliaObject( Julia.sqrt );[127X[104X
    [4X[28Xfalse[128X[104X
  [4X[32X[104X
  
  [1X2.1-2 JuliaPointer[101X
  
  [33X[1;0Y[29X[2XJuliaPointer[102X( [3Xobj[103X ) [32X attribute[133X
  
  [33X[0;0Yis  an  attribute for storing a [5XJulia[105X object in a [5XGAP[105X object. The value must
  be a [5XJulia[105X object.[133X
  
  [1X2.1-3 IsJuliaModule[101X
  
  [33X[1;0Y[29X[2XIsJuliaModule[102X( [3Xobj[103X ) [32X Category[133X
  [6XReturns:[106X  [33X[0;10Y[9Xtrue[109X or [9Xfalse[109X[133X
  
  [33X[0;0YThis  filter  is  set  in  those  [5XGAP[105X  objects that represent [5XJulia[105X modules.
  Members of a [5XJulia[105X module can be accessed like record components.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27XIsJuliaModule( Julia );[127X[104X
    [4X[28Xtrue[128X[104X
    [4X[25Xgap>[125X [27XGAP_jl;[127X[104X
    [4X[28X<Julia module GAP>[128X[104X
    [4X[25Xgap>[125X [27XIsJuliaModule( GAP_jl );[127X[104X
    [4X[28Xtrue[128X[104X
    [4X[25Xgap>[125X [27XGAP_jl.prompt;[127X[104X
    [4X[28X<Julia: prompt>[128X[104X
  [4X[32X[104X
  
  
  [1X2.2 [33X[0;0YCreating [5XJulia[105X[101X[1X objects[133X[101X
  
  [1X2.2-1 JuliaEvalString[101X
  
  [33X[1;0Y[29X[2XJuliaEvalString[102X( [3Xstring[103X ) [32X function[133X
  
  [33X[0;0Yevaluates  the  string  [3Xstring[103X  in  the  current  [5XJulia[105X session, in the [10XMain[110X
  module, and returns [5XJulia[105X's return value.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27XJuliaEvalString( "x = 2^2" );  # assignment to a variable in Julia[127X[104X
    [4X[28X4[128X[104X
    [4X[25Xgap>[125X [27XJuliaEvalString( "x" );        # access to this variable[127X[104X
    [4X[28X4[128X[104X
  [4X[32X[104X
  
  [1X2.2-2 JuliaType[101X
  
  [33X[1;0Y[29X[2XJuliaType[102X( [3XT[103X, [3Xparameters[103X ) [32X function[133X
  
  [33X[0;0Ycreates the parametrized [5XJulia[105X type [3XT[103X[10X{para1, para2, ...}[110X, where [3XT[103X is a [5XJulia[105X
  type  and  [3Xparameters[103X  is  a list of [5XJulia[105X types which are its intended type
  parameters.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27XJuliaType( Julia.Vector, [ Julia.Int ] );[127X[104X
    [4X[28X<Julia: Vector{Int64}>[128X[104X
    [4X[25Xgap>[125X [27XJuliaType( Julia.Tuple, [ Julia.Int, Julia.Int ] );[127X[104X
    [4X[28X<Julia: Tuple{Int64, Int64}>[128X[104X
    [4X[25Xgap>[125X [27XJuliaType( Julia.Tuple,[127X[104X
    [4X[25X>[125X [27X     [ JuliaType( Julia.Vector, [ Julia.Int ] ),[127X[104X
    [4X[25X>[125X [27X       JuliaType( Julia.Matrix, [ Julia.Int ] ) ] );[127X[104X
    [4X[28X<Julia: Tuple{Vector{Int64}, Matrix{Int64}}>[128X[104X
  [4X[32X[104X
  
  [1X2.2-3 JuliaIncludeFile[101X
  
  [33X[1;0Y[29X[2XJuliaIncludeFile[102X( [3Xfilename[103X[, [3Xmodule_name[103X] ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ynothing.[133X
  
  [33X[0;0Ycalls  [5XJulia[105X's [10XBase.include[110X with the strings [3Xfilename[103X (an absolute filename,
  as  returned by [2XFilename[102X ([14XReference: Filename[114X)) and [3Xmodule_name[103X (the name of
  a  [5XJulia[105X  module,  the default is [10X"Main"[110X). This means that the [5XJulia[105X code in
  the  file  with name [3Xfilename[103X gets executed in the current [5XJulia[105X session, in
  the context of the [5XJulia[105X module [3Xmodule_name[103X.[133X
  
  [1X2.2-4 JuliaImportPackage[101X
  
  [33X[1;0Y[29X[2XJuliaImportPackage[102X( [3Xpkgname[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Y[9Xtrue[109X or [9Xfalse[109X.[133X
  
  [33X[0;0YThis  function  triggers  the execution of an [10Ximport[110X statement for the [5XJulia[105X
  package  with  name [3Xpkgname[103X. It returns [9Xtrue[109X if the call was successful, and
  [9Xfalse[109X otherwise.[133X
  
  [33X[0;0YNote  that  we  just  want to load the package into [5XJulia[105X, we do [13Xnot[113X want to
  import variable names from the package into [5XJulia[105X's [10XMain[110X module, because the
  [5XJulia[105X  variables  must be referenced relative to their modules if we want to
  be sure to access the correct values.[133X
  
  [33X[0;0YWhy is this function needed?[133X
  
  [33X[0;0YApparently  [10Xlibjulia[110X  throws  an  error  when trying to compile the package,
  which  happens  when  some  files  from the package have been modified since
  compilation.[133X
  
  [33X[0;0YThus   [5XGAP[105X   has  to  check  whether  the  [5XJulia[105X  package  has  been  loaded
  successfully,  and can then safely load and execute code that relies on this
  [5XJulia[105X  package.  In  particular,  we  cannot  just  put the necessary [10Ximport[110X
  statements  into  the  relevant  [11X.jl[111X  files,  and then load these files with
  [2XJuliaIncludeFile[102X ([14X2.2-3[114X).[133X
  
  
  [1X2.3 [33X[0;0YAccess to [5XJulia[105X[101X[1X objects[133X[101X
  
  [33X[0;0YNot  all [5XJulia[105X syntax features are supported in [5XGAP[105X. For important ones, the
  interface provides [5XGAP[105X functions or helper functions written in [5XJulia[105X to use
  them  in  [5XGAP[105X. For example, [2XCallJuliaFunctionWithCatch[102X ([14X2.3-2[114X) allows one to
  use [5XJulia[105X's try/catch statements.[133X
  
  [33X[0;0YHere is a selection of other workarounds for [5XJulia[105X syntax features.[133X
  
  [30X    [33X[0;6Y[5XJulia[105X's  [10XRefValue[110X  objects  can be handled as follows. If [10Xx[110X is such an
        object  then  its  value  can  be fetched with [10XGAP_jl.getindex( x )[110X, a
        value [10Xv[110X of the right type can be set with [10XGAP_jl.setindex( x, v )[110X, and
        one can check with [10XGAP_jl.isassigned( x )[110X whether [10Xx[110X has a value.[133X
  
  [1X2.3-1 Julia[101X
  
  [33X[1;0Y[29X[2XJulia[102X [32X global variable[133X
  
  [33X[0;0YThis  global  variable  represents  the [5XJulia[105X module [10XMain[110X, see [2XIsJuliaModule[102X
  ([14X2.1-3[114X).[133X
  
  [33X[0;0YThe  variables  from the underlying [5XJulia[105X session can be accessed via [2XJulia[102X,
  as follows.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27XJulia.sqrt;  # a Julia function[127X[104X
    [4X[28X<Julia: sqrt>[128X[104X
    [4X[25Xgap>[125X [27XJuliaEvalString( "x = 1" );  # an assignment in the Julia session[127X[104X
    [4X[28X1[128X[104X
    [4X[25Xgap>[125X [27XJulia.x;  # access to the value that was just assigned[127X[104X
    [4X[28X1[128X[104X
    [4X[25Xgap>[125X [27XJulia.Main.x;[127X[104X
    [4X[28X1[128X[104X
  [4X[32X[104X
  
  [33X[0;0YNote  that  not all [5XJulia[105X variables are directly visible in its [10XMain[110X module.
  For  example,  [5XJulia[105X  variables from the interface to [5XGAP[105X are defined in the
  [5XJulia[105X  module  [10XGAP[110X  or  its  submodules. It is safe to access this module as
  [10XGAP_jl[110X.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27XGAP_jl;[127X[104X
    [4X[28X<Julia module GAP>[128X[104X
    [4X[25Xgap>[125X [27XGAP_jl.prompt;[127X[104X
    [4X[28X<Julia: prompt>[128X[104X
  [4X[32X[104X
  
  [1X2.3-2 CallJuliaFunctionWithCatch[101X
  
  [33X[1;0Y[29X[2XCallJuliaFunctionWithCatch[102X( [3Xjuliafunc[103X, [3Xarguments[103X[, [3Xkwargs[103X] ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ya record.[133X
  
  [33X[0;0YThe  function  calls the [5XJulia[105X function [3Xjuliafunc[103X with ordinary arguments in
  the  [5XGAP[105X  list  [3Xarguments[103X and optionally with keyword arguments given by the
  component  names  (keys)  and values of the [5XGAP[105X record [3Xkwargs[103X, and returns a
  record  with  the  components [10Xok[110X and [10Xvalue[110X. If no error occurred then [10Xok[110X has
  the  value  [9Xtrue[109X,  and [10Xvalue[110X is the value returned by [3Xjuliafunc[103X. If an error
  occurred  then  [10Xok[110X  has the value [9Xfalse[109X, and [10Xvalue[110X is the error message as a
  [5XGAP[105X string.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27Xfun:= Julia.sqrt;;[127X[104X
    [4X[25Xgap>[125X [27XCallJuliaFunctionWithCatch( fun, [ 2 ] );[127X[104X
    [4X[28Xrec( ok := true, value := <Julia: 1.4142135623730951> )[128X[104X
    [4X[25Xgap>[125X [27Xres:= CallJuliaFunctionWithCatch( fun, [ -1 ] );;[127X[104X
    [4X[25Xgap>[125X [27Xres.ok;[127X[104X
    [4X[28Xfalse[128X[104X
    [4X[25Xgap>[125X [27Xres.value{ [ 1 .. Position( res.value, '(' )-1 ] };[127X[104X
    [4X[28X"DomainError"[128X[104X
    [4X[25Xgap>[125X [27Xinv:= Julia.inv;;[127X[104X
    [4X[25Xgap>[125X [27Xm:= GAPToJulia( JuliaType( Julia.Matrix, [ Julia.Int ] ),[127X[104X
    [4X[25X>[125X [27X                   [ [ 1, 2 ], [ 2, 4 ] ] );[127X[104X
    [4X[28X<Julia: [1 2; 2 4]>[128X[104X
    [4X[25Xgap>[125X [27Xres:= CallJuliaFunctionWithCatch( inv, [ m ] );;[127X[104X
    [4X[25Xgap>[125X [27Xres.ok;[127X[104X
    [4X[28Xfalse[128X[104X
    [4X[25Xgap>[125X [27Xres.value{ [ 1 .. Position( res.value, '(' )-1 ] };[127X[104X
    [4X[28X"LinearAlgebra.SingularException"[128X[104X
    [4X[25Xgap>[125X [27Xfun:= Julia.range;;[127X[104X
    [4X[25Xgap>[125X [27XCallJuliaFunctionWithCatch( fun, [ 2, 10 ], rec( step:= 2 ) );[127X[104X
    [4X[28Xrec( ok := true, value := <Julia: 2:2:10> )[128X[104X
    [4X[25Xgap>[125X [27Xres:= CallJuliaFunctionWithCatch( fun, [ 2, 10 ],[127X[104X
    [4X[25X>[125X [27X             rec( step:= GAPToJulia( "a" ) ) );;[127X[104X
    [4X[25Xgap>[125X [27Xres.ok;[127X[104X
    [4X[28Xfalse[128X[104X
    [4X[25Xgap>[125X [27Xres.value{ [ 1 .. Position( res.value, '(' )-1 ] };[127X[104X
    [4X[28X"MethodError"[128X[104X
  [4X[32X[104X
  
  [1X2.3-3 CallJuliaFunctionWithKeywordArguments[101X
  
  [33X[1;0Y[29X[2XCallJuliaFunctionWithKeywordArguments[102X( [3Xjuliafunc[103X, [3Xarguments[103X, [3Xkwargs[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ythe result of the [5XJulia[105X function call.[133X
  
  [33X[0;0YThe  function  calls the [5XJulia[105X function [3Xjuliafunc[103X with ordinary arguments in
  the  [5XGAP[105X  list  [3Xarguments[103X and keyword arguments given by the component names
  (keys) and values of the record [3Xkwargs[103X, and returns the function value.[133X
  
  [33X[0;0YNote  that  the  entries  of  [3Xarguments[103X and the components of [3Xkwargs[103X are not
  implicitly converted to [5XJulia[105X.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27XCallJuliaFunctionWithKeywordArguments( Julia.Base.round,[127X[104X
    [4X[25X>[125X [27X       [ GAPToJulia( Float( 1/3 ) ) ], rec( digits:= 5 ) );[127X[104X
    [4X[28X<Julia: 0.33333>[128X[104X
    [4X[25Xgap>[125X [27XCallJuliaFunctionWithKeywordArguments([127X[104X
    [4X[25X>[125X [27X       Julia.Base.range, [ 2 ], rec( length:= 5, step:= 2 ) );[127X[104X
    [4X[28X<Julia: 2:2:10>[128X[104X
    [4X[25Xgap>[125X [27Xm:= GAPToJulia( JuliaType( Julia.Matrix, [ Julia.Int ] ),[127X[104X
    [4X[25X>[125X [27X                   [ [ 1, 2 ], [ 3, 4 ] ] );[127X[104X
    [4X[28X<Julia: [1 2; 3 4]>[128X[104X
    [4X[25Xgap>[125X [27XCallJuliaFunctionWithKeywordArguments([127X[104X
    [4X[25X>[125X [27X       Julia.Base.reverse, [ m ], rec( dims:= 1 ) );[127X[104X
    [4X[28X<Julia: [3 4; 1 2]>[128X[104X
    [4X[25Xgap>[125X [27XCallJuliaFunctionWithKeywordArguments([127X[104X
    [4X[25X>[125X [27X       Julia.Base.reverse, [ m ], rec( dims:= 2 ) );[127X[104X
    [4X[28X<Julia: [2 1; 4 3]>[128X[104X
    [4X[25Xgap>[125X [27Xtuptyp:= JuliaType( Julia.Tuple, [ Julia.Int, Julia.Int ]  );;[127X[104X
    [4X[25Xgap>[125X [27Xt1:= GAPToJulia( tuptyp, [ 2, 1 ] );[127X[104X
    [4X[28X<Julia: (2, 1)>[128X[104X
    [4X[25Xgap>[125X [27Xt2:= GAPToJulia( tuptyp, [ 1, 3 ] );[127X[104X
    [4X[28X<Julia: (1, 3)>[128X[104X
    [4X[25Xgap>[125X [27XCallJuliaFunctionWithKeywordArguments([127X[104X
    [4X[25X>[125X [27X       Julia.Base.( "repeat" ), [ m ],[127X[104X
    [4X[25X>[125X [27X       rec( inner:= t1, outer:= t2 ) );[127X[104X
    [4X[28X<Julia: [1 2 1 2 1 2; 1 2 1 2 1 2; 3 4 3 4 3 4; 3 4 3 4 3 4]>[128X[104X
  [4X[32X[104X
  
  
  [1X2.4 [33X[0;0YCalling [5XJulia[105X[101X[1X functions[133X[101X
  
  [33X[0;0YThe  simplest  way to execute [5XJulia[105X code from [5XGAP[105X is to call [2XJuliaEvalString[102X
  ([14X2.2-1[114X) with a string that contains the [5XJulia[105X code in question.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27XJuliaEvalString( "sqrt( 2 )" );[127X[104X
    [4X[28X<Julia: 1.4142135623730951>[128X[104X
  [4X[32X[104X
  
  [33X[0;0YHowever,  it  is  usually more suitable to create [5XGAP[105X variables whose values
  are  [5XJulia[105X  objects,  and to call [5XJulia[105X functions directly. The [5XGAP[105X function
  call syntax is used for that.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27Xjsqrt:= JuliaEvalString( "sqrt" );[127X[104X
    [4X[28X<Julia: sqrt>[128X[104X
    [4X[25Xgap>[125X [27Xjsqrt( 2 );[127X[104X
    [4X[28X<Julia: 1.4142135623730951>[128X[104X
  [4X[32X[104X
  
  [33X[0;0YIn  fact,  there  are  slightly  different  kinds of function calls. A [5XJulia[105X
  function  such  as  [10XJulia.sqrt[110X  is represented by a [5XGAP[105X function object, and
  calls to it are executed on the C level, using [5XJulia[105X's [10Xjl_call[110X.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27Xfun:= Julia.sqrt;[127X[104X
    [4X[28X<Julia: sqrt>[128X[104X
    [4X[25Xgap>[125X [27XIsJuliaObject( fun );[127X[104X
    [4X[28Xfalse[128X[104X
    [4X[25Xgap>[125X [27XIsFunction( fun );[127X[104X
    [4X[28Xtrue[128X[104X
    [4X[25Xgap>[125X [27Xfun( 2 );[127X[104X
    [4X[28X<Julia: 1.4142135623730951>[128X[104X
  [4X[32X[104X
  
  [33X[0;0YNote  that  in [5XJulia[105X any object (not just functions) is potentially callable
  (in fact this is the same as in [5XGAP[105X), for example [5XJulia[105X types can be[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27Xsmalltype:= Julia.Int32;[127X[104X
    [4X[28X<Julia: Int32>[128X[104X
    [4X[25Xgap>[125X [27XIsJuliaObject( smalltype );[127X[104X
    [4X[28Xtrue[128X[104X
    [4X[25Xgap>[125X [27XIsFunction( smalltype );[127X[104X
    [4X[28Xfalse[128X[104X
    [4X[25Xgap>[125X [27Xval:= smalltype( 1 );[127X[104X
    [4X[28X<Julia: 1>[128X[104X
    [4X[25Xgap>[125X [27XJulia.typeof( val );[127X[104X
    [4X[28X<Julia: Int32>[128X[104X
    [4X[25Xgap>[125X [27XJulia.typeof( 1 );[127X[104X
    [4X[28X<Julia: Int64>[128X[104X
  [4X[32X[104X
  
  
  [1X2.4-1 [33X[0;0YConvenience methods for [5XJulia[105X[101X[1X objects[133X[101X
  
  [33X[0;0YFor  the  following operations, methods are installed that require arguments
  in [2XIsJuliaObject[102X ([14X2.1-1[114X) and delegate to the corresponding [5XJulia[105X functions.[133X
  
  [30X    [33X[0;6Y[2XCallFuncList[102X   ([14XReference:   CallFuncList[114X),   delegating   to  [5XJulia[105X's
        [10Xfunc(args...)[110X syntax; this yields the function call syntax in [5XGAP[105X,[133X
  
  [30X    [33X[0;6Yaccess  to  and  assignment of entries of arrays, via [2X\[\][102X ([14XReference:
        \[\][114X), [2X\[\]\:\=[102X ([14XReference: \[\]\:\=[114X), [2XMatElm[102X ([14XReference: MatElm[114X), and
        [2XSetMatElm[102X  ([14XReference:  MatElm[114X), delegating to [10XJulia.Base.getindex[110X and
        [10XJulia.Base.setindex[110X,[133X
  
  [30X    [33X[0;6Yaccess  to and assignment of fields and properties, via [2X\.[102X ([14XReference:
        \.[114X)     and     [2X\.\:\=[102X     ([14XReference:    \.\:\=[114X),    delegating    to
        [10XJulia.Base.getproperty[110X and [10XJulia.Base.setproperty[110X,[133X
  
  [30X    [33X[0;6Ythe   unary   arithmetic   operations   [2XAdditiveInverseOp[102X  ([14XReference:
        AdditiveInverseOp[114X),  [2XZeroOp[102X ([14XReference: ZeroOp[114X), and [2XOneOp[102X ([14XReference:
        OneOp[114X),    delegating    to    [10XJulia.Base.\-[110X,   [10XJulia.Base.zero[110X,   and
        [10XJulia.Base.one[110X,[133X
  
  [30X    [33X[0;6Ythe binary arithmetic operations [2X\+[102X ([14XReference: +[114X), [2X\-[102X ([14XReference: -[114X),
        [2X\*[102X   ([14XReference:  *[114X),  [2X\/[102X  ([14XReference:  /[114X),  [2XLeftQuotient[102X  ([14XReference:
        LeftQuotient[114X),  [2X\^[102X  ([14XReference: ^[114X), [2X\=[102X ([14XReference: \=[114X), [2X\<[102X ([14XReference:
        \<[114X),   delegating   to  [10XJulia.Base.\+[110X,  [10XJulia.Base.\-[110X,  [10XJulia.Base.\*[110X,
        [10XJulia.Base.\/[110X,   [10XJulia.Base.\\[110X,  [10XJulia.Base.\^[110X,  [10XJulia.Base.\=\=[110X,  and
        [10XJulia.Base.\<[110X;  the  same methods are installed also for the case that
        only  one argument is in [2XIsJuliaObject[102X ([14X2.1-1[114X), and the other argument
        is an immediate integer.[133X
  
  [4X[32X  Example  [32X[104X
    [4X[25Xgap>[125X [27Xm:= GAPToJulia( JuliaType( Julia.Matrix, [ Julia.Int ] ),[127X[104X
    [4X[25X>[125X [27X           [ [ 1, 2 ], [ 3, 4 ] ] );[127X[104X
    [4X[28X<Julia: [1 2; 3 4]>[128X[104X
    [4X[25Xgap>[125X [27Xm[1,2];[127X[104X
    [4X[28X2[128X[104X
    [4X[25Xgap>[125X [27X- m;[127X[104X
    [4X[28X<Julia: [-1 -2; -3 -4]>[128X[104X
    [4X[25Xgap>[125X [27Xm + m;[127X[104X
    [4X[28X<Julia: [2 4; 6 8]>[128X[104X
  [4X[32X[104X
  
  
  [1X2.5 [33X[0;0YUtilities[133X[101X
  
  [1X2.5-1 GetJuliaScratchspace[101X
  
  [33X[1;0Y[29X[2XGetJuliaScratchspace[102X( [3Xkey[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ya string[133X
  
  [33X[0;0YReturns  the  path of a [5XJulia[105X scratchspace associated to the given key. This
  scratchspace  gets  created if it did not exist already, one can rely on the
  fact that the returned path describes a writable directory. Subsequent calls
  with the same key yield the same result, and calls with different keys yield
  different  results.  The  directory  may  be removed by [5XJulia[105X as soon as the
  [5XJulia[105X package [10XGAP.jl[110X gets uninstalled.[133X
  
  
  [1X2.6 [33X[0;0YAccess [5XJulia[105X[101X[1X help from a [5XGAP[105X[101X[1X session[133X[101X
  
  [33X[0;0YIn  a [5XJulia[105X session, one can ask for help about the object with the name [10Xobj[110X
  (a function or a type) by entering [10X?obj[110X, and [5XJulia[105X prints all matches to the
  screen. One can get the same output in a [5XGAP[105X session by entering [10X?Julia:obj[110X,
  cf.  Section [14X'Reference: Invoking the Help'[114X in the [5XGAP[105X Reference Manual. For
  example,  [10X?Julia:sqrt[110X  shows  the  [5XJulia[105X  help about the [5XJulia[105X function [10Xsqrt[110X
  (which is available in [5XGAP[105X as [10XJulia.sqrt[110X).[133X
  
  [33X[0;0YNote  that  this  way  to  access the [5XJulia[105X help is different from the usual
  access to [5XGAP[105X help books, in the following sense.[133X
  
  [30X    [33X[0;6YThe qualifying prefix [10XJulia:[110X is mandatory. Thus the help request [10X?sqrt[110X
        will show matches from usual [5XGAP[105X help books (there is one match in the
        [5XGAP[105X Reference Manual), but not the help about the [5XJulia[105X function [10Xsqrt[110X.[133X
  
  [30X    [33X[0;6YSince  the  prefix  [10XJulia:[110X does not belong to a [21Xpreprocessed[121X help book
        with  chapters,  sections, index, etc., help requests of the kinds [10X?<[110X,
        [10X?<<[110X, [10X?>[110X, [10X?>>[110X are not meaningful when the previous help request had the
        prefix  [10X?Julia:[110X.  (Also requests with the prefix [10X??Julia:[110X do not work,
        but this holds also for usual [5XGAP[105X help books.)[133X
  
  [30X    [33X[0;6YThe  [5XJulia[105X  help  system  is case sensitive. Thus [10X?Julia:sqrt[110X yields a
        match  but  [10X?Julia:Sqrt[110X  does  not,  and [10X?Julia:Set[110X yields a match but
        [10X?Julia:set[110X does not.[133X
  
  [30X    [33X[0;6YThe  [5XJulia[105X  help  system  does  currently not support menus in case of
        multiple matches, all matches are shown at once, and this happens also
        in a [5XGAP[105X session.[133X
  
  [30X    [33X[0;6YNo PDF or HTML version of the [5XJulia[105X help is supported in [5XGAP[105X, only the
        text format can be shown on the screen. Thus it does not make sense to
        change  the  help  viewer,  cf.  Section [14X'Reference: Changing the Help
        Viewer'[114X in the [5XGAP[105X Reference Manual.[133X
  
  [30X    [33X[0;6Y[5XJulia[105X  functions  belong to [5XJulia[105X modules. Many [5XJulia[105X functions can be
        accessed  only  relative  to  their  modules,  and  then also the help
        requests   work   only   for   the   qualified   names.  For  example,
        [10X?Julia:GAP.wrap_rng[110X  yields  the  description  of  the  [5XJulia[105X function
        [10Xwrap_rng[110X  that is defined in the [5XJulia[105X module [10XGAP[110X, whereas no match is
        found for the input [10X?Julia:wrap_rng[110X.[133X
  
