cossincalc 1.0.0

data/lib/cossincalc/triangle/formatter.rb

@@ -0,0 +1,73 @@
+module CosSinCalc
+  class Triangle
+    class Formatter
+      UNIT_FACTORS = { :radian => Math::PI, :degree => 180.0, :gon => 200.0 }
+      
+      attr_reader :triangle, :precision # References to associated triangle object and data precision.
+      
+      def initialize(triangle, precision = 2)
+        @triangle  = triangle
+        @precision = precision
+      end
+      
+      # Converts an input value to a number.
+      def self.parse(value)
+        return value if value.is_a? Float
+        return nil if value.nil? || value.to_s !~ /\S/
+        
+        value = value.to_s.gsub(/[^\d.,]+/, '').split(/[^\d]+/)
+        value.push('.' + value.pop) if value.length > 1
+        value.join.to_f
+      end
+      
+      # Converts an input angle value in some unit to a radian number.
+      def self.parse_angle(value, from_unit)
+        value.is_a?(Float) ? value : convert_angle(parse(value), from_unit)
+      end
+      
+      # Converts the given value from the unit specified to radians.
+      # If reverse is true, the value will be converted from radians to the specified unit.
+      def self.convert_angle(value, unit, reverse = false)
+        return nil if value.nil?
+        
+        factor = (Math::PI / UNIT_FACTORS[unit.to_sym])
+        value * (reverse ? 1.0 / factor : factor)
+      end
+      
+      # Returns the size of the angle to the given variable, rounded and converted to the prefered unit.
+      def angle(v)
+        format(Formatter.convert_angle(t.angle(v), t.angles.unit, true), @precision)
+      end
+      
+      private
+      # Shorthand-method referencing the associated triangle object.
+      def t
+        @triangle
+      end
+      
+      # Rounds the value down to the specified amount of decimals.
+      def round(value, decimals)
+        multiplier = 10 ** decimals
+        (value * multiplier).round.to_f / multiplier
+      end
+      
+      # Formats the given value to improve human readability.
+      def format(value, decimals)
+        "%.#{decimals}f" % round(value, decimals)
+      end
+      
+      # Returns the number of significant digits of the given value.
+      def significant_digits(number)
+        number.to_s.gsub(/^[0.]+/, '').length
+      end
+      
+      def method_missing(name, *args)
+        if [:side, :altitude, :median, :angle_bisector, :area, :circumference].include?(name)
+          format(t.send(name, *args), @precision)
+        else
+          super(name, *args)
+        end
+      end
+    end
+  end
+end

data/lib/cossincalc/triangle/formatter/latex.rb

