title: CGAL quadratic solver from iterator exception
body: <p>I need to solve some quadratic programs using CGAL by specifying the problem through iterators. Below is a dummy example which runs fine (problem is infeasible). The problem is when I change the constraints to be ">=": </p>
  
  <pre><code>std::array&lt;CGAL::Comparison_result, numAConstraints&gt; relationships 
                = { CGAL::LARGER,CGAL::LARGER,CGAL::LARGER,CGAL::LARGER, };
  </code></pre>
  
  <p>Then I get:
  "basis-inverse check: failed (row=0 | col=1)" from qp_solver_imp.h line 1155.</p>
  
  <p>This is the sample code that runs without crashing, all constraints are "&lt;=":</p>
  
  <pre><code>#include "stdafx.h"
  #include &lt;array&gt;
  #include &lt;iterator&gt;
  #include &lt;vector&gt;
  #include &lt;CGAL/basic.h&gt;
  #include &lt;CGAL/QP_models.h&gt;
  #include &lt;CGAL/QP_functions.h&gt;
  #include &lt;CGAL/MP_Float.h&gt;
  typedef double ET;
  
  int main(){
      const int numAConstraints = 4;
      const int numVariables = 3;
      typedef CGAL::Quadratic_program_from_iterators
      &lt;double**,  // for A
       double*, // for b
      std::array&lt;CGAL::Comparison_result, numAConstraints&gt;::const_iterator, // for r
      bool*,    // for fl
      double*,   // for l
      bool*,    // for fu
      double*,   // for u
      double**,  // for D
      double*&gt;  // for c 
      Program;
  typedef CGAL::Quadratic_program_solution&lt;ET&gt; Solution;
  
      double  Ax[] = { 1, -1, -1, 1 };      // column for x
      double  Ay[] = { -2, -2, 2, -1 };  
      double  Az[] = { 1, 0.0, -5, 5 };   
      double*  A[] = { Ax, Ay, Az };        // A comes columnwise
      double   b[] = { -2.4, -6, -2, 1.0 };  // right-hand side
      std::array&lt;CGAL::Comparison_result, numAConstraints&gt; relationships 
                = { CGAL::SMALLER,CGAL::SMALLER,CGAL::SMALLER, CGAL::SMALLER }; 
      bool fl[] = { true, true, true };    // both x, y are lower-bounded
      double   l[] = { 0, 0, 0 };
      bool fu[] = { false, false, false };    // only y is upper-bounded
      double   u[] = { 0, 0, 0 };            // x's u-entry is ignored
      double  D1[] = { 1 };                // 2D_{1,1}
      double  D2[] = { 0, 0.1 }; 
      double  D3[] = { 10, 0.0, 100.0 };   
      double*  D[] = { D1, D2, D3 };        // D-entries on/below diagonal ROWISE
      double   c[] = { -200, -5, -25 };
      double  c0 = 64;                
  
      Program qp(numVariables, numAConstraints, A, b, relationships.begin(), fl, l, fu, u, D, c, c0);
      // solve the program, using ET as the exact type
      Solution s = CGAL::solve_quadratic_program(qp, ET());
      std::cout &lt;&lt; s;
      return 0;
  }
  </code></pre>