amor 0.0.2

data/spec/amor/expression_spec.rb

@@ -0,0 +1,275 @@
+require 'amor/expression'
+
+module Amor
+  describe Expression do
+    before(:each) do
+      @variable = double('Variable')
+      @expression = Expression.new([[2, @variable]])
+    end
+
+    describe '.new' do
+      context 'when used with another Expression' do
+        before(:each) do
+          @other_variable = double('Variable')
+          @other_expression = Expression.new([[3.0, @other_variable]])
+        end
+
+        it 'Copys the Expression' do
+          expect(Expression.new(@other_expression).factors).to eq(@other_expression.factors)
+        end
+      end
+
+      context 'when used with an Array of factors' do
+        before(:each) do
+          @factors = [[3.0, double('Variable')]]
+        end
+
+        it 'Creates an Expression with the given factors' do
+          expect(Expression.new(@factors).factors).to eq(@factors)
+        end
+      end
+
+      context 'when used with a Variable' do
+        before(:each) do
+          @variable = Variable.new(double('Model'),1)
+        end
+
+        it 'Creates an Expression with the given variable as factor with scalar 1' do
+          expect(Expression.new(@variable).factors).to eq([[1, @variable]])
+        end
+      end
+
+      [-3, -3.0].each do |number|
+        context "when used with a #{number.class}" do
+          it 'Creates an Expression with the given number as a constant factor' do
+            expect(Expression.new(number).factors).to eq([[number, :constant]])
+          end
+        end
+      end
+
+    end
+
+    describe '#+' do
+      context 'when used with another Expression' do
+        before(:each) do
+          @other_variable = double('Other Variable')
+          @other_expression = Expression.new([[3.0, @other_variable]])
+        end
+
+        it 'returns an Expression' do
+          expect(@expression + @other_expression).to be_a(Expression)
+        end
+
+        it 'returns an Expression with the combined factors of both Expressions' do
+          expect((@expression + @other_expression).factors).to eq([[2, @variable], [3.0, @other_variable]])
+        end
+      end
+
+      context 'when used with a variable' do
+        before(:each) do
+          @other_variable = Variable.new(double('Model'),1)
+        end
+
+        it 'returns an Expression' do
+          expect(@expression + @other_variable).to be_a(Expression)
+        end
+
+        it 'returns an Expression with the factor of the variable set to 1' do
+          expect((@expression + @other_variable).factors).to eq([[2, @variable], [1, @other_variable]])
+        end
+      end
+
+      [4, 4.0].each do |number|
+        context "when used with a #{number.class}" do
+          it 'returns an Expression' do
+            expect(@expression + number).to be_a(Expression)
+          end
+
+          it 'returns an Expression with the the last factor set to the corresponding constant' do
+            expect((@expression + number).factors).to eq([[2, @variable], [number, :constant]])
+          end
+        end
+      end
+    end
+
+    describe '#-' do
+      context 'when used with another Expression' do
+        before(:each) do
+          @other_variable = double('Other Variable')
+          @other_expression = Expression.new([[3.0, @other_variable]])
+        end
+
+        it 'returns an Expression' do
+          expect(@expression - @other_expression).to be_a(Expression)
+        end
+
+        it 'returns an Expression with the combined factors of the first Expression and the negative second Expression' do
+          expect((@expression - @other_expression).factors).to eq([[2, @variable], [-3.0, @other_variable]])
+        end
+      end
+
+      context 'when used with a variable' do
+        before(:each) do
+          @other_variable = Variable.new(double('Model'),1)
+        end
+
+        it 'returns an Expression' do
+          expect(@expression - @other_variable).to be_a(Expression)
+        end
+
+        it 'returns an Expression with the factor of the variable set to -1' do
+          expect((@expression - @other_variable).factors).to eq([[2, @variable], [-1, @other_variable]])
+        end
+      end
+
+      [4, 4.0].each do |number|
+        context "when used with a #{number.class}" do
+          it 'returns an Expression' do
+            expect(@expression - number).to be_a(Expression)
+          end
+
+          it 'returns an Expression with the the last factor set to the corresponding negative constant' do
+            expect((@expression - number).factors).to eq([[2, @variable], [-number, :constant]])
+          end
+        end
+      end
+    end
+
+    describe '#-@' do
+      it 'returns an Expression' do
+        expect(-@expression).to be_a(Expression)
+      end
+
+      it 'returns an Expression with the negative factors' do
+        expect((-@expression).factors).to eq([[-2, @variable]])
+      end
+    end
+
+    describe '#<=' do
+      context 'when used with another Expression' do
+        before(:each) do
+          @other_expression = Expression.new(5.0)
+        end
+
+        it 'returns a Constraint' do
+          expect(@expression <= @other_expression).to be_a(Constraint)
+        end
+
+        it 'sets the Constraints relation to :lesser_equal' do
+          expect((@expression <= @other_expression).relation).to eq(:lesser_equal)
+        end
+
+        it 'sets the lhs of the Constraint to self' do
+          expect((@expression <= @other_expression).lhs).to eql(@expression)
+        end
+
+        it 'sets the rhs of the Constraint to the other Expression' do
+          expect((@expression <= @other_expression).rhs).to eql(@other_expression)
+        end
+      end
+    end
+
+    describe '#>=' do
+      context 'when used with another Expression' do
+        before(:each) do
+          @other_expression = Expression.new(5.0)
+        end
+
+        it 'returns a Constraint' do
+          expect(@expression >= @other_expression).to be_a(Constraint)
+        end
+
+        it 'sets the Constraints relation to :greater_equal' do
+          expect((@expression >= @other_expression).relation).to eq(:greater_equal)
+        end
+
+        it 'sets the lhs of the Constraint to self' do
+          expect((@expression >= @other_expression).lhs).to eql(@expression)
+        end
+
+        it 'sets the rhs of the Constraint to the other Expression' do
+          expect((@expression >= @other_expression).rhs).to eql(@other_expression)
+        end
+      end
+    end
+
+    describe '#==' do
+      context 'when used with another Expression' do
+        before(:each) do
+          @other_expression = Expression.new(5.0)
+        end
+
+        it 'returns a Constraint' do
+          expect(@expression == @other_expression).to be_a(Constraint)
+        end
+
+        it 'sets the Constraints relation to :greater_equal' do
+          expect((@expression == @other_expression).relation).to eq(:equal)
+        end
+
+        it 'sets the lhs of the Constraint to self' do
+          expect((@expression == @other_expression).lhs).to eql(@expression)
+        end
+
+        it 'sets the rhs of the Constraint to the other Expression' do
+          expect((@expression == @other_expression).rhs).to eql(@other_expression)
+        end
+      end
+    end
+
+    describe '#simplified' do
+      it 'returns an Expression' do
+        expect(Expression.new(1).simplified).to be_a(Expression)
+      end
+
+      it 'returns the Expression with no dupplications in the factors' do
+        v1 = double('Variable')
+        v2 = double('Variable')
+        v3 = double('Variable')
+        factors = Expression.new([[3, v1], [-2.0, v2], [-1, v1], [2, :constant], [2.5, v3], [1, v2], [-2.0, :constant], [3, :constant], [-2.5, v3]]).simplified.factors
+        expect(factors).to include([2, v1])
+        expect(factors).to include([-1.0, v2])
+        expect(factors).to include([3.0, :constant])
+      end
+
+      it 'returns an Expression where no factors with scalar 0 appear' do
+        v1 = double('Variable')
+        v2 = double('Variable')
+        v3 = double('Variable')
+        expect(Expression.new([[3, v1], [-2.0, v2], [-1, v1], [2, :constant], [2.5, v3], [1, v2], [-2.0, :constant], [3, :constant], [-2.5, v3]]).simplified.factors.flatten).not_to include(v3)
+      end
+    end
+
+    describe '#remove_constants' do
+      it 'returns an Expression containing all but the constant factors' do
+        model = Model.new
+        v1 = model.x(1)
+        v2 = model.x(2)
+        v3 = model.x(3)
+        factors = Expression.new([[3, v1], [-2.0, v2], [-1, v1], [2, :constant], [2.5, v3], [1, v2], [-2.0, :constant], [3, :constant], [-2.5, v3]]).remove_constants.factors
+        expect(factors).to eq([[3, v1], [-2.0, v2], [-1, v1], [2.5, v3], [1, v2], [-2.5, v3]])
+      end
+    end
+
+    describe '#constant_factor' do
+      it 'returns the total constant factor' do
+        model = Model.new
+        v1 = model.x(1)
+        v2 = model.x(2)
+        v3 = model.x(3)
+        expect(Expression.new([[3, v1], [-2.0, v2], [-1, v1], [2, :constant], [2.5, v3], [1, v2], [-2.0, :constant], [3, :constant], [-2.5, v3]]).constant_factor).to eq(3.0)
+      end
+    end
+
+    describe '#lp_string' do
+      it 'returns a string representation feasible for the LP file format' do
+        model = Model.new
+        v1 = model.x(1)
+        v2 = model.x(2)
+        v3 = model.x(3)
+        expect(Expression.new([[3, v1], [-2.0, v2], [-1, v1], [2, :constant], [2.5, v3], [1, v2], [-2.0, :constant], [3, :constant], [-2.5, v3]]).lp_string).to eq('2 x1 - 1.0 x2 + 3.0')
+      end
+    end
+
+  end
+end