@@ -0,0 +1,134 @@
+module CosSinCalc
+  class Triangle
+    class Formatter
+      class Latex
+        # Initializes the LaTeX renderer.
+        def initialize(formatter)
+          @formatter = formatter
+          @triangle  = formatter.triangle
+        end
+        
+        # Returns the generated LaTeX code.
+        def to_tex(filename = nil)
+          document(@triangle.alt ? (<<-EOT) : document_content(filename))
+#{document_content(filename ? filename + '-1' : nil)}
+
+\\newpage
+\\section*{Alternative triangle}
+Another triangle can be constructed based on the variables given.\\\\[0.2 cm]
+
+#{Latex.new(@triangle.alt.humanize(f.precision)).document_content(filename ? filename + '-2' : nil)}
+EOT
+        end
+        
+        # Saves the generated LaTeX to a TeX file.
+        # The filename should be provided without the .tex extension.
+        def save_tex(filename)
+          File.open("#{filename}.tex", 'w') { |f| f.write(to_tex(filename)) }
+        end
+        
+        # Saves the generated LaTeX to a TeX file and then converts it using pdflatex.
+        # The filename should be provided without the .pdf extension.
+        def save_pdf(filename)
+          save_tex(filename)
+          `pdflatex \"#{filename}.tex\" --output-directory #{File.dirname(filename)}`
+        end
+        
+        # Returns the content of the LaTeX document.
+        def document_content(image_filename = nil)
+          variable_table + "\\\\[0.2 cm]\n\n" + equations + "\n\n" + drawing(image_filename)
+        end
+        
+        private
+        # Shorthand-method referencing the associated formatter object.
+        def f
+          @formatter
+        end
+        
+        # Wraps the variables calculated in a LaTeX table.
+        def variable_table
+          table = "\\begin{tabular}{ r r r r r }\n"
+          table << ['Angles', 'Sides', 'Altitudes', 'Medians', 'Angle bisectors'].join(' & ') + " \\\\ \\hline\n"
+          
+          @triangle.each do |v|
+            table << [ "$#{v.to_s.upcase}=#{format_angle(f.angle(v), @triangle.angles.unit)}$", "$#{v}=#{f.side(v)}$",
+              "$h_#{v.to_s.upcase}=#{f.altitude(v)}$", "$m_#{v}=#{f.median(v)}$",
+              "$t_#{v.to_s.upcase}=#{f.angle_bisector(v)}$" ].join(' & ') + " \\\\\n"
+          end
+          
+          table << "\\end{tabular}"
+        end
+        
+        # Adds the appropriate unit to the angle value.
+        def format_angle(value, unit)
+          value + case unit
+          when :degree then '\degree'
+          when :gon    then '\unit{gon}'
+          when :radian then '\unit{radian}'
+          end
+        end
+        
+        # Formats the equation for embedding into a LaTeX document.
+        def format_equation(latex, variables, angle_unit)
+          latex.gsub! /@pi/, (angle_unit == :radian ? '\pi' :
+            format_angle(CosSinCalc::Triangle::Formatter::UNIT_FACTORS[angle_unit].to_i.to_s, angle_unit))
+          
+          symbols = latex.gsub /[$@]\d/ do |match|
+            v = variables[match[1..-1].to_i - 1]
+            (match[0] == ?@ ? v.to_s.upcase : v.to_s)
+          end
+          
+          values = latex.gsub /[$@]\d/ do |match|
+            v = variables[match[1..-1].to_i - 1]
+            (match[0] == ?@ ? format_angle(f.angle(v), angle_unit) : f.side(v))
+          end.split('=').reverse.join('=')
+          
+          symbols + ' &= ' + values
+        end
+        
+        # Returns the list of equations performed during calculation.
+        def equations
+          "\\begin{align*}\n" +
+            @triangle.equations.map { |latex, vars| format_equation(latex, vars, @triangle.angles.unit) }.join("\\\\\n") +
+            "\n\\end{align*}"
+        end
+        
+        # Saves the associated drawing and returns the embedding LaTeX code.
+        # If no filename is given no image will be saved (can be used in testing).
+        def drawing(filename = nil)
+          CosSinCalc::Triangle::Drawing.new(f).save_png(filename) if filename
+          "\\begin{center}\n\\includegraphics[scale=0.4]{#{filename || 'placeholder'}}\n\\end{center}"
+        end
+        
+        # Wraps the given LaTeX content into a LaTeX document ready to write to filesystem.
+        def document(content)
+          <<-EOT
+\\documentclass{article}
+\\usepackage{amsmath}
+\\usepackage{amsfonts}
+\\usepackage{graphicx}
+
+\\DeclareMathSymbol{*}{\\mathbin}{symbols}{"01}
+\\newcommand{\\unit}[1]{\\ensuremath{\\, \\mathrm{#1}}}
+\\newcommand{\\degree}{\\ensuremath{^{\\circ}}}
+
+% Uncomment to use a comma as the decimal separator (you would still write a period in the source).
+% \\DeclareMathSymbol{,}{\\mathpunct}{letters}{"3B}
+% \\DeclareMathSymbol{.}{\\mathord}{letters}{"3B}
+% \\DeclareMathSymbol{\\decimal}{\\mathord}{letters}{"3A}
+
+\\title{CosSinCalc Calculation Results}
+\\author{Calculated by the CosSinCalc Triangle Calculator}
+
+\\begin{document}
+\\maketitle
+
+#{content}
+
+\\end{document}
+EOT
+        end
+      end
+    end
+  end
+end

data/lib/cossincalc/triangle/validator.rb

@@ -0,0 +1,87 @@
+module CosSinCalc
+  class Triangle
+    class Validator
+      NOT_ENOUGH_VARIABLES = '3 values must be specified.'
+      TOO_MANY_VARIABLES   = 'Only 3 values should be specified.'
+      NO_SIDES             = 'At least one side must be given.'
+      INVALID_SIDE         = 'Only numbers (above zero) are accepted values for a side.'
+      INVALID_ANGLE        = 'Only numbers (above zero) are accepted values for an angle. Furthermore the angle must remain inside the scope of the sum of all angles in the triangle.'
+      INVALID_TRIANGLE     = 'The specified values do not match a valid triangle.'
+      CALCULATOR_PRECISION = 0.01
+      
+      class ValidationError < Exception
+        attr_reader :messages, :sides_valid, :angles_valid
+        
+        def initialize(messages, sides_valid = {}, angles_valid = {})
+          @messages, @sides_valid, @angles_valid = messages, sides_valid, angles_valid
+        end
+      end
+      
+      def initialize(triangle)
+        @triangle = triangle
+      end
+      
+      # Validates the triangle before calculation and raises an exception on errors.
+      def validate
+        @sides_valid, @angles_valid = {}, {}
+        
+        t.each do |v|
+          @sides_valid[v]  = t.side(v).nil?  || valid_side?(t.side(v))
+          @angles_valid[v] = t.angle(v).nil? || valid_angle?(t.angle(v))
+        end
+        
+        errors = error_messages
+        errors.empty? || (raise ValidationError.new(errors, @sides_valid, @angles_valid))
+      end
+      
+      # Checks whether the calculation was successful and the values given/calculated match a triangle.
+      def validate_calculation
+        t.each do |v, r|
+          raise ValidtionError.new([INVALID_TRIANGLE]) unless valid_side?(t.side(v)) && valid_angle?(t.angle(v))
+          
+          angle = t.calculate_angle_by_sides(v, r)
+          unless angle > t.angle(v) - CALCULATOR_PRECISION && angle < t.angle(v) + CALCULATOR_PRECISION
+            raise ValidtionError.new([INVALID_TRIANGLE])
+          end
+        end
+        return true
+      end
+      
+      private
+      # Shorthand-method referencing the associated triangle object.
+      def t
+        @triangle
+      end
+      
+      # Returns an array of unique errors raised when validating the triangle.
+      def error_messages
+        errors = []
+        errors << INVALID_SIDE  if @sides_valid.values.include?(false)
+        errors << INVALID_ANGLE if @angles_valid.values.include?(false)
+        
+        if errors.empty?
+          errors << NOT_ENOUGH_VARIABLES if total_values < 3
+          errors << TOO_MANY_VARIABLES   if total_values > 3
+          errors << NO_SIDES             if t.sides.amount < 1
+        end
+        
+        return errors
+      end
+      
+      # Returns the total number of variables given.
+      def total_values
+        @total_values ||= t.sides.amount + t.angles.amount
+      end
+      
+      # Returns whether the value is a valid side.
+      def valid_side?(value)
+        value.is_a?(Float) && value.finite? && value > 0
+      end
+      
+      # Returns whether the value is a valid angle.
+      def valid_angle?(value)
+        valid_side?(value) && value < Math::PI
+      end
+    end
+  end
+end

data/lib/cossincalc/triangle/variable_hash.rb

@@ -0,0 +1,24 @@
+module CosSinCalc
+  class Triangle
+    class VariableHash < Hash
+      attr_accessor :unit
+      
+      # Initializes the variables.
+      def initialize
+        super()
+        CosSinCalc::Triangle::VARIABLES.each { |v| self[v] = nil }
+      end
+      
+      # If a symbol is given, returns the associated value.
+      # If an array of symbols is given, returns an array of the associated values.
+      def [](vars)
+        vars.is_a?(Array) ? vars.map { |v| super(v) } : super(vars)
+      end
+      
+      # Returns the amount of variables that have a value.
+      def amount
+        self.values.compact.size
+      end
+    end
+  end
+end

data/lib/cossincalc/version.rb

@@ -0,0 +1,3 @@
+module CosSinCalc
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: cossincalc
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Molte Emil Strange Andersen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-30 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: |
+  CosSinCalc is a web application able to calculate the variables of a triangle. The live site is located at http://cossincalc.com/. This is an offline version of the calculator.
+  
+  You can use the included command line utility to generate a PDF page containing all the results, formulae and a drawing of the triangle, or you can include it as a library in your Ruby application and use just the features you care about.
+
+email: molte@cossincalc.com
+executables: 
+- cossincalc
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- Rakefile
+- lib/core_ext.rb
+- lib/cossincalc/triangle/calculator.rb
+- lib/cossincalc/triangle/drawing/svg.rb
+- lib/cossincalc/triangle/drawing.rb
+- lib/cossincalc/triangle/formatter/latex.rb
+- lib/cossincalc/triangle/formatter.rb
+- lib/cossincalc/triangle/validator.rb
+- lib/cossincalc/triangle/variable_hash.rb
+- lib/cossincalc/triangle.rb
+- lib/cossincalc/version.rb
+- lib/cossincalc.rb
+- bin/cossincalc
+- bin/trollop.rb
+has_rdoc: true
+homepage: http://cossincalc.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Triangle calculator
+test_files: []
+