From 40dda1f610f41552e13f006175cb6b5340f96e32 Mon Sep 17 00:00:00 2001
From: ThomasBreuer <sam@math.rwth-aachen.de>
Date: Wed, 25 Jul 2018 14:19:34 +0200
Subject: [PATCH] support converting Nemo polynomials to GAP

- added new GAP functions `GAPCoefficientsOfNemo_Polynomial`,
  `ElementOfNemoNumberField`,
  and corresponding Julia functions

- increase the rank of generic methods for `IsNemoObject` arguments,
  otherwise the GAP library methods for polynomials are preferred

- simplified syntax:
  now `Julia.Singular.Matrix` and `Julia.Core._apply` are available
---
 JuliaExperimental/gap/numfield.g              | 221 +++++++++++++++---
 JuliaExperimental/gap/record.g                |   2 +-
 .../ipynb/GAPJulia_Singular_blog.ipynb        |   3 +-
 JuliaExperimental/julia/hnf.jl                |   2 +-
 JuliaExperimental/julia/numfield.jl           |  83 ++++---
 JuliaExperimental/julia/utils.jl              |  71 +++++-
 JuliaExperimental/julia/zlattice.jl           |   5 +-
 JuliaExperimental/tst/numfield.tst            |  26 +++
 8 files changed, 345 insertions(+), 68 deletions(-)

diff --git a/JuliaExperimental/gap/numfield.g b/JuliaExperimental/gap/numfield.g
index d139a8963..b22308755 100644
--- a/JuliaExperimental/gap/numfield.g
+++ b/JuliaExperimental/gap/numfield.g
@@ -202,7 +202,56 @@ BindGlobal( "Nemo_Polynomial", function( R, descr )
 
     return ObjectifyWithAttributes( rec(),
         ElementsFamily( FamilyObj( R ) )!.defaultPolynomialType,
-        JuliaPointer, pol );
+        JuliaPointer, pol,
+        ParentAttr, R );
+end );
+
+
+#############################################################################
+##
+#F  GAPCoefficientsOfNemo_Polynomial( <pol> )
+##
+BindGlobal( "GAPCoefficientsOfNemo_Polynomial", function( pol )
+    local R, info, num, den, monomials;
+
+    R:= Parent( pol );
+    if HasJuliaPointer( pol ) then
+      pol:= JuliaPointer( pol );
+    fi;
+
+    if R!.isUnivariatePolynomialRing = true then
+      info:= Julia.GAPUtilsExperimental.CoefficientsOfUnivarateNemoPolynomialFmpq(
+                 pol );
+      info:= Julia.GAPUtilsExperimental.CoefficientsNumDenOfFmpqArray( info );
+      num:= StructuralConvertedFromJulia( info[2] );
+      den:= StructuralConvertedFromJulia( info[3] );
+      if ConvertedFromJulia( info[1] ) = "int" then
+        # Just convert the integers to GAP.
+        return List( [ 1 .. Length( num ) ], i -> num[i] / den[i] );
+      else
+        # The entries are hex strings encoding integers.
+        return List( [ 1 .. Length( num ) ],
+                     i -> IntHexString( num[i] ) / IntHexString( den[i] ) );
+      fi;
+    else
+      info:= JuliaGetFieldOfObject( pol, "coeffs" );
+      info:= Julia.GAPUtilsExperimental.CoefficientsNumDenOfFmpqArray( info );
+      num:= StructuralConvertedFromJulia( info[2] );
+      den:= StructuralConvertedFromJulia( info[3] );
+      if ConvertedFromJulia( info[1] ) = "int" then
+        # Just convert the integers to GAP.
+        info:= List( [ 1 .. Length( num ) ], i -> num[i] / den[i] );
+      else
+        # The entries are hex strings encoding integers.
+        info:= List( [ 1 .. Length( num ) ],
+                     i -> IntHexString( num[i] ) / IntHexString( den[i] ) );
+      fi;
+      monomials:= Julia.GAPUtilsExperimental.NestedArrayFromMatrix(
+                      JuliaGetFieldOfObject( pol, "exps" ) );
+
+      return [ info,
+               StructuralConvertedFromJulia( monomials ) ];
+    fi;
 end );
 
 
@@ -289,11 +338,132 @@ BindGlobal( "Nemo_Field", function( F, descr... )
 end );
 
 