data/spec/amor/model_spec.rb

@@ -0,0 +1,120 @@
+require 'amor/model'
+
+module Amor
+  describe Model do
+    before(:each) do
+      @model = Model.new
+    end
+
+    describe '#x' do
+      it 'returns a variable' do
+        expect(@model.x(1)).to be_a(Variable)
+      end
+
+      it 'returns the same variable for the same indices' do
+        expect(@model.x(1)).to equal(@model.x(1))
+      end
+
+      it 'returns different variables for different indices' do
+        expect(@model.x(1)).not_to equal(@model.x(2))
+      end
+
+      it 'stores the model in the variable' do
+        expect(@model.x(1).model).to equal(@model)
+      end
+
+      it 'stores the index in the variable' do
+        expect(@model.x(1).index).to equal(1)
+      end
+    end
+
+    describe '#min' do
+      before(:each) do
+        @expression = Expression.new([[3, double('Variable')], [-2, double('Variable')]])
+      end
+
+      it 'returns an Objective' do
+        expect(@model.min(@expression)).to be_a(Objective)
+      end
+
+      it 'returns an Objective with the direction set to :min' do
+        expect(@model.min(@expression).direction).to eq(:minimize)
+      end
+
+      it 'returns an Objective with the expression set to the given Expression' do
+        expect(@model.min(@expression).expression).to eql(@expression)
+      end
+
+      it 'stores the objective in the model' do
+        objective = @model.min(@expression)
+        expect(@model.objective).to equal(objective)
+      end
+    end
+
+    describe '#max' do
+      before(:each) do
+        @expression = Expression.new([[3, double('Variable')], [-2, double('Variable')]])
+      end
+
+      it 'returns an Objective' do
+        expect(@model.max(@expression)).to be_a(Objective)
+      end
+
+      it 'returns an Objective with the direction set to :max' do
+        expect(@model.max(@expression).direction).to eq(:maximize)
+      end
+
+      it 'returns an Objective with the expression set to the given Expression' do
+        expect(@model.max(@expression).expression).to eql(@expression)
+      end
+
+      it 'stores the objective in the model' do
+        objective = @model.max(@expression)
+        expect(@model.objective).to equal(objective)
+      end
+    end
+
+    describe '#st' do
+      before(:each) do
+        @constraint = Constraint.new(1, :greater_equal, Variable.new(double('Model'), 1))
+      end
+
+      it 'returns the given Constraint' do
+        expect(@model.st(@constraint)).to equal(@constraint)
+      end
+
+      it 'stores the constraint in the model' do
+        @model.st(@constraint)
+        expect(@model.constraints).to include(@constraint)
+      end
+    end
+
+
+    describe '.from_string' do
+      before(:each) do
+        @string = "min x(3) + 3 * x(2) + 4.0\nst x(2) - 2.0 * x(3) <= 5.0"
+      end
+
+      it 'returns a Model' do
+        expect(Model.from_string(@string)).to be_a(Model)
+      end
+
+      it 'returns a Model with the specified objective' do
+        model = Model.from_string(@string)
+        expect(model.objective.expression.factors).to eq([[1, model.x(3)], [3, model.x(2)], [4.0, :constant]])
+      end
+
+      it 'returns a Model with the specified constraint' do
+        model = Model.from_string(@string)
+        expect(model.constraints[0].lhs.factors).to eq([[1, model.x(2)], [-2.0, model.x(3)]])
+      end
+    end
+
+    describe '.lp_string' do
+      it 'returns a LP Format ready string of the model' do
+        model = Model.from_string("min x(3) + 3 * x(2) + 4.0\nst x(2) - 2.0 * x(3) <= 5.0")
+        expect(model.lp_string).to eq("Minimize\n obj: 1 x1 + 3 x2 + 4.0\nSubject To\n c1: 1 x2 - 2.0 x1 <= 5.0\nEnd")
+      end
+    end
+  end
+end

