cossincalc 1.0.0

data/lib/core_ext.rb

@@ -0,0 +1,18 @@
+# Taken from Active Support (copyright (c) 2005-2008 David Heinemeier Hansson),
+# which is realeased under the MIT license as part of the Ruby on Rails framework.
+# http://github.com/rails/rails/blob/babbc1580da9e4a23921ab68d47c7c0d2e8447da/activesupport/lib/active_support/core_ext/symbol.rb
+
+unless :to_proc.respond_to?(:to_proc)
+  class Symbol
+    # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
+    #
+    # # The same as people.collect { |p| p.name }
+    # people.collect(&:name)
+    #
+    # # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
+    # people.select(&:manager?).collect(&:salary)
+    def to_proc
+      Proc.new { |*args| args.shift.__send__(self, *args) }
+    end
+  end
+end

data/lib/cossincalc.rb

@@ -0,0 +1,13 @@
+require 'core_ext'
+require 'cossincalc/version'
+require 'cossincalc/triangle/calculator'
+require 'cossincalc/triangle/drawing/svg'
+require 'cossincalc/triangle/drawing'
+require 'cossincalc/triangle/formatter'
+require 'cossincalc/triangle/formatter/latex'
+require 'cossincalc/triangle/validator'
+require 'cossincalc/triangle/variable_hash'
+require 'cossincalc/triangle'
+
+module CosSinCalc
+end

data/lib/cossincalc/triangle.rb

@@ -0,0 +1,124 @@
+module CosSinCalc
+  class Triangle
+    include Calculator
+    
+    VARIABLES = [:a, :b, :c]
+    
+    attr_reader :alt # Reference to alternative triangle at ambiguous case.
+    attr_reader :equations # Steps performed to calculate the result.
+    
+    # Initializes a triangle object with the given sides and angles and an optional reference to an alternative triangle.
+    # 
+    # The sides and angles may be given either as a VariableHash object or an ordinary hash.
+    # The angle unit may be specified inside the given_angles hash (using the key :unit and value either :degree, :gon or :radian).
+    # If no angle unit is given it defaults to :degree.
+    # If a hash is used then value parsing and conversion will only occur if the values are provided as strings.
+    # Float angle values are expected to be radians no matter the given angle unit.
+    def initialize(given_sides, given_angles, alternative = nil)
+      initialize_variables
+      
+      given_sides.each { |v, value| side[v] = Formatter.parse(value) }
+      
+      angles.unit = (given_angles.respond_to?(:unit) ? given_angles.unit : given_angles.delete(:unit)) || :degree
+      given_angles.each { |v, value| angle[v] = Formatter.parse_angle(value, angles.unit) }
+      
+      @alt = alternative
+    end
+    
+    # Calculates the unknown variables in the triangle.
+    def calculate!
+      Validator.new(self).validate
+      calculate_variables
+      Validator.new(self).validate_calculation
+      @calculated = true
+    rescue Errno::EDOM
+      Validator::ValidationError.new([Validator::INVALID_TRIANGLE])
+    rescue Validator::ValidationError => exception
+      exception
+    end
+    
+    def humanize(precision = 2)
+      Formatter.new(self, precision)
+    end
+    
+    def angle(v = nil)
+      v.nil? ? @angles : @angles[v]
+    end
+    alias_method :angles, :angle
+    
+    def side(v = nil)
+      v.nil? ? @sides : @sides[v]
+    end
+    alias_method :sides, :side
+    
+    # Returns the length of the line which starts at the corner and is perpendicular with the opposite side.
+    def altitude(v)
+      require_calculation
+      r = rest(v)
+      Math.sin(angle(r[0])) * side(r[1])
+    end
+    
+    # Returns the length of the line going from the corner to the middle of the opposite side.
+    def median(v)
+      require_calculation
+      Math.sqrt((2 * sq(sides(rest(v))).inject(&:+) - sq(side(v))) / 4)
+    end
+    
+    # Returns the length of the line between a corner and the opposite side which bisects the angle at the corner.
+    def angle_bisector(v)
+      require_calculation
+      r = rest(v)
+      Math.sin(angle(r[0])) * side(r[1]) / Math.sin(angle(r[1]) + angle(v) / 2)
+    end
+    
+    # Returns the area of the triangle.
+    def area
+      require_calculation
+      side(VARIABLES[0]) * side(VARIABLES[1]) * Math.sin(angle(VARIABLES[2])) / 2
+    end
+    
+    # Returns the circumference of the triangle.
+    def circumference
+      require_calculation
+      sides(VARIABLES).inject(&:+)
+    end
+    
+    # Executes the given block for each variable symbol.
+    # If an array of variable names is given, only those variables will be iterated through.
+    def each(array = VARIABLES, &block)
+      array.each { |v| block.arity == 2 ? yield(v, rest(v)) : yield(v) }
+    end
+    
+    # Returns all the variable symbols except those given.
+    def rest(*vars)
+      VARIABLES - vars
+    end
+    
+    # Returns whether the missing values have been successfully calculated.
+    def calculated?
+      @calculated
+    end
+    
+    # Returns whether the given value is acute or not.
+    def acute?(value)
+      value < Math::PI / 2
+    end
+    
+    # Returns whether the given value is obtuse or not.
+    def obtuse?(value)
+      value > Math::PI / 2
+    end
+    
+    private
+    # Reset the sides, angles etc. to their default values.
+    def initialize_variables
+      @sides  = VariableHash.new
+      @angles = VariableHash.new
+    end
+    
+    # Calculate the missing values of the triangle if not already done.
+    def require_calculation
+      calculate! unless calculated?
+    end
+  end
+end

