/*
 * Copyright 2010, Clemens Zeidler <haiku@clemens-zeidler.de>
 * Distributed under the terms of the MIT License.
 */
#ifndef ACTICE_SET_SOLVER_H
#define ACTICE_SET_SOLVER_H


#include "LinearSpec.h"


class EquationSystem {
public:
								EquationSystem(int32 rows, int32 columns);
								~EquationSystem();

			void				SetRows(int32 rows);
			int32				Rows();
			int32				Columns();

			//! Debug function: check bounds
			bool				InRange(int32 row, int32 column);
	inline	double&				A(int32 row, int32 column);
	inline	double&				B(int32 row);
			/*! Copy the solved variables into results, keeping the original
			variable order. */
	inline	void				Results(double* results, int32 size);

	inline	void				SwapColumn(int32 i, int32 j);
	inline	void				SwapRow(int32 i, int32 j);

			bool				GaussianElimination();
			bool				GaussJordan();
			/*! Gauss Jordan elimination just for one column, the diagonal
			element must be none zero. */
			void				GaussJordan(int32 column);

			void				RemoveLinearlyDependentRows();
			void				RemoveUnusedVariables();

			void				MoveColumnRight(int32 i, int32 target);

			void				Print();
private:
	inline	void				_EliminateColumn(int32 column, int32 startRow,
									int32 endRow);

			int32*				fRowIndices;
			int32*				fColumnIndices;
			double**			fMatrix;
			double*				fB;
			int32				fRows;
			int32				fColumns;
};


class ActiveSetSolver : public LinearProgramming::SolverInterface {
public:
								ActiveSetSolver(LinearSpec* linearSpec);
								~ActiveSetSolver();

			ResultType			Solve();

			bool				VariableAdded(Variable* variable);
			bool				VariableRemoved(Variable* variable);
			bool				VariableRangeChanged(Variable* variable);

			bool				ConstraintAdded(Constraint* constraint);
			bool				ConstraintRemoved(Constraint* constraint);
			bool				LeftSideChanged(Constraint* constraint);
			bool				RightSideChanged(Constraint* constraint);
			bool				OperatorChanged(Constraint* constraint);
			bool				PenaltiesChanged(Constraint* constraint);

			bool				SaveModel(const char* fileName);

			ResultType			FindMaxs(const VariableList* variables);
			ResultType			FindMins(const VariableList* variables);

			void				GetRangeConstraints(const Variable* var,
									const Constraint** _min,
									const Constraint** _max) const;

private:
			void				_RemoveSoftConstraint(ConstraintList& list);
			void				_AddSoftConstraint(const ConstraintList& list);

	typedef Constraint* (*AddConstraintFunc)(LinearSpec* spec, Variable* var);

			ResultType			_FindWithConstraintsNoSoft(
									const VariableList* variables,
									AddConstraintFunc constraintFunc);

	const	VariableList&		fVariables;
	const	ConstraintList&		fConstraints;

			ConstraintList		fVariableGEConstraints;
			ConstraintList		fVariableLEConstraints;
};


#endif // ACTICE_SET_SOLVER_H