Added functions to get HNF transformation matrices

src/Sparse/HNF.jl

@@ -825,6 +825,18 @@
   return hnf_kannan_bachem(A; truncate, full_hnf, auto, limit)
 end
 
+function hnf_with_trafo(A::SMat{ZZRingElem}; truncate::Bool = false, full_hnf::Bool = true, auto::Bool = false, limit::Int=typemax(Int))
+  B, T = hnf_kannan_bachem(A, Val(true); truncate, full_hnf, auto, limit)
+  I = sparse_matrix(ZZ, 0, nrows(A))
+  for i in 1:nrows(A)
+    push!(I, sparse_row(ZZ, [(i, ZZ(1))]))
+  end
+  for (i, TT) in enumerate(T)
+    apply_left!(I, TT)
+  end
+  return B, I
+end
+
 @doc raw"""
     hnf!(A::SMat{ZZRingElem})
 
@@ -838,20 +850,40 @@
   A.c = B.c
 end
 
+function hnf_with_trafo!(A::SMat{ZZRingElem}, I::SMat{ZZRingElem}; truncate::Bool = false, full_hnf::Bool = true, auto::Bool = false)
+  B, U = hnf_with_trafo(A; truncate, full_hnf, auto)
+  A.rows = B.rows
+  A.nnz = B.nnz
+  A.r = B.r
+  A.c = B.c
+  I.rows = U.rows
+  I.nnz = U.nnz
+  I.r = U.r
+  I.c = U.c
+end
+
 @doc raw"""
     diagonal_form(A::SMat{ZZRingElem}) -> SMat{ZZRingElem}
 
 A matrix $D$ that is diagonal and obtained via unimodular row and column operations.
 Like a snf without the divisibility condition.
 """
-function diagonal_form(A::SMat{ZZRingElem})
+function diagonal_form(A::SMat{ZZRingElem}, with_right_trafo = false, with_left_trafo = false)
   sa = size(A)
   if nrows(A) < ncols(A)
     A = transpose(A)
   else
     A = deepcopy(A)
   end
   el_div = ZZRingElem[]
+  U = []
+  V = []
+  if with_right_trafo
+    V = identity_matrix(ZZ, ncols(A))
+  end
+  if with_left_trafo
+    U = identity_matrix(ZZ, nrows(A))
+  end 
   while true
     r = nrows(A)
     hnf!(A; auto = true, truncate = true)
@@ -865,6 +897,7 @@
     append!(el_div, [ZZ(1) for j = 1:i-1])
     if i > 1
       A = sub(A, i:nrows(A), 1:ncols(A))
+      print(Matrix(A))
     end
     if all(x->length(x) == 1, A.rows)
       for x = A.rows

src/Sparse/UpperTriangular.jl

@@ -4,6 +4,75 @@
 #
 ################################################################################
 
+function diagonal_form_with_transform(A::SMat, left=false, right=false)
+  n = 1
+  if left == true
+    C = sparse_matrix(ZZ, 0, nrows(A))
+    for i in 1:nrows(A)
+      push!(C, sparse_row(ZZ, [(i, ZZ(1))]))
+    end
+  end
+  if right == true
+    D = sparse_matrix(ZZ, 0, ncols(A))
+    for i in 1:ncols(A)
+      push!(D, sparse_row(ZZ, [(i, ZZ(1))]))
+    end
+  end
+  while(!is_diagonal(A))
+    if n % 2 == 1
+      if left == false
+        hnf!(A, truncate=false, full_hnf=true, auto=false)
+      else
+ 	I = sparse_matrix(ZZ, 0, nrows(A))
+        for i in 1:nrows(A)
+          push!(I, sparse_row(ZZ, [(i, ZZ(1))]))
+        end
+        hnf_with_trafo!(A, I, truncate=false, full_hnf=true, auto=false)
+      	R = sparse_matrix(base_ring(C), nrows(I), ncols(C))
+        for (i, row) in enumerate(I.rows)
+          rR = row * C
+          R[i] = rR
+        end
+        C = R
+      end
+      A = transpose(A)
+      n = n + 1
+    else
+      if right == false
+        hnf!(A, truncate=false, full_hnf=true, auto=false)
+      else
+        I = sparse_matrix(ZZ, 0, ncols(A))
+        for i in 1:ncols(A)
+          push!(I, sparse_row(ZZ, [(i, ZZ(1))]))
+        end
+        hnf_with_trafo!(A, I, truncate=false, full_hnf=true, auto=false)
+        R = sparse_matrix(base_ring(D), nrows(I), ncols(D))
+        for (i, row) in enumerate(I.rows)
+          rR = row * D
+          R[i] = rR
+        end
+        D = R
+      end
+      A = transpose(A)
+      n = n + 1
+    end
+  end
+  if n % 2 == 0
+    A = transpose(A)
+  end
+  if left == true && right == true
+    return C, A, transpose(D)
+  end
+  if left == true
+    return C, A
+  end
+  if right == true
+    return A, transpose(D)
+  else
+    return A
+  end
+end    
+
 @doc raw"""
     diagonal(A::SMat) -> ZZRingElem[]