rulp 0.1.0

A library providing functionality to parse, create and solve linear programming problems.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

extern crate rulinalg;
extern crate assert_approx_eq;
extern crate rulp;

#[allow(unused_imports)]
use assert_approx_eq::*;
use rulp::builder::{Builder, BuilderBase};
use rulp::parser::{Parser, ParserBase};
use rulp::solver::{SolverBase, SimplexSolver};
use rulp::solver::Status;
use std::fs::File;

#[test]
fn minimize_text_test() {
	let text_problem = "	
		# Radiation Example;

		var x_1;
		var x_2;

		minimize healthy_anatomy_exposure: 0.4*x_1 + 0.5*x_2;
		subject to critical_tissues: 0.3*x_1 + 0.1*x_2 <= 2.7;
		subject to tumor_region: 0.5*x_1 + 0.5*x_2 == 6;
		subject to tumor_center: 0.6*x_1 + 0.4*x_2 >= 6;
	";

	let builder = Builder::new();
	let lp = Parser::lp_from_text(text_problem, builder);
	println!("{}", lp);
	let solver = SimplexSolver::new(lp);
	let solution = solver.solve();
	print!("finished solving");
	print!("{:?}", &solution);

	let expected_sol = vec![7.5, 4.5];
	let sol = solution.values.unwrap();
	for i in 0 .. expected_sol.len() {
		assert_approx_eq!(expected_sol[i], sol[i]);
	}
	assert_approx_eq!(5.25, solution.objective.unwrap());
}


#[test]
fn maximize_text_test () {
	let text_problem = "	
		# This is a problem;

		var television;
		var newspaper;
		var radio;

		maximize objective: 100000.*television + 40000.*newspaper + 18000.*radio;

		subject to constraint_1: 20.*television + 6.*newspaper + 3.*radio <= 182.;
		subject to constraint_2: newspaper <= 10.;
		subject to constraint_3: -1.*television + -1.*newspaper + radio <= 0.;
		subject to constraint_4: -9.*television + newspaper + radio <= 0.;

		# Nothing more to see here;
	";
	let builder = Builder::new();
	let lp = Parser::lp_from_text(text_problem, builder);
	println!("{}", lp);
	let simplex = SimplexSolver::new(lp);
	let solution = simplex.solve();
	println!("{:?}", &solution);
	let res = solution.values.unwrap();
	let expected = vec![4., 10., 14.];
	assert_eq!(solution.status, Status::Optimal);
	for i in 0..expected.len() {
		assert_approx_eq!(res[i], expected[i]);
	}
	assert_eq!(solution.objective.unwrap(), 1052000.);
}	

#[test]
fn advertisement_file_test() {
	let builder = Builder::new();
	let mut input_file = File::open("./tests/test_files/advertisement_example.lp").unwrap();
	let lp = Parser::lp_from_file(&mut input_file, builder);

	let solver = SimplexSolver::new(lp);
	let solution = solver.solve();

	let res = solution.values.unwrap();
	let expected = vec![4., 10., 14.];
	assert_eq!(solution.status, Status::Optimal);
	for i in 0..expected.len() {
		assert_approx_eq!(res[i], expected[i]);
	}
	assert_eq!(solution.objective.unwrap(), 1052000.);
}

#[test]
fn radiation_file_test() {
	let builder = Builder::new();
	let mut input_file = File::open("./tests/test_files/radiation_example.lp").unwrap();
	let lp = Parser::lp_from_file(&mut input_file, builder);

	let solver = SimplexSolver::new(lp);
	let solution = solver.solve();

	let expected_sol = vec![7.5, 4.5];
	let sol = solution.values.unwrap(); // returning [7.5, 0.3, 0, 4.5]
	for i in 0 .. expected_sol.len() {
		assert_approx_eq!(expected_sol[i], sol[i]);
	}
	assert_approx_eq!(5.25, solution.objective.unwrap());
}


#[test]
fn unbounded_file_test() {
	let builder = Builder::new();
	let mut input_file = File::open("./tests/test_files/unbounded_example.lp").unwrap();
	let lp = Parser::lp_from_file(&mut input_file, builder);

	let solver = SimplexSolver::new(lp);
	let solution = solver.solve();

	assert_eq!(solution.objective, None);
	assert_eq!(solution.values, None);
	assert_eq!(solution.status, Status::Unbounded);
}

#[test]
fn infeasible_file_test() {
	let builder = Builder::new();
	let mut input_file = File::open("./tests/test_files/infeasible_example.lp").unwrap();
	let lp = Parser::lp_from_file(&mut input_file, builder);

	let solver = SimplexSolver::new(lp);
	let solution = solver.solve();

	assert_eq!(solution.objective, None);
	assert_eq!(solution.values, None);
	assert_eq!(solution.status, Status::Infeasible);
}