cassowary-ruby 0.5.0

data/lib/strength.rb

@@ -0,0 +1,31 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class Strength
+    attr_accessor :name, :symbolic_weight
+
+    def initialize(name = nil, symbolic_weight = nil)
+      self.name = name
+      self.symbolic_weight = symbolic_weight
+    end
+
+    def required?
+      self == RequiredStrength
+    end
+
+    def inspect
+      "#{name}"
+    end
+
+    def each
+      [RequiredStrength, StrongStrength, MediumStrength, WeakStrength].each do |str|
+        yield str
+      end
+    end
+
+    RequiredStrength = new "required"
+    StrongStrength = new "strong", SymbolicWeight.new([1.0])
+    MediumStrength = new "medium", SymbolicWeight.new([0.0, 1.0])
+    WeakStrength = new "weak", SymbolicWeight.new([0.0, 0.0, 1.0])
+  end
+end

data/lib/symbolic_weight.rb

@@ -0,0 +1,115 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class SymbolicWeight
+    include Enumerable
+    include Comparable
+
+    StrengthLevels = 3
+
+    def initialize(levels = {})
+      @levels = [0.0] * StrengthLevels
+      case levels
+      when Hash
+        levels.each_pair do |k, v|
+          self[k] = v
+        end
+      when Array
+        levels.each_with_index do |e, idx|
+          self[idx] = e
+        end
+      else
+        raise InternalError
+      end
+    end
+
+    def each(*args, &block)
+      @levels.each(*args, &block)
+    end
+
+    def [](idx)
+      @levels[idx]
+    end
+
+    def []=(idx, value)
+      @levels[idx] = value
+    end
+
+    def *(n)
+      raise InternalError unless n.is_a? Numeric
+      result = SymbolicWeight.new
+      each_with_index do |e, idx|
+        result[idx] = e * n
+      end
+      result
+    end
+
+    def /(n)
+      raise InternalError unless n.is_a? Numeric
+      result = SymbolicWeight.new
+      each_with_index do |e, idx|
+        result[idx] = e / n
+      end
+      result
+    end
+
+    def +(n)
+      raise InternalError unless n.is_a? SymbolicWeight
+      result = SymbolicWeight.new
+      each_with_index do |e, idx|
+        result[idx] = e + n[idx]
+      end
+      result
+    end
+
+    def -(n)
+      raise InternalError unless n.is_a? SymbolicWeight
+      result = SymbolicWeight.new
+      each_with_index do |e, idx|
+        result[idx] = e - n[idx]
+      end
+      result
+    end
+
+    def <=>(other)
+      raise InternalError unless other.is_a? SymbolicWeight
+      each_with_index do |e, idx|
+        return -1 if e < other[idx]
+        return 1 if e > other[idx]
+      end
+      0
+    end
+
+    def cl_approx(s)
+      raise InternalError unless s.is_a? SymbolicWeight
+      each_with_index do |e, idx|
+        return false unless e.cl_approx(s[idx])
+      end
+      true
+    end
+
+    def cl_approx_zero
+      cl_approx Zero
+    end
+
+    def definitely_negative
+      epsilon = SimplexSolver::Epsilon
+      nepsilon = 0.0 - epsilon
+      each do |e|
+        return true if e < nepsilon
+        return false if e > epsilon
+      end
+      false
+    end
+
+    def symbolic_weight?
+      true
+    end
+
+    def inspect
+      "[" + @levels.join(",") + "]"
+    end
+
+    Zero = new([0.0] * StrengthLevels)
+  end
+end

data/lib/utils/equalities.rb

@@ -0,0 +1,27 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+    module Equalities
+    def cn_equal(expr, strength = Strength::RequiredStrength, weight = 1.0)
+      cn_equality(LinearEquation, self - expr, strength, weight)
+    end
+
+    def cn_geq(expr, strength = Strength::RequiredStrength, weight = 1.0)
+      cn_equality(LinearInequality, self - expr, strength, weight)
+    end
+
+    def cn_leq(expr, strength = Strength::RequiredStrength, weight = 1.0)
+      expr = expr.as_linear_expression if expr.is_a?(Numeric)
+      cn_equality(LinearInequality, expr - self, strength, weight)
+    end
+
+    private
+    def cn_equality(klass, expr, strength, weight)
+      cn = klass.new
+      cn.expression = expr
+      cn.strength = strength
+      cn.weight = weight
+      cn
+    end
+  end
+end