data/spec/amor/numeric_extensions_spec.rb

@@ -0,0 +1,83 @@
+require 'amor/numeric_extensions'
+
+module Amor
+  [5, 5.0].each do |number|
+    describe "#{number.class}" do
+      describe '#*' do
+        context 'when used with a variable' do
+          before(:each) do
+            @variable = Variable.new(double('Model'), 1)
+          end
+
+          it 'returns an Expression' do
+            expect(number * @variable).to be_a(Expression)
+          end
+
+          it 'returns an Expression with the factor of the variable set to the number' do
+            expect((number * @variable).factors).to eq([[number, @variable]])
+          end
+        end
+      end
+
+      describe '#+' do
+        context 'when used with an expression' do
+          before(:each) do
+            @variable = double('Variable')
+            @expression = Expression.new([[2.0, @variable]])
+          end
+
+          it 'returns an Expression' do
+            expect(number + @expression).to be_a(Expression)
+          end
+
+          it 'returns an Expression with the first factor set to the constant' do
+            expect((number + @expression).factors).to eq([[number, :constant], [2.0, @variable]])
+          end
+        end
+
+        context 'when used with a variable' do
+          before(:each) do
+            @variable = Variable.new(double('Model'), 1)
+          end
+          it 'returns an Expression' do
+            expect(number + @variable).to be_a(Expression)
+          end
+
+          it 'returns an Expression with the first factor set to the constant and the second to the variable with scalar 1' do
+            expect((number + @variable).factors).to eq([[number, :constant], [1, @variable]])
+          end
+        end
+      end
+
+      describe '#-' do
+        context 'when used with an expression' do
+          before(:each) do
+            @variable = double('Variable')
+            @expression = Expression.new([[2.0, @variable]])
+          end
+
+          it 'returns an Expression' do
+            expect(number - @expression).to be_a(Expression)
+          end
+
+          it 'returns an Expression with the first factor set to the constant and the second to the negative Expression' do
+            expect((number - @expression).factors).to eq([[number, :constant], [-2.0, @variable]])
+          end
+        end
+
+        context 'when used with a variable' do
+          before(:each) do
+            @variable = Variable.new(double('Model'), 1)
+          end
+          it 'returns an Expression' do
+            expect(number - @variable).to be_a(Expression)
+          end
+
+          it 'returns an Expression with the first factor set to the constant and the second to the variable with scalar -1' do
+            expect((number - @variable).factors).to eq([[number, :constant], [-1, @variable]])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/amor/objective_spec.rb