data/lib/cossincalc/triangle/calculator.rb

@@ -0,0 +1,118 @@
+module CosSinCalc
+  class Triangle
+    module Calculator
+      include Math
+      
+      def calculate_variables
+        case sides.amount
+        when 3 then calculate_three_angles
+        when 2 then calculate_two_angles
+        when 1 then calculate_two_sides
+        end
+      end
+      
+      # Calculates the last unknown angle and side.
+      # This function is public so it is derectly callable (used with ambiguous case).
+      def calculate_side_and_angle
+        calculate_two_sides
+      end
+      
+      # Calculates the value of an angle when all the sides are known.
+      def calculate_angle_by_sides(v, r)
+        acos (sq(sides(r)).inject(&:+) - sq(side(v))) / (2 * sides(r).inject(&:*))
+      end
+      
+      # Add a calculation step to the list of equations performed.
+      def equation(latex, *variables)
+        @equations ||= []
+        @equations << [latex, variables]
+      end
+      
+      private
+      def each(*args, &block)
+        @triangle.each(*args, &block)
+      end
+      
+      def sq(value)
+        value.is_a?(Array) ? value.map { |n| n * n } : (value * value)
+      end
+      
+      # Calculates all three angles when all three sides are known.
+      def calculate_three_angles
+        each do |v, r|
+          unless angle(v)
+            angle[v] = calculate_angle_by_sides(v, r)
+            equation('@1=\arccos\left(\frac{$2^2+$3^2-$1^2}{2 * $2 * $3}\right)', v, *r)
+          end
+        end
+      end
+      
+      # Calculates two unknown angles when two sides and one angle are known.
+      def calculate_two_angles
+        each do |v, r|
+          if angle(v)
+            unless side(v)
+              side[v] = sqrt sq(sides(r)).inject(&:+) -
+                2 * sides(r).inject(&:*) * cos(angle(v))
+              equation('$1=\sqrt{$2^2+$3^2-2 * $2 * $3 * \cos(@1)}', v, *r)
+              calculate_three_angles
+              break
+            end
+            
+            each(r) do |v2|
+              if side(v2)
+                angle[v2] = asin sin(angle(v)) * side(v2) / side(v)
+                equation('@2=\arcsin\left(\frac{\sin(@1) * $2}{$1}\right)', v, v2)
+                
+                if ambiguous_case?(v, v2)
+                  @alt = CosSinCalc::Triangle.new(sides, angles, self)
+                  @alt.angle[v2] = PI - angle(v2)
+                  @alt.equation('@2=@pi-\arcsin\left(\frac{\sin(@1) * $2}{$1}\right)', v, v2)
+                  @alt.calculate_side_and_angle
+                end
+                
+                calculate_two_sides
+                break
+              end
+            end
+            break
+          end
+        end
+      end
+      
+      # Calculates up to two unknown sides when at least one side and two angles are known.
+      def calculate_two_sides
+        calculate_last_angle
+        
+        each do |v, r|
+          if side(v)
+            each(r) do |v2|
+              unless side(v2)
+                side[v2] = sin(angle(v2)) * side(v) / sin(angle(v))
+                equation('$2=\frac{\sin(@2) * $1}{\sin(@1)}', v, v2)
+              end
+            end
+            break
+          end
+        end
+      end
+      
+      # Calculates the last unknown angle.
+      def calculate_last_angle
+        each do |v, r|
+          unless angle(v)
+            angle[v] = PI - angles(r).inject(&:+)
+            equation('@1=@pi-@2-@3', v, *r)
+            break
+          end
+        end
+      end
+      
+      # Calculates and returns whether the triangle has multiple solutions.
+      # See http://en.wikipedia.org/wiki/Law_of_sines#The_ambiguous_case
+      def ambiguous_case?(v1, v2)
+        acute?(angle(v1)) && side(v1) < side(v2) && side(v1) > side(v2) * sin(angle(v1))
+      end
+    end
+  end
+end