data/lib/variables/abstract_variable.rb

@@ -0,0 +1,35 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class AbstractVariable
+    attr_accessor :name
+
+    def initialize(hash = {})
+      self.name = hash[:name]
+    end
+
+    def dummy?
+      false
+    end
+
+    def external?
+      raise NotImplementedError, "my subclass should have implemented #external?"
+    end
+
+    def pivotable?
+      raise NotImplementedError, "my subclass should have implemented #pivotable?"
+    end
+
+    def restricted?
+      raise NotImplementedError, "my subclass should have implemented #restricted?"
+    end
+
+    def inspect
+      if name
+        "#{name}"
+      else
+        "<CV#0x#{object_id.to_s(16)}>"
+      end
+    end
+  end
+end

data/lib/variables/dummy_variable.rb

@@ -0,0 +1,21 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class DummyVariable < AbstractVariable
+    def dummy?
+      true
+    end
+
+    def external?
+      false
+    end
+
+    def pivotable?
+      false
+    end
+
+    def restricted?
+      true
+    end
+  end
+end

data/lib/variables/objective_variable.rb

@@ -0,0 +1,17 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class ObjectiveVariable < AbstractVariable
+    def external?
+      false
+    end
+
+    def pivotable?
+      false
+    end
+
+    def restricted?
+      false
+    end
+  end
+end

data/lib/variables/slack_variable.rb

@@ -0,0 +1,17 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class SlackVariable < AbstractVariable
+    def external?
+      false
+    end
+
+    def pivotable?
+      true
+    end
+
+    def restricted?
+      true
+    end
+  end
+end

data/lib/variables/variable.rb

@@ -0,0 +1,56 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class Variable < AbstractVariable
+    include Equalities
+
+    attr_accessor :value
+
+    def initialize(hash)
+      super
+      self.value = hash[:value]
+    end
+
+    def *(expr)
+      self.as_linear_expression * expr
+    end
+
+    def +(expr)
+      self.as_linear_expression + expr
+    end
+
+    def -(expr)
+      self.as_linear_expression - expr
+    end
+
+    def /(expr)
+      self.as_linear_expression / expr
+    end
+
+    def as_linear_expression
+      expr = LinearExpression.new
+      expr.terms[self] = 1.0
+      expr
+    end
+
+    def external?
+      true
+    end
+
+    def pivotable?
+      false
+    end
+
+    def restricted?
+      false
+    end
+
+    def -@
+      -1.0.as_linear_expression * self
+    end
+
+    def inspect
+      "#{super}[#{value.inspect}]"
+    end
+  end
+end

data/lib/variables.rb

@@ -0,0 +1,5 @@
+require "variables/abstract_variable"
+require "variables/dummy_variable"
+require "variables/objective_variable"
+require "variables/slack_variable"
+require "variables/variable"

data/test/test_abstract_methods.rb

@@ -0,0 +1,22 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class AbstractMethodsTest < Test::Unit::TestCase
+  def test_constraint
+    assert_raise NotImplementedError do
+      Cassowary::Constraint.new.expression
+    end
+  end
+
+  def test_abstract_variable
+    var = Cassowary::AbstractVariable.new
+    assert_raise NotImplementedError do
+      var.external?
+    end
+    assert_raise NotImplementedError do
+      var.pivotable?
+    end
+    assert_raise NotImplementedError do
+      var.restricted?
+    end
+  end
+end

data/test/test_cassowary.rb

