#include <Simplex.H>

Tipos públicos
enum	State { Not_Solved, Solving, Unbounded, Solved, Unfeasible }
	Estados del sistema.

Métodos públicos
	Simplex (int n)

void	put_objetive_function_coef (int i, const T &coef)

void	put_objetive_function (DynArray< T > &coefs)

void	put_objetive_function (T coefs[])

T *	put_restriction (T *coefs=NULL)

T *	get_restriction (int rest_num)
	Retorna un punero al arreglo restricción num_rest.

T *	put_restriction (DynArray< T > &coefs)

State	latex_solve (char *name=NULL)

State	solve ()

void	load_solution ()
	Carga los valores de las variables solución.

const T &	get_solution (size_t i) const

T	objetive_value () const
	Retorna el valor de la función objetivo.

bool	verify_solution () const

void	print_matrix ()

void	latex_matrix (const char *name, int d=2, int p=-1, int q=-1)

void	latex_linear_program (char *name)

size_t	get_num_restrictions () const

size_t	get_num_vars () const

T *	get_objetive_function ()

T &	get_restriction_coef (int rest_num, int idx)
	retorna el coeficiente idx de la restricci{on rest_num

void	put_restriction_coef (int rest_num, int idx, const T &coef)

void	prepare_linear_program ()

Descripción detallada

template<typename T>
class Aleph::Simplex< T >

Resolucionador de programas lineales mediante el método simplex.

Simplex<T> permite expresar programas lineales en forma estándar; es decir, una función objetivo a maximizar y un conjunto de restricciones con coeficientes positivos y desigualdes menor o igual.

Para casos no estándar, el programa lineal puede convertirse a uno estándar mediante los siguientes criterios:

Si se tienen variable sin restricción de no negatividad, entonces se pueden emplear variables auxiliares.
Si una restricción no es menor o igual que, entonces ésta se puede negar para convertirla en una menor o igual que.
Si se tiene una restrcción de igualdad estricta, entonces esta se puede modelizar como dos, menor o igual que y mayor o igual que.

El tipo T debe ser de tipo numérico. No es aconsejable que sea entero.

Documentación del constructor y destructor

template<typename T>

Aleph::Simplex< T >::Simplex ( int n )

inline

Constructor.

Inicializa un programa lineal en forma estándar, sin restricciones y con los coeficientes de la fnción objetivo en cero.

Parámetros

[in] n número de variables que tiene el sistema.

Excepciones

bad_alloc si no hay suficiente memoria.

Documentación de las funciones miembro

template<typename T>

const T& Aleph::Simplex< T >::get_solution ( size_t i ) const

inline

Retorna un puntero al arreglo con las soluciones. Previamente debe haberse llamado a load_solution().

template<typename T>

void Aleph::Simplex< T >::put_objetive_function ( DynArray< T > & coefs )

inline

Define los coeficientes de la función objetivo mediante un arreglo dinámico. Sólo se leen los n - 1 coeficientes.

template<typename T>

void Aleph::Simplex< T >::put_objetive_function ( T coefs[] )

inline

Define los coeficientes de la función objetivo mediante un arreglo. Sólo se leen los n - 1 coeficientes.

template<typename T>

void Aleph::Simplex< T >::put_objetive_function_coef	(	int	i,
		const T &	coef
	)

inline

Define el coeficiente coef de la variable i en el afunción objetivo. No se valida si i está fuera de rango.

template<typename T>

T* Aleph::Simplex< T >::put_restriction ( T * coefs = NULL )

inline

Define una restricción mediante un arreglo.

put_restriction(coefs) recibe un arreglo de n-1 coeficientes más el valor límite correspondiente a una restricción en forma estándar del tipo c1*x0 + c2*x_1 + ... + c(n-1)*x(n-1) <= cn.

Parámetros

[in] coefs arreglo de coeficientes que será leído entre 0 y n. Si el puntero es nulo, entonces se crea la restricción con coeficientes nulos, cuales pueden ser definidos después.

Excepciones

bad_alloc en caso de que se pase un puntero nulo y no haya memoria para apartar el arreglo.

Devuelve: un puntero al arreglo de restricciones.

template<typename T>

T* Aleph::Simplex< T >::put_restriction ( DynArray< T > & coefs )

inline

Define una restricción mediante un arreglo dinámico.

put_restriction(coefs) recibe un arreglo de n-1 coeficientes más el valor límite correspondiente a una restricción en forma estándar del tipo c1*x0 + c2*x_1 + ... + c(n-1)*x(n-1) <= cn.

Parámetros

[in] coefs arreglo de coeficientes que será leído entre 0 y n.

Excepciones

bad_alloc en caso de que no haya memoria para apartar el arreglo.

Devuelve: un puntero al arreglo de restricciones.

template<typename T>

State Aleph::Simplex< T >::solve ( )

inline

Resuelve un programa lineal.

Resuelve un programa lineal correcta y completamente especificado.

Los estado de solución son:

Unbounded: el sistema está ilimitado (error de diseño)
Solved: se ha encontrado una solución máxima. Se debe tener cuidado, pues la solución no necesariamente satisface las restricciones.

Devuelve: el estado de solución del sistema.

template<typename T>

bool Aleph::Simplex< T >::verify_solution ( ) const

inline

Retorna true si la solución obtenida satisface las restricciones; false de lo contrario.

La documentación para esta clase fue generada a partir del siguiente fichero:

Simplex.H

Tipos públicos

Métodos públicos

Descripción detallada

template<typename T> class Aleph::Simplex< T >

Documentación del constructor y destructor

Documentación de las funciones miembro

template<typename T>
class Aleph::Simplex< T >