data/lib/cossincalc/triangle/drawing.rb

@@ -0,0 +1,76 @@
+module CosSinCalc
+  class Triangle
+    class Drawing
+      include Svg
+      
+      # Initializes the drawing object of the given formatter's triangle with the provided maximum size and border padding.
+      def initialize(formatter, size = 500, padding = 50)
+        @formatter, @size, @padding = formatter, size, padding
+        @triangle = @formatter.triangle
+        @coords = {}
+      end
+      
+      private
+      # Calculates the coordinates of the verticies of the triangle and scales it to maximum allowed size.
+      def draw
+        calculate_coords
+        resize
+        apply_padding
+      end
+      
+      # Shorthand-method referencing the associated triangle object.
+      def t; @triangle end
+      
+      # Shorthand-method referencing the associated triangle formatter object.
+      def f; @formatter end
+      
+      # Calculates the coordinates for the corners of the triangle.
+      def calculate_coords
+        @coords[:a] = [ 0, 0 ]
+        @coords[:b] = [ t.side(:c) * Math.cos(t.angle(:a)), t.altitude(:b) ]
+        @coords[:c] = [ t.side(:b), 0 ]
+        
+        if t.obtuse?(t.angle(:a))
+          move_coords(-@coords[:b][0])
+        end
+      end
+      
+      # Moves the corners of the triangle with the given distance to the right.
+      # Pass a negative value to move them to the left.
+      def move_coords(distance)
+        t.each { |v| @coords[v][0] += distance }
+      end
+      
+      # Scales the coordiantes to fit the size of the canvas.
+      def resize
+        scale_coords @size / [@coords[:b][0], @coords[:c][0], @coords[:b][1]].max
+      end
+      
+      # Scales the coordinates with the given amount.
+      def scale_coords(scalar)
+        t.each do |v|
+          @coords[v][0] *= scalar
+          @coords[v][1] *= scalar
+        end
+      end
+      
+      # Switches between bottom-left and top-left origin of the coordiante system.
+      def invert_coords
+        t.each { |v| @coords[v][1] = canvas_size - @coords[v][1] }
+      end
+      
+      # Adds a padding around the triangle.
+      def apply_padding
+        t.each do |v|
+          @coords[v][0] += @padding
+          @coords[v][1] += @padding
+        end
+      end
+      
+      # Returns the total size of the canvas, ie. the sum of the size of the triangle and the padding on both sides of it.
+      def canvas_size
+        @size + @padding * 2
+      end
+    end
+  end
+end

data/lib/cossincalc/triangle/drawing/svg.rb