@@ -0,0 +1,184 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class CassowaryTests < Test::Unit::TestCase
+  include Cassowary
+
+  def test_add_delete1
+    x = Variable.new(name: 'x')
+    solver = SimplexSolver.new
+    solver.add_constraint x.cn_equal(100.0, Strength::WeakStrength)
+    c10 = x.cn_leq 10.0
+    c20 = x.cn_leq 20.0
+    solver.add_constraint c10
+    solver.add_constraint c20
+    assert x.value.cl_approx(10.0)
+
+    solver.remove_constraint c10
+    assert x.value.cl_approx(20.0)
+
+    solver.remove_constraint c20
+    assert x.value.cl_approx(100.0)
+
+    c10again = x.cn_leq 10.0
+    solver.add_constraint c10
+    solver.add_constraint c10again
+    assert x.value.cl_approx(10.0)
+
+    solver.remove_constraint c10
+    assert x.value.cl_approx(10.0)
+
+    solver.remove_constraint c10again
+    assert x.value.cl_approx(100.0)
+  end
+
+  def test_add_delete2
+    x = Variable.new name: 'x'
+    y = Variable.new name: 'y'
+
+    solver = SimplexSolver.new
+    solver.add_constraint x.cn_equal(100.0, Strength::WeakStrength)
+    solver.add_constraint y.cn_equal(120.0, Strength::StrongStrength)
+
+    c10 = x.cn_leq(10.0)
+    c20 = x.cn_leq(20.0)
+    solver.add_constraint c10
+    solver.add_constraint c20
+    assert x.value.cl_approx(10.0)
+    assert y.value.cl_approx(120.0)
+
+    solver.remove_constraint c10
+    assert x.value.cl_approx 20.0
+    assert y.value.cl_approx 120.0
+
+    cxy = (x * 2).cn_equal y
+    solver.add_constraint cxy
+    assert x.value.cl_approx 20
+    assert y.value.cl_approx 40
+
+    solver.remove_constraint c20
+    assert x.value.cl_approx 60
+    assert y.value.cl_approx 120
+
+    solver.remove_constraint cxy
+    assert x.value.cl_approx 100
+    assert y.value.cl_approx 120
+
+    cxy2 = (x * 1.as_linear_expression).cn_equal(1000)
+    solver.add_constraint cxy2
+    assert x.value.cl_approx 1000
+  end
+
+  def test_add_delete3
+    x = Variable.new name: 'x'
+    solver = SimplexSolver.new
+    c1 = x.cn_equal 100, Strength::WeakStrength, 5
+    c2 = x.cn_equal 200, Strength::WeakStrength
+
+    solver.add_constraint c1
+    solver.add_constraint c2
+    assert x.value.cl_approx 100
+
+    solver.remove_constraint c1
+    assert x.value.cl_approx 200
+  end
+
+  def test_inconsistent1
+    x = Variable.new name: 'x'
+    solver = SimplexSolver.new
+    solver.add_constraint x.cn_equal 10
+    assert_raise RequiredFailure do
+      solver.add_constraint x.cn_equal 5
+    end
+  end
+
+  def test_inconsistent2
+    x = Variable.new name: 'x'
+    solver = SimplexSolver.new
+    solver.add_constraint x.cn_geq 10
+    assert_raise RequiredFailure do
+      solver.add_constraint x.cn_leq 5
+    end
+  end
+
+  def test_stay1
+    x = Variable.new name: 'x', value: 20
+    solver = SimplexSolver.new
+
+    solver.add_stay x, Strength::WeakStrength
+    assert x.value.cl_approx 20
+  end
+
+  def test_two_solutions
+    x = Variable.new name: 'x'
+    y = Variable.new name: 'y'
+
+    solver = SimplexSolver.new
+    solver.add_constraint x.cn_leq y
+    solver.add_constraint y.cn_equal x + 3
+    solver.add_constraint x.cn_equal 10, Strength::WeakStrength
+    solver.add_constraint y.cn_equal 10, Strength::WeakStrength
+
+    assert(x.value.cl_approx(10) && y.value.cl_approx(13) ||
+           x.value.cl_approx(7) && y.value.cl_approx(10))
+  end
+
+  def test_weighted1
+    x = Variable.new name: 'x'
+    solver = SimplexSolver.new
+
+    c15 = x.cn_equal 15, Strength::WeakStrength
+    c20 = x.cn_equal 20, Strength::WeakStrength, 2
+
+    solver.add_constraint c15
+    assert x.value.cl_approx 15
+
+    solver.add_constraint c20
+    assert x.value.cl_approx 20
+
+    solver.remove_constraint c20
+    assert x.value.cl_approx 15
+  end
+
+  def test_edit1
+    x = Variable.new name: 'x', value: 20
+    y = Variable.new name: 'y', value: 30
+
+    solver = SimplexSolver.new
+    solver.add_stay x, Strength::WeakStrength
+    solver.add_constraint x.cn_geq 10
+    solver.add_constraint x.cn_leq 100
+    solver.add_constraint x.cn_equal y * 2
+    assert x.value.cl_approx 20
+    assert y.value.cl_approx 10
+
+    solver.add_edit_var y, Strength::StrongStrength
+    solver.begin_edit
+    solver.suggest_value y, 35
+    solver.resolve
+    assert x.value.cl_approx 70
+    assert y.value.cl_approx 35
+
+    solver.suggest_value y, 80
+    solver.resolve
+    assert x.value.cl_approx 100
+    assert y.value.cl_approx 50
+
+    solver.suggest_value y, 25
+    solver.resolve
+    assert x.value.cl_approx 50
+    assert y.value.cl_approx 25
+
+    solver.end_edit
+    assert x.value.cl_approx 50
+    assert y.value.cl_approx 25
+
+    solver.add_edit_var x, Strength::StrongStrength
+    solver.begin_edit
+    solver.suggest_value x, 44.0
+    solver.resolve
+    assert x.value.cl_approx 44
+    assert y.value.cl_approx 22
+
+    solver.end_edit
+  end
+end

