Refactor tricky indexing with common function (#55)

* Refactor tricky indexing with common function

* Make it internal

* Fix

Author: blegat

src/lp.jl

@@ -172,7 +172,7 @@ function print_lpoutput(m::HMatrix, print_solution::Bool=false)
     for i in 0:P.d-1
         C_i = unsafe_load(P.C, i+1)
         Col_i = unsafe_load(P.Col, i+1)
-        idx = unsafe_load(Q.inequality, C_i-Q.lastdv+1)
+        idx = _unsafe_load_inequality(m, C_i)
         print(" y_$(idx)=")
         temp1 = extractbigint(unsafe_load(Q.Lcm, Col_i+1)) * (-1)
         temp1 *= extractbigint(unsafe_load(unsafe_load(P.A, 1), Col_i+1))

src/matrix.jl

@@ -55,7 +55,6 @@ function initmatrix(M::Matrix{Rational{BigInt}}, linset, Hrep::Bool)
     (P, Q)
 end
 
-
 function fillmatrix(inequality::Bool, P::Ptr{Clrs_dic}, Q::Ptr{Clrs_dat}, itr::Polyhedra.ElemIt, offset::Int)
     for (i, item) in enumerate(itr)
         a = convert(Vector{Rational{BigInt}}, vec(coord(lift(item))))
@@ -176,6 +175,11 @@ Polyhedra.islin(vrep::VMatrix, idx::Polyhedra.VIndex{Rational{BigInt}}) = !(vrep
 Polyhedra.done(idxs::Polyhedra.Indices{Rational{BigInt}, ElemT, <:RepMatrix}, idx::Polyhedra.Index{Rational{BigInt}, ElemT}) where {ElemT} = idx.value > length(idxs.rep)
 Base.get(rep::RepMatrix, idx::Polyhedra.Index{Rational{BigInt}}) = Polyhedra.valuetype(idx)(extractrow(rep, idx.value)...)
 
+function _unsafe_load_inequality(m::RepMatrix, idx)
+    Q = unsafe_load(m.Q)
+    return unsafe_load(Q.inequality, idx - Q.lastdv + 1)
+end
+
 # H-representation
 
 #HMatrix{T}(rep::Rep{T}) = HMatrix{polytypefor(T), mytypefor(T)}(rep) # TODO finish this line

src/nash.jl

@@ -120,9 +120,9 @@ function nash2_main(hr1::HMatrix, hr2::HMatrix, linindex::Vector{Clong})
     for i in (unsafe_load(Q1).lastdv+1):(unsafe_load(P1).m)
         Row_i = unsafe_load(unsafe_load(P1).Row, i+1)
         if !iszero(extractbigintat(unsafe_load(A1, Row_i+1), 1))
-            j = unsafe_load(
-                unsafe_load(Q1).inequality,
-                unsafe_load(unsafe_load(P1).B, i+1)-unsafe_load(Q1).lastdv+1
+            j = _unsafe_load_inequality(
+                hr1,
+                unsafe_load(unsafe_load(P1).B, i+1),
             )
             if ((unsafe_load(Q1).nlinearity == 0) ||
                 (j < unsafe_load(unsafe_load(Q1).linearity, 1)))

src/redund.jl

@@ -27,7 +27,7 @@ function redund(m::RepMatrix)
 
     redset = BitSet()
     for index in (lastdv + 1):(m_A + d)
-        ineq = unsafe_load(unsafe_load(m.Q).inequality, index - lastdv + 1) # the input inequality number corr. to this index
+        ineq = _unsafe_load_inequality(m, index) # the input inequality number corr. to this index
 
         status = checkindex(m, index)
         if :redundant == checkindex(m, index)
@@ -46,7 +46,7 @@ function redundi(m::RepMatrix, ineq::Int)
     d = unsafe_load(m.P).d
     lastdv = unsafe_load(m.Q).lastdv
 
-    index = lastdv + findfirst(i -> ineq == unsafe_load(unsafe_load(m.Q).inequality, i - lastdv + 1), (lastdv + 1):(m_A + d))
+    index = lastdv + findfirst(i -> ineq == _unsafe_load_inequality(m, i), (lastdv + 1):(m_A + d))
 
     :redundant == checkindex(m, index)
 end