@@ -0,0 +1,127 @@
+module CosSinCalc
+  class Triangle
+    class Drawing
+      module Svg
+        VERTEX_LABEL_MARGIN = 10 # The distance between the middle of the vertex label and the vertex itself.
+        VERTEX_VALUE_MARGIN = 55 # The distance between the middle of the vertex value and the vertex itself.
+        FONT_SIZE           = 12 # The font size of the labels.
+        ARC_RADIUS          = 25 # The radius of the circular arcs at the vertices.
+        NEXT_VARIABLE       = { :a => :b, :b => :c, :c => :a } # The association between a variable and the next.
+        
+        # Returns a drawing of the triangle in SVG (Scalable Vector Graphics) format.
+        def to_svg
+          draw
+          invert_coords
+          
+          polygon = @coords.values.map { |c| c.join(',') }.join(' ')
+          labels  = ''
+          
+          t.each { |v| labels << vertex_label(v) << vertex_arc(v) << vertex_value(v) }
+          t.each { |v| labels << edge_label(v) } # Needs to be drawn last in order to make ImageMagick render it correctly.
+          
+          <<-EOT
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="#{canvas_size}" height="#{canvas_size}">
+<polygon fill="#f5eae5" stroke="#993300" stroke-width="1" points="#{polygon}"/>
+#{labels}</svg>
+EOT
+        end
+        
+        # Saves a drawing of the triangle as an PNG file.
+        # The filename should be provided without the .png extension.
+        def save_png(filename)
+          save_svg(filename)
+          system "convert \"#{filename}.svg\" \"#{filename}.png\""
+        end
+        
+        # Saves a drawing of the triangle as an SVG file.
+        # The filename should be provided without the .svg extension.
+        def save_svg(filename)
+          File.open("#{filename}.svg", 'w') { |f| f.write(to_svg) }
+        end
+        
+        private
+        # Returns the SVG code for a label containing the given text at the given position.
+        def label(x, y, text, attributes = nil)
+          %[<text font-size="#{FONT_SIZE}" font-family="Verdana" fill="#333333" text-anchor="middle" x="#{x}" y="#{y + FONT_SIZE / 2}"#{' ' + attributes if attributes}>#{text}</text>\n]
+        end
+        
+        # Returns the equivalent cartesian coordiantes (x and y) of the given polar coordiantes (angle and distance).
+        def polar_to_cartesian(angle, distance)
+          [ Math.cos(angle), Math.sin(angle) ].map { |val| distance * val }
+        end
+        
+        # Returns the coordiantes of the vertex label of the given variable.
+        def vertex_label_coords(v)
+          x, y = *polar_to_cartesian(bisector_angle_to_x(v), VERTEX_LABEL_MARGIN)
+          [ @coords[v][0] - x, @coords[v][1] + y ]
+        end
+        
+        # Returns the SVG code for the vertex label of the given variable.
+        def vertex_label(v)
+          x, y = *vertex_label_coords(v)
+          label(x, y, v.to_s.upcase)
+        end
+        
+        # Returns the angle between the first edge (the right relative to the angle) connected to the given verted and the x-axis.
+        def angle_to_x(v)
+          case v
+          when :a then 0.0
+          when :b then -(t.angle(:b) + t.angle(:c))
+          when :c then Math::PI - t.angle(:c)
+          end
+        end
+        
+        # Returns the angle between the angle bisector of the given vertex and the x-axis.
+        def bisector_angle_to_x(v)
+          t.angle(v) / 2 + angle_to_x(v)
+        end
+        
+        # Returns the SVG code for the circular arcs at the given vertex.
+        def vertex_arc(v)
+          x1, y1 = *polar_to_cartesian(angle_to_x(v), ARC_RADIUS)
+          x2, y2 = *polar_to_cartesian(angle_to_x(v) + t.angle(v), ARC_RADIUS)
+          %[<path d="M #{@coords[v][0] + x1},#{@coords[v][1] - y1} A #{ARC_RADIUS},#{ARC_RADIUS} 0 0 0 #{@coords[v][0] + x2},#{@coords[v][1] - y2}" stroke="#90ee90" stroke-width="2" fill="none"/>\n]
+        end
+        
+        # Returns the coordiantes of the vertex value label of the given variable.
+        def vertex_value_coords(v)
+          x, y = *polar_to_cartesian(bisector_angle_to_x(v), VERTEX_VALUE_MARGIN)
+          [ @coords[v][0] + x, @coords[v][1] - y ]
+        end
+        
+        # Returns the SVG code for the vertex label containing the value of the angle including the unit.
+        def vertex_value(v)
+          x, y = *vertex_value_coords(v)
+          label(x, y, format_angle(f.angle(v), t.angles.unit))
+        end
+        
+        # Adds the appropriate unit to the angle value.
+        def format_angle(value, unit)
+          if unit == :degree
+            value + '&#176;'
+          else
+            value + ' gon'
+          end
+        end
+        
+        # Returns the SVG code for the given edge label.
+        def edge_label(v)
+          r = t.rest(v)
+          x = (@coords[r[1]][0] - @coords[r[0]][0]) / 2 + @coords[r[0]][0]
+          y = (@coords[r[1]][1] - @coords[r[0]][1]) / 2 + @coords[r[0]][1]
+          
+          v2    = NEXT_VARIABLE[v]
+          angle = CosSinCalc::Triangle::Formatter.convert_angle(angle_to_x(v2) + t.angle(v2), :degree, true)
+          text  = "#{v} = #{f.side(v)}"
+          
+          if angle < 90 && angle > -90
+            label(x, y - FONT_SIZE, text, %[transform="rotate(#{-angle} #{x},#{y})"])
+          else
+            label(x, y + FONT_SIZE, text, %[transform="rotate(#{180 - angle}, #{x},#{y})"])
+          end
+        end
+      end
+    end
+  end
+end