// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3) fieldsfirst 
// Source File Name:   lprec.java

package lp;

import java.io.PrintStream;

// Referenced classes of package lp:
//			matrec, constant

public class lprec
	implements constant
{

	String lp_name;
	public int active;
	public int verbose;
	public int print_duals;
	public int print_sol;
	public int debug;
	public int print_at_invert;
	public int trace;
	public int anti_degen;
	int rows;
	int rows_alloc;
	int columns;
	int columns_alloc;
	int sum;
	int sum_alloc;
	int names_used;
	String row_name[];
	String col_name[];
	int non_zeros;
	int mat_alloc;
	matrec mat[];
	int col_end[];
	int col_no[];
	int row_end_valid;
	int row_end[];
	double orig_rh[];
	double rh[];
	double rhs[];
	int must_be_int[];
	double orig_upbo[];
	double orig_lowbo[];
	double upbo[];
	double lowbo[];
	int basis_valid;
	int bas[];
	int basis[];
	int lower[];
	int eta_valid;
	int eta_alloc;
	int eta_size;
	int num_inv;
	int max_num_inv;
	double eta_value[];
	int eta_row_nr[];
	int eta_col_end[];
	int bb_rule;
	int break_at_int;
	double break_value;
	double obj_bound;
	int iter;
	int total_iter;
	int max_level;
	int total_nodes;
	double solution[];
	double best_solution[];
	double duals[];
	int maximise;
	int floor_first;
	int ch_sign[];
	int scaling_used;
	int columns_scaled;
	double scale[];
	int nr_lagrange;
	double lag_row[][];
	double lag_rhs[];
	double lambda[];
	int lag_con_type[];
	double lag_bound;
	int valid;
	double infinite;
	double epsilon;
	double epsb;
	double epsd;
	double epsel;

	public double getBestSolution(int i)
	{
		return best_solution[i];
	}

	public int getRows()
	{
		return rows;
	}

	public int getColumns()
	{
		return columns;
	}

	public lprec(int i, int j)
	{
		int k6 = i + j;
		if(rows < 0 || columns < 0)
			System.err.print("rows < 0 or columns < 0");
		lp_name = new String("unnamed");
		active = 0;
		verbose = 0;
		print_duals = 0;
		print_sol = 0;
		debug = 0;
		print_at_invert = 0;
		trace = 0;
		rows = i;
		columns = j;
		sum = k6;
		rows_alloc = rows;
		columns_alloc = columns;
		sum_alloc = sum;
		names_used = 0;
		obj_bound = 9.9999999999999998E+23D;
		infinite = 9.9999999999999998E+23D;
		epsilon = 0.001D;
		epsb = 5.0100000000000005E-07D;
		epsd = 9.9999999999999995E-07D;
		epsel = 1E-08D;
		non_zeros = 0;
		mat_alloc = 1;
		mat = new matrec[mat_alloc];
		for(int k = 0; k < mat_alloc; k++)
			mat[k] = new matrec(0, 0.0D);

		col_no = new int[mat_alloc];
		for(int l = 0; l < mat_alloc; l++)
			col_no[l] = 0;

		col_end = new int[columns + 1];
		for(int i1 = 0; i1 < columns + 1; i1++)
			col_end[i1] = 0;

		row_end = new int[rows + 1];
		for(int j1 = 0; j1 < rows + 1; j1++)
			row_end[j1] = 0;

		row_end_valid = 0;
		orig_rh = new double[rows + 1];
		for(int k1 = 0; k1 < rows + 1; k1++)
			orig_rh[k1] = 0.0D;

		rh = new double[rows + 1];
		for(int l1 = 0; l1 < rows + 1; l1++)
			rh[l1] = 0.0D;

		rhs = new double[rows + 1];
		for(int i2 = 0; i2 < rows + 1; i2++)
			rhs[i2] = 0.0D;

		must_be_int = new int[sum + 1];
		for(int j2 = 0; j2 < sum + 1; j2++)
			must_be_int[j2] = 0;

		orig_upbo = new double[sum + 1];
		for(int k2 = 0; k2 <= sum; k2++)
			orig_upbo[k2] = infinite;

		upbo = new double[sum + 1];
		for(int l2 = 0; l2 < sum + 1; l2++)
			upbo[l2] = 0.0D;

		orig_lowbo = new double[sum + 1];
		for(int i3 = 0; i3 < sum + 1; i3++)
			orig_lowbo[i3] = 0.0D;

		lowbo = new double[sum + 1];
		for(int j3 = 0; j3 < sum + 1; j3++)
			lowbo[j3] = 0.0D;

		basis_valid = 1;
		bas = new int[rows + 1];
		for(int k3 = 0; k3 <= rows; k3++)
			bas[k3] = 0;

		basis = new int[sum + 1];
		for(int l3 = 0; l3 <= sum; l3++)
			basis[l3] = 0;

		lower = new int[sum + 1];
		for(int i4 = 0; i4 <= rows; i4++)
		{
			bas[i4] = i4;
			basis[i4] = 1;
		}

		for(int j4 = rows + 1; j4 <= sum; j4++)
			basis[j4] = 0;

		for(int k4 = 0; k4 <= sum; k4++)
			lower[k4] = 1;

		eta_valid = 1;
		eta_size = 0;
		eta_alloc = 10000;
		max_num_inv = 50;
		nr_lagrange = 0;
		eta_value = new double[eta_alloc];
		for(int l4 = 0; l4 < eta_alloc; l4++)
			eta_value[l4] = 0.0D;

		eta_row_nr = new int[eta_alloc];
		for(int i5 = 0; i5 < eta_alloc; i5++)
			eta_row_nr[i5] = 0;

		eta_col_end = new int[rows_alloc + max_num_inv];
		for(int j5 = 0; j5 < rows_alloc + max_num_inv; j5++)
			eta_col_end[j5] = 0;

		bb_rule = 0;
		break_at_int = 0;
		break_value = 0.0D;
		iter = 0;
		total_iter = 0;
		solution = new double[sum + 1];
		for(int k5 = 0; k5 <= sum; k5++)
			solution[k5] = 0.0D;

		best_solution = new double[sum + 1];
		for(int l5 = 0; l5 <= sum; l5++)
			best_solution[l5] = 0.0D;

		duals = new double[rows + 1];
		for(int i6 = 0; i6 <= rows; i6++)
			duals[i6] = 0.0D;

		maximise = 0;
		floor_first = 1;
		scaling_used = 0;
		columns_scaled = 0;
		ch_sign = new int[rows + 1];
		for(int j6 = 0; j6 <= rows; j6++)
			ch_sign[j6] = 0;

		valid = 0;
	}
}
