cassowary-ruby 0.5.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OWZkYjdhMWMwYjdkZWM3OWE0NGM2NDVhODFlMjdkZDQ0YzkxN2FjMg==
+  data.tar.gz: !binary |-
+    NmU1YWEyOTZkNGIyNTM2YmFiZjk3ZjVjMDczNjMyMGJmYWVkNDMxMg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YTFhOTI5ZjZjMjAzMGMwN2JkMzJlYWYxZGMyZjg2NjllMWU2NTA1ZmExN2Y5
+    NDA1Nzk5ZWI4MDcxYjBjOWY1ZDRhYjNkY2EyNmQ3YWI4ODE1ZjdiMDkyMGFi
+    YWRlZjZmN2UwNDQ3NmZmMjNkNTMyNjRjMzlhMmM5OTY3N2FhOTU=
+  data.tar.gz: !binary |-
+    N2NlZDE5NGYwMWRiZDgwNjViYjFmOWJlZDJmYThiMmI5ZGZhZjNlZDYyNjRk
+    N2YxNWEzODliYjZlMzE0MTliZjY3OTk1MjRkOWQ5OGJhMDNkZDEyMjRhODc4
+    ZTQ1ZjcyOGIzZDVjMmJlOGRlYzlkZDY0Y2I1MWJkYWJkYjA3ZTE=

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Tim Felgentreff
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,18 @@
+## Cassowary
+
+Cassowary is an incremental constraint solving toolkit that
+efficiently solves systems of linear equalities and
+inequalities. Constraints may be either requirements or
+preferences. Client code specifies the constraints to be maintained,
+and the solver updates the constrained variables to have values that
+satisfy the constraints.
+
+This is a Ruby port of the Smalltalk version of Cassowary. The
+original distribution can be found
+[here](http://www.cs.washington.edu/research/constraints/cassowary/).
+
+A technical report is included in the original distribution that
+describes the algorithm, interface, and implementation of the
+Cassowary solver. Additionally, the distribution contains toy sample
+applications written in Smalltalk, C++, Java, and Python, and a more
+complex example Java applet, the "Constraint Drawing Application".

data/lib/cassowary.rb

@@ -0,0 +1,25 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  VERSION = "0.5.0"
+
+  class Error < StandardError; end
+  class InternalError < Error; end
+  class NonLinearResult < Error; end
+  class NotEnoughStays < Error; end
+  class RequiredFailure < Error; end
+  class TooDifficult < Error; end
+end
+
+require "utils/equalities"
+
+require "variables"
+require "constraint"
+require "symbolic_weight"
+require "strength"
+require "linear_expression"
+require "simplex_solver"
+
+require "ext/object"
+require "ext/float"
+require "ext/numeric"

data/lib/constraint/edit_or_stay_constraint.rb

@@ -0,0 +1,40 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class EditOrStayConstraint < Constraint
+    attr_accessor :variable
+
+    def initialize(hash = {})
+      hash = {:weight => 1.0}.merge(hash)
+      self.variable = hash[:variable]
+      self.strength = hash[:strength]
+      self.weight = hash[:weight]
+    end
+
+    def expression
+      e = LinearExpression.new
+      e.constant = variable.value
+      e.terms[variable] = -1.0
+      e
+    end
+  end
+
+  class EditConstraint < EditOrStayConstraint
+    attr_accessor :value
+
+    def initialize(hash = {})
+      super
+      self.value = hash[:value]
+    end
+
+    def edit_constraint?
+      true
+    end
+  end
+
+  class StayConstraint < EditOrStayConstraint
+    def stay_constraint?
+      true
+    end
+  end
+end

data/lib/constraint/linear_constraint.rb

@@ -0,0 +1,23 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class LinearConstraint < Constraint
+    attr_accessor :expression
+  end
+
+  class LinearEquation < LinearConstraint
+    def inspect
+      "#{strength.inspect}(#{expression.inspect}=0)"
+    end
+  end
+
+  class LinearInequality < LinearConstraint
+    def inequality?
+      true
+    end
+
+    def inspect
+      "#{strength.inspect}(#{expression.inspect}>=0)"
+    end
+  end
+end

data/lib/constraint.rb

@@ -0,0 +1,30 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class Constraint
+    attr_accessor :strength, :weight
+
+    def expression
+      raise NotImplementedError, "my subclass should have implemented #expression"
+    end
+
+    def edit_constraint?
+      false
+    end
+
+    def inequality?
+      false
+    end
+
+    def required?
+      strength.required?
+    end
+
+    def stay_constraint?
+      false
+    end
+  end
+end
+
+require "constraint/edit_or_stay_constraint"
+require "constraint/linear_constraint"

data/lib/ext/float.rb

@@ -0,0 +1,24 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+class Float
+  def cl_approx(float)
+    # Answer true if I am approximately equal to the argument
+    epsilon = Cassowary::SimplexSolver::Epsilon
+    if self == 0.0
+      float.abs < epsilon
+    elsif float == 0.0
+      abs < epsilon
+    else
+      (self - float).abs < (abs * epsilon)
+    end
+  end
+
+  def cl_approx_zero
+    cl_approx 0.0
+  end
+
+  def definitely_negative
+    # return true if I am definitely negative (i.e. smaller than negative epsilon)"
+    self < (0.0 - Cassowary::SimplexSolver::Epsilon)
+  end
+end

data/lib/ext/numeric.rb

@@ -0,0 +1,11 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+class Numeric
+  include Cassowary::Equalities
+
+  def as_linear_expression
+    expr = Cassowary::LinearExpression.new
+    expr.constant = self.to_f
+    expr
+  end
+end

data/lib/ext/object.rb

@@ -0,0 +1,11 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+class Object
+  def cl_approx(x)
+    self == x
+  end
+
+  def symbolic_weight?
+    false
+  end
+end

data/lib/linear_expression.rb

@@ -0,0 +1,163 @@
+# Copyright (C) 2012 by Tim Felgentreff
+
+module Cassowary
+  class LinearExpression
+    include Equalities
+
+    attr_accessor :constant, :terms
+
+    def self.new_with_symbolic_weight
+      result = self.new
+      result.constant = SymbolicWeight::Zero
+      result
+    end
+
+    def initialize
+      self.constant = 0.0
+      self.terms = {}
+    end
+
+    def any_variable
+      if terms.any?
+        terms.keys.first
+      else
+        raise InternalError, "expression is constant"
+      end
+    end
+
+    def as_linear_expression
+      self
+    end
+
+    def coefficient_for(variable)
+      terms[variable] || 0.0
+    end
+
+    def constant?
+      terms.empty?
+    end
+
+    def each_variable_and_coefficient(&block)
+      terms.each_pair(&block)
+    end
+
+    def add_variable(variable, coefficient, subject = nil, solver = nil)
+      if terms.has_key? variable
+        new_coeff = coefficient + terms[variable]
+        if new_coeff.cl_approx_zero
+          terms.delete variable
+          solver.note_removed_variable(variable, subject) if solver
+        else
+          terms[variable] = new_coeff
+        end
+      else
+        terms[variable] = coefficient
+        solver.note_added_variable(variable, subject) if solver
+      end
+    end
+
+    def add_expression(expr, times, subject = nil, solver = nil)
+      increment_constant(times * expr.constant)
+      expr.each_variable_and_coefficient do |v, c|
+        add_variable(v, times * c, subject, solver)
+      end
+    end
+
+    def new_subject(subject)
+      nreciprocal = -(1.0 / terms.delete(subject))
+      self.constant *= nreciprocal
+      terms.each_pair do |v, c|
+        terms[v] = c * nreciprocal
+      end
+    end
+
+    def change_subject(old, new)
+      reciprocal = 1.0 / terms.delete(new)
+      nreciprocal = -reciprocal
+      self.constant *= nreciprocal
+      terms.each_pair do |v, c|
+        terms[v] = c * nreciprocal
+      end
+      terms[old] = reciprocal
+    end
+
+    def increment_constant(num)
+      self.constant += num
+    end
+
+    def substitute_variable(var, expr, subject, solver)
+      multiplier = terms.delete(var)
+      increment_constant(multiplier * expr.constant)
+      expr.each_variable_and_coefficient do |v, c|
+        if old_coeff = terms[v]
+          new_coeff = old_coeff + (multiplier * c)
+          if new_coeff.cl_approx_zero
+            terms.delete v
+            solver.note_removed_variable v, subject
+          else
+            terms[v] = new_coeff
+          end
+        else
+          terms[v] = multiplier * c
+          solver.note_added_variable v, subject
+        end
+      end
+    end
+
+    def *(x)
+      return x * constant if constant?
+
+      n = if x.is_a? Numeric
+            x.to_f
+          else
+            expr = x.as_linear_expression
+            raise NonLinearResult unless expr.constant?
+            expr.constant
+          end
+      result = LinearExpression.new
+      result.constant = n * constant
+      terms.each_pair do |v, c|
+        result.terms[v] = n * c
+      end
+      result
+    end
+
+    def /(x)
+      expr = x.as_linear_expression
+      raise NonLinearResult unless expr.constant?
+      self * (1.0 / expr.constant)
+    end
+
+    def +(x)
+      expr = x.as_linear_expression
+      result = LinearExpression.new
+      result.constant = constant + expr.constant
+      terms.each_pair do |v, c|
+        result.terms[v] = c
+      end
+      expr.each_variable_and_coefficient do |v, c|
+        result.add_variable(v, c)
+      end
+      result
+    end
+
+    def -(x)
+      expr = x.as_linear_expression
+      result = LinearExpression.new
+      result.constant = constant - expr.constant
+      terms.each_pair do |v, c|
+        result.terms[v] = c
+      end
+      expr.each_variable_and_coefficient do |v, c|
+        result.add_variable(v, -c)
+      end
+      result
+    end
+
+    def inspect
+      terms.keys.inject(constant.inspect) do |str, v|
+        "#{str}+#{terms[v].inspect}*#{v.inspect}"
+      end
+    end
+  end
+end