+#############################################################################
+##
+InstallMethod( \in,
+    IsElmsColls,
+    [ "IsNemoFieldElement", "IsNemoField" ],
+    ReturnTrue );
+
+
+#############################################################################
+##
+BindGlobal( "ElementOfNemoNumberField", function( nemoF, coeffs )
+    local d, res;
+
+    # Compute the common denominator.
+    coeffs:= ExtRepOfObj( coeffs );
+    d:= Lcm( List( coeffs, DenominatorRat ) );
+    coeffs:= coeffs * d;
+
+    # Convert the list of integral coefficient vectors
+    # to a suitable matrix in Julia (Nemo.fmpz_mat).
+    res:= Julia.GAPUtilsExperimental.MatrixFromNestedArray( [ coeffs ] );
+    res:= Julia.Nemo.matrix( Julia.Nemo.ZZ, res );
+
+    # Call the Julia function.
+    res:= Julia.GAPNumberFields.NemoElementOfNumberField(
+                JuliaPointer( nemoF ), res, d );
+
+    return ObjectifyWithAttributes( rec(),
+               ElementsFamily( FamilyObj( nemoF ) )!.defaultType,
+               JuliaPointer, res );
+end );
+
+
 #T  Random for this field:
 #T  method for alg. ext.; method for v. sp. -> then need basis ...
 #T  -> and need arithm. between GAP coeffs. and NEMO field elements
 
 
+#############################################################################
+##
+#R  IsIsomorphismToNemoFieldRep( <obj> )
+##
+DeclareRepresentation( "IsIsomorphismToNemoFieldRep",
+    IsAttributeStoringRep, [] );
+
+
+#############################################################################
+##
+#P  IsIsomorphismToNemoField( <obj> )
+##
+DeclareSynonym( "IsIsomorphismToNemoField",
+    IsIsomorphismToNemoFieldRep
+    and IsFieldHomomorphism
+    and IsMapping
+    and IsBijective );
+
+
+##############################################################################
+##
+#F  IsomorphismToNemoField( <F> )
+##
+##  For a field that consists of 'IsAlgebraicElement' elements,
+##  this function returns a field isomorphism
+##  to a field consisting of elements in '...'.
+##
+IsomorphismToNemoField:= function( F )
+    local NemoF;
+
+    # Check the argument.
+    if not ( IsAlgebraicElementCollection( F ) and IsField( F ) ) then
+      Error( "<F> must be an algebraic extension" );
+    fi;
+
+    NemoF:= Nemo_Field( F );
+
+    return Objectify( TypeOfDefaultGeneralMapping( F, NemoF,
+                              IsSPGeneralMapping
+                          and IsIsomorphismToNemoField ),
+                      rec() );
+end;
+
+
+#############################################################################
+##
+#M  ImageElm( <iso>, <cyc> )
+##
+InstallMethod( ImageElm,
+    FamSourceEqFamElm,
+    [ "IsIsomorphismToNemoField", "IsAlgebraicElement" ],
+    function( iso, algelm )
+    return ElementOfNemoNumberField( Range( iso ), algelm );
+    end );
+
+
+#############################################################################
+##
+#M  PreImageElm( <iso>, <elm> )
+##
+InstallMethod( PreImageElm,
+    FamRangeEqFamElm,
+    [ "IsIsomorphismToNemoField", "IsNemoFieldElement" ],
+    function( iso, elm )
+    local numden, getindex, convert, num, den, coeffs, i;
+
+    numden:= Julia.GAPNumberFields.CoefficientVectorsNumDenOfNumberFieldElement(                 JuliaPointer( elm ), Dimension( Source( iso ) ) );
+
+    getindex:= Julia.Base.getindex;
+    convert:= Julia.Base.convert;
+    num:= StructuralConvertedFromJulia(
+              convert( JuliaEvalString( "Array{Int,1}" ),
+                       getindex( numden, 1 ) ) );
+    den:= StructuralConvertedFromJulia(
+              convert( JuliaEvalString( "Array{Int,1}" ),
+                       getindex( numden, 2 ) ) );
+    coeffs:= [];
+    for i in [ 1 .. Length( num ) ] do
+      coeffs[i]:= num[i] / den[i];
+    od;
+
+    return AlgExtElm( ElementsFamily( FamilyObj( Source( iso ) ) ), coeffs );
+    end );
+
+
+#T hier!
+
+
 #############################################################################
 ##
 #F  NemoElement( <template>, <jpointer> )