data/test/test_ext.rb

@@ -0,0 +1,38 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class ExtTests < Test::Unit::TestCase
+  def test_float_approx_zero
+    assert !1.1.cl_approx_zero
+    assert 0.0.cl_approx_zero
+    assert 0.1e-8.cl_approx_zero
+  end
+
+  def test_float_approx
+    assert 1.1.cl_approx 1.1
+  end
+
+  def test_float_negative
+    assert -1.1.definitely_negative
+    assert -0.1e-5.definitely_negative
+    assert ! -0.1e-8.definitely_negative
+  end
+
+  def test_numeric_as_linear_expression
+    expr = 1.as_linear_expression
+    assert expr.terms.empty?
+    assert expr.constant == 1.to_f
+
+    expr = 1.1.as_linear_expression
+    assert expr.terms.empty?
+    assert expr.constant == 1.1
+  end
+
+  def test_object_approx
+    assert "foo".cl_approx "foo"
+    assert ! Object.new.cl_approx(Object.new)
+  end
+
+  def test_object_symbolic_weight
+    assert !Object.new.symbolic_weight?
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+if ENV["coverage"]
+  require "simplecov"
+  SimpleCov.start do
+    add_filter "/test/"
+    minimum_coverage 90
+  end
+end
+
+require "test/unit"
+require "cassowary"

data/test/test_variables.rb

@@ -0,0 +1,33 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class VariablesTests < Test::Unit::TestCase
+  def test_operations
+    x = Cassowary::Variable.new name: 'x', value: 20
+    expr = x / 10
+    assert expr.constant == 0
+    assert expr.terms[x] == 0.1
+
+    expr = x * 10
+    assert expr.terms[x] == 10
+
+    expr = x - 10
+    assert expr.constant == -10
+
+    expr = x + 10
+    assert expr.constant == 10
+
+    expr = -x
+    assert expr.terms[x] == -1
+  end
+
+  def test_inspect
+    x = Cassowary::Variable.new name: 'x', value: 21.1
+    assert_equal "x[21.1]", x.inspect
+
+    x = Cassowary::Variable.new name: 'x'
+    assert_equal "x[nil]", x.inspect
+
+    x = Cassowary::SlackVariable.new
+    assert_equal "<CV#0x" + x.object_id.to_s(16) + ">", x.inspect
+  end
+end