\begin{ccRefConcept}{LinearProgramInterface}

\ccDefinition
A model of \ccRefName\ describes a linear program of the form
%%
\begin{eqnarray*}
\mbox{(QP)}& \mbox{minimize} &c^{T}x+c_0 \\
&\mbox{subject to}   & Ax\qprel b, \\
&                    & l \leq x \leq u
\end{eqnarray*}
%%
in $n$ real variables $x=(x_0,\ldots,x_{n-1})$.
Here, 
\begin{itemize}
\item $A$ is an $m\times n$ matrix (the constraint matrix), 
\item $b$ is an $m$-dimensional vector (the right-hand side),
\item $\qprel$ is an $m$-dimensional vector of relations 
from $\{\leq, =, \geq\}$, 
\item $l$ is an $n$-dimensional vector of lower
bounds for $x$,
\item $u$ is an $n$-dimensional vector of upper bounds for
$x$, 
\item $c$ is an $n$-dimensional vector (the linear objective
  function), and 
\item $c_0$ is a constant.
\end{itemize}

\ccRefines
\ccc{NonnegativeLinearProgramInterface}

\ccHasModels
\ccc{CGAL::Linear_program_from_iterators<A_it, B_it, R_it, FL_it, L_it, FU_it, U_it, C_it>}\\
\ccc{CGAL::Linear_program_from_pointers<NT>}\\
\ccc{CGAL::Linear_program_from_mps<NT>}\\
\ccc{CGAL::Quadratic_program_from_iterators<A_it, B_it, R_it, FL_it, L_it, FU_it, U_it, D_it, C_it>}\\
\ccc{CGAL::Quadratic_program_from_pointers<NT>}\\
\ccc{CGAL::Quadratic_program_from_mps<NT>}

\ccTypes

\ccNestedType{A_iterator}{A random access iterator type for 
  the \emph{columns} of the constraint matrix $A$.}

\ccNestedType{B_iterator}{A random access iterator type for 
  the entries of the right-hand side $b$.}

\ccNestedType{R_iterator}{A random access iterator type for the
  relations $\qprel$. The value type of \ccc{R_iterator} is
  \ccc{CGAL::Comparison_result}.}

\ccNestedType{FL_iterator}{A random access iterator type for the
  existence (or finiteness) of the lower bounds $l_j, j=0,\ldots,n-1$.
  The value type of \ccc{FL_iterator} is \ccc{bool}.}

\ccNestedType{L_iterator}{A random acess iterator type for the entries
  of the lower bound vector $l$.}

\ccNestedType{UL_iterator}{A random access iterator type for the
  existence (or finiteness) of the upper bounds $u_j, j=0,\ldots,n-1$.
  The value type of \ccc{UL_iterator} is \ccc{bool}.}

\ccNestedType{U_iterator}{A random acess iterator type for the entries
  of the upper bound vector $u$.}

\ccNestedType{C_iterator}{A random access iterator type for the
  entries of the linear objective function vector $c$.}

\ccOperations

\ccCreationVariable{qp}

\ccMethod{int n() const;}{returns the number $n$ of variables (number
  of columns of $A$) in \ccVar.}

\ccMethod{int m() const;}{returns the number $m$ of constraints
  (number of rows of $A$) in \ccVar.}

\ccMethod{const A_iterator& a() const;}{returns an iterator for the columns
  of $A$. For $j=0,\ldots,n-1$, $\ccVar.\ccc{a()}[j]$ is a random access
  iterator for column $j$. This means that $\ccVar.\ccc{a()}[j][i]$ is the
  entry of $A$ in row $i$ and column $j$ (row and column indices start
  from $0$).}

\ccMethod{const B_iterator& b() const;}{returns an iterator for the entries
  of $b$.}

\ccMethod{const R_iterator& r() const;}{returns an iterator for the entries
  of $\qprel$. The value \ccc{CGAL::SMALLER} stands
  for $\leq$, \ccc{CGAL::EQUAL} stands for $=$, and \ccc{CGAL::LARGER}
  stands for $\geq$.}

\ccMethod{const FL_iterator& fl() const;}{returns an iterator for the
  existence of the lower bounds $l_j, j=0,\ldots,n-1$. If 
  $\ccVar.\ccc{fl()}[j]=true$, the variable $x_j$ has a lower
  bound, otherwise it has no lower bound.}

\ccMethod{const L_iterator& l() const;}{returns an iterator for the
  entries of $l$. If $\ccVar.\ccc{fl()}[j]=\ccc{false}$, the value 
  $\ccVar.\ccc{l()}[j]$ is not accessed.}

\ccMethod{const FU_iterator& fu() const;}{returns an iterator for the
  existence of the upper bounds $u_j, j=0,\ldots,n-1$. If 
  $\ccVar.\ccc{fu()}[j]=true$, the variable $x_j$ has an upper
  bound, otherwise it has no upper bound.}

\ccMethod{const U_iterator& u() const;}{returns an iterator for the
  entries of $u$. If $\ccVar.\ccc{fu()}[j]=\ccc{false}$, the value 
  $\ccVar.\ccc{u()}[j]$ is not accessed.}

\ccMethod{const C_iterator& c() const;}{returns an iterator for the entries
  of $c$.}

\ccMethod{const C_iterator::value_type& c0() const;}{returns the constant term
$c_0$ of the objective function.}

\ccRequirements

The value types of all iterator types (nested iterator types,
respectively, for \ccc{A_iterator}) must be
convertible to some common Euclidian ring number type \ccc{ET}.

\ccSeeAlso

\end{ccRefConcept}