@@ -0,0 +1,14 @@
+require 'amor/objective'
+
+module Amor
+  describe Objective do
+    describe '#lp_string' do
+      it 'returns LP format ready version of objective, starting with Maximize if direction is :maximize' do
+        expect(Objective.new(:maximize, Expression.new(2)).lp_string).to eq("Maximize\n obj: 2")
+      end
+      it 'returns LP format ready version of objective, starting with Minimize if direction is :minimize' do
+        expect(Objective.new(:minimize, Expression.new(2)).lp_string).to eq("Minimize\n obj: 2")
+      end
+    end
+  end
+end

data/spec/amor/variable_spec.rb

@@ -0,0 +1,140 @@
+require 'amor/variable'
+
+module Amor
+  describe Variable do
+    before(:each) do
+      @model = double('Model')
+      @variable = Variable.new(@model, 1)
+    end
+
+    describe '#*' do
+      # Make sure it works with Integer and Float
+      [5, 5.0].each do |number|
+        context "used with a #{number.class} as scalar" do
+          it "returns an Expression when called with #{number}" do
+            expect(@variable * number).to be_a(Expression)
+          end
+
+          it "returns an Expression with one factor" do
+            expect((@variable * number).factors.size).to eq(1)
+          end
+
+          it "returns an Expression with one factor consisting of given variable and the value it was called with" do
+            expect((@variable * number).factors.first).to eq([number, @variable])
+          end
+        end
+      end
+    end
+
+    describe '#+' do
+      context 'when used with an expression' do
+        before(:each) do
+          @other_variable = double('Other Variable')
+          @other_expression = Expression.new([[3.0, @other_variable]])
+        end
+
+        it 'returns an Expression' do
+          expect(@variable + @other_expression).to be_a(Expression)
+        end
+
+        it 'returns an Expression with the factor of the variable set to 1' do
+          expect((@variable + @other_expression).factors).to eq([[1, @variable], [3.0, @other_variable]])
+        end
+      end
+
+      context 'when used with a variable' do
+        before(:each) do
+          @other_variable = Variable.new(@model,2)
+        end
+
+        it 'returns an Expression' do
+          expect(@variable + @other_variable).to be_a(Expression)
+        end
+
+        it 'returns an Expression with the factor of the variables set to 1' do
+          expect((@variable + @other_variable).factors).to eq([[1, @variable], [1, @other_variable]])
+        end
+      end
+
+      [6, 6.0].each do |number|
+        context "when used with a #{number.class}" do
+          it 'returns an Expression' do
+            expect(@variable + number).to be_a(Expression)
+          end
+
+          it 'returns an Expression with the first factor set to the variable and the second factor set to the constant' do
+            expect((@variable + number).factors).to eq([[1, @variable], [number, :constant]])
+          end
+        end
+      end
+    end
+
+    describe '#-' do
+      context 'when used with an expression' do
+        before(:each) do
+          @other_variable = double('Other Variable')
+          @other_expression = Expression.new([[3.0, @other_variable]])
+        end
+
+        it 'returns an Expression' do
+          expect(@variable - @other_expression).to be_a(Expression)
+        end
+
+        it 'returns an Expression with the factor of the variable set to 1 and the negative expression' do
+          expect((@variable - @other_expression).factors).to eq([[1, @variable], [-3.0, @other_variable]])
+        end
+      end
+
+      context 'when used with a variable' do
+        before(:each) do
+          @other_variable = Variable.new(@model,2)
+        end
+
+        it 'returns an Expression' do
+          expect(@variable - @other_variable).to be_a(Expression)
+        end
+
+        it 'returns an Expression with the factor of the first variable set to 1 and the second to -1' do
+          expect((@variable - @other_variable).factors).to eq([[1, @variable], [-1, @other_variable]])
+        end
+      end
+
+      [6, 6.0].each do |number|
+        context "when used with a #{number.class}" do
+          it 'returns an Expression' do
+            expect(@variable - number).to be_a(Expression)
+          end
+
+          it 'returns an Expression with the first factor set to the variable and the second factor set to the negative constant' do
+            expect((@variable - number).factors).to eq([[1, @variable], [-number, :constant]])
+          end
+        end
+      end
+    end
+
+    describe '#-@' do
+      it 'returns an Expression' do
+        expect(-@variable).to be_a(Expression)
+      end
+
+      it 'returns an Expression with the variables factor set to -1' do
+        expect((-@variable).factors).to eq([[-1, @variable]])
+      end
+    end
+
+    describe '#internal_index' do
+      before(:each) do
+        @model = Model.new
+      end
+
+      it 'returns 0 for the first variable' do
+        expect(@model.x(1).internal_index).to eq(0)
+      end
+
+      it 'returns 1 for the second variable' do
+        @model.x(1)
+        expect(@model.x(2).internal_index).to eq(1)
+      end
+    end
+  end
+end