@@ -305,16 +475,25 @@ BindGlobal( "NemoElement", function( template, jpointer )
 
     if IsDomain( template ) then
       type:= ElementsFamily( FamilyObj( template ) )!.defaultType;
+    elif IsPolynomial( template ) then
+      type:= FamilyObj( template )!.defaultPolynomialType;
     else
       type:= FamilyObj( template )!.defaultType;
     fi;
 
     result:= ObjectifyWithAttributes( rec(), type, JuliaPointer, jpointer );
+    if HasParent( template ) then
+      SetParent( result, Parent( template ) );
+    fi;
 
     return result;
 end );
 
 
+#T beat GAP's 'IsPolynomial' methods
+NEMO_RANK_SHIFT:= 100;
+
+
 #############################################################################
 ##
 ##  methods for Nemo's polynomials
@@ -348,49 +527,49 @@ InstallMethod( RootOfDefiningPolynomial, [ IsNemoField ],
 ##
 ##  methods for field elements
 ##
-InstallOtherMethod( ViewString, [ IsNemoObject ],
+InstallOtherMethod( ViewString, [ "IsNemoObject" ],
     x -> Concatenation( "<", ViewString( JuliaPointer( x ) ), ">" ) );
 
-InstallOtherMethod( \=, [ IsNemoObject, IsNemoObject ],
+InstallOtherMethod( \=, [ "IsNemoObject", "IsNemoObject" ], NEMO_RANK_SHIFT,
     function( x, y )
       return ConvertedFromJulia(
                  Julia.Base.("==")( JuliaPointer( x ), JuliaPointer( y ) ) );
     end );
 
-InstallOtherMethod( \+, [ IsNemoObject, IsNemoObject ],
+InstallOtherMethod( \+, [ "IsNemoObject", "IsNemoObject" ], NEMO_RANK_SHIFT,
     function( x, y )
       return NemoElement( x,
                  Julia.Base.("+")( JuliaPointer( x ), JuliaPointer( y ) ) );
     end );
 
-InstallOtherMethod( \+, [ IsNemoObject, IsInt ],
+InstallOtherMethod( \+, [ "IsNemoObject", "IsInt and IsSmallIntRep" ], NEMO_RANK_SHIFT,
     function( x, y )
       return NemoElement( x,
                  Julia.Base.("+")( JuliaPointer( x ), y ) );
     end );
 
-InstallOtherMethod( AdditiveInverse, [ IsNemoObject ],
+InstallOtherMethod( AdditiveInverse, [ "IsNemoObject" ], NEMO_RANK_SHIFT,
     x -> NemoElement( x, Julia.Base.("-")( JuliaPointer( x ) ) ) );
 
-InstallOtherMethod( \-, [ IsNemoObject, IsNemoObject ],
+InstallOtherMethod( \-, [ "IsNemoObject", "IsNemoObject" ], NEMO_RANK_SHIFT,
     function( x, y )
       return NemoElement( x,
                  Julia.Base.("-")( JuliaPointer( x ), JuliaPointer( y ) ) );
     end );
 
-InstallOtherMethod( \*, [ IsNemoObject, IsNemoObject ],
+InstallOtherMethod( \*, [ "IsNemoObject", "IsNemoObject" ], NEMO_RANK_SHIFT,
     function( x, y )
       return NemoElement( x,
                  Julia.Base.("*")( JuliaPointer( x ), JuliaPointer( y ) ) );
     end );
 
-InstallOtherMethod( \/, [ IsNemoObject, IsNemoObject ],
+InstallOtherMethod( \/, [ "IsNemoObject", "IsNemoObject" ], NEMO_RANK_SHIFT,
     function( x, y )
       return NemoElement( x, Julia.Nemo.divexact(
                      JuliaPointer( x ), JuliaPointer( y ) ) );
     end );
 
-InstallOtherMethod( \^, [ IsNemoObject, IsPosInt ],
+InstallOtherMethod( \^, [ "IsNemoObject", "IsPosInt" ], NEMO_RANK_SHIFT,
     function( x, n )
       return NemoElement( x, Julia.Base.("^")( JuliaPointer( x ), n ) );
     end );
@@ -516,7 +695,6 @@ end );
 InstallMethod( NumberRows,
     [ "IsNemoMatrixObj" ],
     nemomat -> ConvertedFromJulia( Julia.Nemo.rows( JuliaPointer( nemomat ) ) ) );
-#T really unbox?
 
 InstallMethod( NumberColumns,
     [ "IsNemoMatrixObj" ],
@@ -582,22 +760,6 @@ InstallMethod( \[\],
 #T four argument []:= needed?
 
 
-# DeclareOperation( "ViewObj", [IsMatrixObj] );
-
-InstallMethod( PrintObj,
-    [ "IsNemoMatrixObj" ],
-    function( nemomat )
-Print( "???" );
-    end );
-# This must produce GAP-readable input reproducing the representation.
-#T how?
-
-# DeclareAttribute( "String", IsMatrixObj );
-# DeclareOperation( "String", [IsMatrixObj,IsInt] );
-
-# DeclareOperation( "Display", [IsMatrixObj] );
-
-
 ############################################################################
 # Arithmetical operations:
 ############################################################################
@@ -612,7 +774,8 @@ Print( "???" );
 #        in that representation cannot be lists!
 
 InstallMethod( \^,
-    [ "IsNemoMatrixObj", "IsPosInt" ],
+    [ "IsNemoMatrixObj", "IsPosInt and IsSmallIntRep" ], NEMO_RANK_SHIFT,
+                                                   # beat the generic method
     function( nemomat, n )
     local power, type;
 
@@ -624,8 +787,6 @@ InstallMethod( \^,
                NumberRows, NumberRows( nemomat ),
                NumberColumns, NumberColumns( nemomat ) );
     end );
-#T check square?
-#T what about 0x0 matrices?
 
 
 # The following unary arithmetical operations are possible for matrices:
diff --git a/JuliaExperimental/gap/record.g b/JuliaExperimental/gap/record.g
index d06244a9d..254d8f74a 100644
--- a/JuliaExperimental/gap/record.g
+++ b/JuliaExperimental/gap/record.g
@@ -14,7 +14,7 @@
 #! @Returns a &Julia; object
 #! @Description
 #!  For a record <A>arec</A>,
-#!  this function creates a dictionary in Julia
+#!  this function creates a dictionary in &Julia;
 #!  whose components are the record components of <A>arec</A>,
 #!  and the corresponding 
 InstallMethod( ConvertedToJulia,
diff --git a/JuliaExperimental/ipynb/GAPJulia_Singular_blog.ipynb b/JuliaExperimental/ipynb/GAPJulia_Singular_blog.ipynb
index 90a7b5c3a..52b282cbd 100644
--- a/JuliaExperimental/ipynb/GAPJulia_Singular_blog.ipynb
+++ b/JuliaExperimental/ipynb/GAPJulia_Singular_blog.ipynb
@@ -466,8 +466,7 @@
     }
    ],
    "source": [
-    "# Currently there is no 'Julia.Singular.Matrix'.\n",
-    "JuliaFunction( \"Matrix\", \"Singular\" )( M );"
+    "Julia.Singular.Matrix( M );"
    ]
   },
   {
diff --git a/JuliaExperimental/julia/hnf.jl b/JuliaExperimental/julia/hnf.jl
index 68c2a20e5..b539741e4 100644
--- a/JuliaExperimental/julia/hnf.jl
+++ b/JuliaExperimental/julia/hnf.jl
@@ -9,7 +9,7 @@ using Nemo
 
 export unpackedNemoMatrixFmpz
 
-function fitsGAPSmallIntRep( x::fmpz )
+function fitsGAPSmallIntRep( x::Nemo.fmpz )
     return -2^60 <= x && x < 2^60
 end
 
diff --git a/JuliaExperimental/julia/numfield.jl b/JuliaExperimental/julia/numfield.jl
index 74c1288ca..3764df218 100644
--- a/JuliaExperimental/julia/numfield.jl
+++ b/JuliaExperimental/julia/numfield.jl
@@ -12,25 +12,33 @@ import Base: length, similar, zeros, ==, isless, *, one, inv, ^, /
 using Nemo
 # using Hecke
 
-export MatrixFromNestedArray, Nemo_Matrix_over_NumberField,
+export NemoElementOfNumberField,
+       Nemo_Matrix_over_NumberField,
        CoefficientVectorsNumDenOfNumberFieldElement,
        MatricesOfCoefficientVectorsNumDen
 
 # export ConvertedToJulia_Cyclotomics
 
 
-##  Turn a nested 1-dim. array (as created by 'ConvertedToJulia'
-##  into a 2-dim. array
-
-function MatrixFromNestedArray( lst ) return hcat( lst... )' end
-
+doc"""
+    NemoElementOfNumberField( f, lst, denom )
+> Return the element in the number field `f` for which `lst` is the array
+> of numerators of the coefficients w.r.t. the defining polynomial of `f`,
+> and `denom` is the common denominator.
+"""
+function NemoElementOfNumberField( f, lst, denom::Int )
+    return Nemo.elem_from_mat_row( f, lst, 1, Nemo.fmpz( denom ) )
+end
 
-##  Create an 'm' by 'n' matrix of elements in the field 'f'
-##  from a list 'lst' (of length 'm' times 'n')
-##  of integer coefficient vectors,
-##  for which 'denom' is the common denominator.
 
-function Nemo_Matrix_over_NumberField( f, m, n, lst, denom )
+doc"""
+    Nemo_Matrix_over_NumberField( f, m, n, lst, denom )
+> Return an `m` by `n` matrix of elements in the Nemo number field `f`
+> from the list `lst` (which has length `m` times `n`)
+> of integer coefficient vectors,
+> for which `denom` is the common denominator.
+"""
+function Nemo_Matrix_over_NumberField( f, m::Int, n::Int, lst, denom::Int )
     local pos, mat, d, i, j
 
     pos = 1
@@ -48,10 +56,12 @@ function Nemo_Matrix_over_NumberField( f, m, n, lst, denom )
 end
 
 
-##  Create the coefficient vector of the element `elm`,
-##  as an array of length `d` and consisting of `fmpq` objects.
-
-function CoefficientVectorOfNumberFieldElement( elm, d )
+doc"""
+    CoefficientVectorOfNumberFieldElement( elm::Nemo.nf_elem, d::Int )
+> Return the coefficient vector of the number field element `elm`,
+> as an array of length `d` and consisting of `Nemo.fmpq` objects.
+"""
+function CoefficientVectorOfNumberFieldElement( elm::Nemo.nf_elem, d::Int )
     local arr, i
 
     arr = Array{Nemo.fmpq,1}( d )
@@ -63,26 +73,34 @@ function CoefficientVectorOfNumberFieldElement( elm, d )
 end
 
 
-##  Create the vectors for numerator and denominator
-##  of the coefficient vector of the element `elm`,
-##  as arrays of length `d` and consisting of `fmpz` objects.
-
+doc"""
+    CoefficientVectorsNumDenOfNumberFieldElement( elm::Nemo.nf_elem, d::Int )
+> Return the tuple that consists of the coefficient vectors
+> of the numerators and the denominators of the coefficient vector
+> of the number field element `elm`,
+> as arrays of length `d` and consisting of `Nemo.fmpz` objects.
+"""
 function CoefficientVectorsNumDenOfNumberFieldElement( elm, d )
-    local num, den, i
+    local num, den, i, onecoeff
 
     num = Array{Nemo.fmpz,1}( d )
     den = Array{Nemo.fmpz,1}( d )
     for i = 1:d
-      num[i] = numerator( Nemo.coeff( elm, i-1 ) )
-      den[i] = denominator( Nemo.coeff( elm, i-1 ) )
+      onecoeff = Nemo.coeff( elm, i-1 )
+      num[i] = numerator( onecoeff )
+      den[i] = denominator( onecoeff )
     end
 
     return num, den
 end
 
 
-##  2-dim. (m n) times d arrays of Nemo.fmpz elements
-
+doc"""
+    MatricesOfCoefficientVectorsNumDen( nemomat, d )
+> Return the tuple that consists of two 2-dim. (m n) times `d` arrays
+> of `Nemo.fmpz` objects that describe the numerators and the denominators
+> of the number field elements in the matrix `nemomat`.
+"""
 function MatricesOfCoefficientVectorsNumDen( nemomat, d )
     local m, n, num, den, i, j, resnum, resden
 
@@ -104,19 +122,20 @@ end
 
 
 #T as soon as 'Qab.jl' is officially available in Hecke:
-# ##  Translate between GAP's cyclotomics and Hecke's QabElem objects.
-# ##  'lst' is a list of integral coefficient vectors w.r.t.
-# ##  the 'N'-th cyclotomic field,
-# ##  'denom' is the common denominator.
-# ##
-# ##  The result is an array of field elements.
-# 
+# doc"""
+#     ConvertedToJulia_Cyclotomics( N, lst, denom )
+# > Return an array of n `QabElem` objects,
+# > which correspond to the n entries of the array `lst`.
+# > Each entry is the vector of numerators of the coefficient vector
+# > of an element in the `N`-th cyclotomic field,
+# > and `denom` is the common denominator.
+# """
 # ConvertedToJulia_Cyclotomics = function( N, lst, denom )
 #     local f, x, n, m, mat, d, res
 # 
 #     f, x = Nemo.CyclotomicField( N, "x" )
 #     n = length( lst )
-#     m = MatrixSpace( ZZ, n, length( lst[1] ) )
+#     m = MatrixSpace( Nemo.ZZ, n, length( lst[1] ) )
 #     mat = m( hcat( lst... )' )
 #     d = Nemo.fmpz( denom )
 #     res = Array{Any}( n )
diff --git a/JuliaExperimental/julia/utils.jl b/JuliaExperimental/julia/utils.jl
index 4fbd9f916..b3b800ee9 100644
--- a/JuliaExperimental/julia/utils.jl
+++ b/JuliaExperimental/julia/utils.jl
@@ -7,7 +7,10 @@
 
 module GAPUtilsExperimental
 
-export MatrixFromNestedArray
+import Nemo
+
+export MatrixFromNestedArray, CoefficientsNumDenOfNemoPolynomialFmpq,
+       JuliaSourceFile
 
 doc"""
     MatrixFromNestedArray( lst )
@@ -16,5 +19,71 @@ doc"""
 """
 function MatrixFromNestedArray( lst ) return hcat( lst... )' end
 
+
+doc"""
+    fitsGAPSmallIntRep( x::Nemo.fmpz )
+> Return `true` if `x` corresponds to a GAP integer in `IsSmallIntRep`,
+> and `false`otherwise.
+"""
+function fitsGAPSmallIntRep( x::Nemo.fmpz )
+    return -2^60 <= x && x < 2^60
+end
+
+
+function CoefficientsOfUnivarateNemoPolynomialFmpq( pol::Nemo.fmpq_poly )
+    return map( i -> Nemo.coeff( pol, i ), 0:(length(pol)-1) )
+end
+
+
+function NestedArrayFromMatrix( mat )
+    return map( i -> mat[i,:], 1:size(mat,1) )
+end
+
+
+doc"""
+    CoefficientsNumDenOfFmpqArray( arr::Array{Nemo.fmpq,1}[, tryint::Bool = true] )
+> Return a tuple `(<kind>, <arrnum>, <arrden>)` where <arrnum>, <arrden>
+> are 1-dim. arrays of the numerators and denominators of the values in <arr>,
+> and <kind> is either `"int"` (the entries are small integers)
+> or `"string"` (the entries are hex strings).
+> This format is suitable for calling `ConvertedFromJulia` from GAP.
+"""
+function CoefficientsNumDenOfFmpqArray( arr::Array{Nemo.fmpq,1}, tryint::Bool = true )
+    n = length( arr )
+    coeffsnum = map( i -> numerator( arr[i] ), 1:n )
+    coeffsden = map( i -> denominator( arr[i] ), 1:n )
+
+    if tryint == true
+      # Check whether the entries are small enough for being unboxed
+      # to small integers in GAP, i. e., in the range '[ -2^60 .. 2^60-1 ]'.
+      fits = [ fitsGAPSmallIntRep( coeffsnum[i] ) for i in 1:n ]
+      if all( [ fitsGAPSmallIntRep( coeffsnum[i] ) for i in 1:n ] ) &&
+         all( [ fitsGAPSmallIntRep( coeffsden[i] ) for i in 1:n ] )
+        return ( "int", map( Int, coeffsnum ), map( Int, coeffsden ) )
+      end
+    end
+
+    # Either we *want* to create a nested array of strings,
+    # or some entry is too large.
+    # Turn the 2-dim. array into a 1-dim. array of 1-dim. arrays
+    # (which can then be unboxed with 'ConvertedFromJulia').
+    return ( "string", [ hex( coeffsnum[i] ) for i in 1:n ],
+                       [ hex( coeffsden[i] ) for i in 1:n ] )
+end
+
+doc"""
+    JuliaSourceFile( func, types )
+> Return the tuple `( filename, startline )`
+> such that the source code of the method `func`
+> that expects arguments of the types given in the tuple `types`
+> can be found in the file `filename`, starting at line `startline`.
+"""
+function JuliaSourceFile( func, types )
+    local meth::Method
+
+    meth = which( func, types )
+    return ( string( meth.file ), meth.line )
+end
+
 end
 
diff --git a/JuliaExperimental/julia/zlattice.jl b/JuliaExperimental/julia/zlattice.jl
index dddcb7fdf..f5540b614 100644
--- a/JuliaExperimental/julia/zlattice.jl
+++ b/JuliaExperimental/julia/zlattice.jl
@@ -18,7 +18,6 @@ export LLLReducedGramMat, ShortestVectors, OrthogonalEmbeddings
 doc"""
     LLLReducedGramMat( grammatrix::Array{Int,2}, y::Rational{Int} = 3//4 )
 > Return a dictionary with the following components.
->   remainder`
 >   `remainder`:      the reduced Gram matrix (`Array{Rational{Int},2}`)
 >   `relations`:      basechange matrix `H` (`Array{Rational{Int},2}`)
 >   `transformation`: basechange matrix `H` (`Array{Rational{Int},2}`)
@@ -470,6 +469,10 @@ end
 
 # A = [ 2 -1 -1 -1 ; -1 2 0 0 ; -1 0 2 0 ; -1 0 0 2 ];
 
+doc"""
+    OrthogonalEmbeddings( A::Array{Int,2}, arec::Dict )
+> ...
+"""
 function OrthogonalEmbeddings( A::Array{Int,2}, arec::Dict )
 
     local ExtendAtPosition,
diff --git a/JuliaExperimental/tst/numfield.tst b/JuliaExperimental/tst/numfield.tst
index 83bd2c0ae..3b4e8ad27 100644
--- a/JuliaExperimental/tst/numfield.tst
+++ b/JuliaExperimental/tst/numfield.tst
@@ -20,6 +20,27 @@ gap> Nemo_Polynomial( R, [ [ 1, 2, 3 ], [ [ 4, 5, 6 ], [ 7, 8, 9 ] ] ] );
 gap> Nemo_Polynomial( R, [ [ 1, 2, 3/2 ], [ [ 4, 5, 6 ], [ 7, 8, 9 ] ] ] );
 <<Julia: x^4*y^7+2*x^5*y^8+3//2*x^6*y^9>>
 
+# polynomial arithmetics?
+
+# Nemo number fields
+gap> x:= X( Rationals );;
+gap> f:= AlgebraicExtension( Rationals, x^2+1 );;
+gap> iso:= IsomorphismToNemoField( f );;
+gap> ff:= Range( iso );
+<field in characteristic 0>
+gap> one:= Image( iso, One( f ) );
+<<Julia: 1>>
+gap> PreImage( iso, one );
+!1
+gap> a:= RootOfDefiningPolynomial( f );
+a
+gap> gen:= Image( iso, a );
+<<Julia: a>>
+gap> PreImage( iso, gen );
+a
+
+# Arithmetic operations in number fields? (which methods get called?)
+
 # matrix over Z
 gap> mat:= NemoMatrix( Nemo_ZZ, IdentityMat( 2 ) );
 <<Julia: [1 0]
@@ -40,6 +61,11 @@ gap> mat:= [ [ o, a/2 ], [ z, o ] ];
 gap> nmat:= NemoMatrix( ff, mat );
 <<Julia: [1 1//2*a]
 [0 1]>>
+gap> PrintObj( nmat );
+[1 1//2*a]
+[0 1]
+gap> TraceMat( nmat );
+<<Julia: 2>>
 gap> GAPMatrix( f, nmat );
 [ [ !1, 1/2*a ], [ !0, !1 ] ]
 gap> no:= One( ff );