engineer_calculator 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c03e6d4e5cc39e07d4dee7deed72a0d76004424f0ab48ebdb11ac7b5c50e023e
-  data.tar.gz: 6af500776ffc9c40434d5ac3f25fe0f0ea0549be3dca8910c3e0478089fc66b1
+  metadata.gz: 32fe357799ad660cc4cfef2fad926400e8287afc853339b4e9d839f96562a811
+  data.tar.gz: 6e8289301ce855f7e754ac47312eb1d7e03b3cfe41883080a4b525a62847cb26
 SHA512:
-  metadata.gz: 782e5beaafe3f3690d68f59a8731e2517c905fcbdafabd72c579bb987df044288749871c0fafe40a1bae35ab0859e1eb982a713dece37826b0e4613310acdbf0
-  data.tar.gz: cfdf0997b87fba6a377167f3c30b7f5738c2c0db76e6f3194397ada055099f80da541913f54c03a70923126889b8555222b2d7b1e8f4bfb8c06b0d5cd7575d0e
+  metadata.gz: 26f9e977b09525668782a2e2479b90fccfc45b0e9e797220b7a445449a143c02e07db4ae2747980008fffe8e3f7de132ea4aee732ff57847e60deca666ff15d2
+  data.tar.gz: 6edaa70e71bb99122290b43c189857a2e92adcce8dea3f19298a79a31df94048cf266acdcced0e29df2ed7aa40de4f4d8ca01c766ead32c19a1b20ad0902f5c2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    engineer_calculator (1.0.1)
+    engineer_calculator (2.0.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/eng_calc.rb

@@ -0,0 +1,61 @@
+require "engineer_calculator/version"
+require 'yaml'
+require_relative "eng_unit"
+require_relative "eng_unit_calc"
+require_relative "eng_formula"
+
+module Eng
+  class Calc
+    include Math
+    include Unit
+    include UnitCalc
+    include Formula
+
+    attr_accessor :error, :alter
+    def calc(formula)
+
+      return nil unless formula
+
+      begin
+        c = { value: "", unit: [], si_formula: "", error: [] }
+
+        split_value_unit(formula.gsub("⋅","*")).map do |e_formula|
+          if e_formula[:unit].nil?
+            c[:value] << e_formula[:value].to_f.to_s + "r"
+            c[:si_formula] << e_formula[:value]
+          elsif e_formula[:value] =~ /#{operator_reg(:ari)}/
+            c[:value] << e_formula[:value]
+            c[:unit] << e_formula[:value]
+            c[:si_formula] << " " + e_formula[:value] + " "
+          else
+            result = convert(e_formula)
+            result[:value].to_f
+            c[:value] << result[:value].to_f.rationalize.to_s + "r"
+            c[:unit] << result[:unit].unshift("(").push(")")
+            c[:error] << result[:error] unless result[:error].nil? || result[:error].empty?
+            c[:si_formula] << result[:value].to_s + " " + result[:unit].join
+          end
+        end
+        c_unit = calc_unit(c[:unit].flatten)
+        { value: eval(c[:value]).to_f,
+          unit: c_unit[:unit],
+          error:  (c[:error] << c_unit[:error]).flatten.compact,
+          si_formula: c[:si_formula] }
+
+      rescue StandardError, SyntaxError
+        { value: "error", unit: "", error: "undifined formula", si_formula: formula}
+      end
+    end
+
+    def each_value(value: , si_unit: nil, kind: nil)
+      value = value.to_f.rationalize
+      kind = Unit.kind_by_si(si_unit) if si_unit
+      return false unless kind || Unit.variable[kind]
+      results = Unit.variable[kind].map do |unit|
+        { unit: unit[0],
+          value: eval(liner_function(unit[1])).to_f }
+      end
+      { kind: kind, result: results }
+    end
+  end
+end

data/lib/eng_formula.rb

@@ -0,0 +1,128 @@
+module Eng
+  module Formula
+    def split_value_unit(formula)
+      unit_array = []
+      formula_pre = formula.to_s.delete(" ")
+      formula_pre.scan(/(#{operator_reg(:tri)})|
+                      (?:(#{operator_reg(:num)}(?:#{operator_reg(:double)})*)((?:\/?\(?\/?[a-z]+\d*(?:\*[a-z])*(?:\W*[a-z]\d*\)*)*)(?:\d[^[a-z]])*\)?))|
+                      (#{operator_reg(:ari)})|
+                      ((?:#{operator_reg(:num)})*(?:#{operator_reg(:double)})?)/ix)
+                      .each do |data|
+                        unit_array << {
+                          value: (data[0] || data[1] || data[3] || data[4]),
+                          unit: (data[2] || data[3]) }
+      end
+
+      unit_array.each_with_index do |data, index|
+        if data[:unit] =~ /^[^\(]+\)$/
+          data[:unit].gsub!(/.$/,'')
+          unit_array.insert(index+1, { value: ")", unit: ")" })
+        end
+      end
+      unit_array.delete_if{ |data| true if data[:value].empty? && data[:unit].nil? }
+    end
+
+    def operator_reg(kind_operator)
+      case kind_operator
+      when :ari
+        /(?:[\(\)\+\-\*\/])/
+      when :double #２乗表現のマッチング (2^1/2)
+        /(?:\^\(?[\+\-]?\d+\/?\d*\)?)/
+      when :num
+        /\d+(?:\.\d*)?(?:e[+-]?\d+)?/
+      when :tri
+        /(?:sin|cos|tan)\(.+\)/
+      end
+    end
+
+    def split_by_ari(formula)
+      formula.split((/(#{operator_reg(:ari)})/))
+    end
+
+    def liner_function(formula)
+      formula_arr = formula.split(/(\*|\/|\+|-)/)
+      input_num = formula_arr.index("value")
+      mv_num = formula_arr.index{ |n| n =~ /\*|\// }
+      pm_num = formula_arr.index{ |n| n =~ /\+|-/ }
+
+      if mv_num
+        a_ari = formula_arr[mv_num]
+        if input_num > mv_num
+          a = formula_arr[mv_num - 1]
+        else
+          a = formula_arr[mv_num + 1]
+        end
+      else
+        a_ari = "/"
+        a = 1
+      end
+
+      if pm_num
+        b_ari = formula_arr[pm_num]
+        if input_num > pm_num
+          b = formula_arr[pm_num - 1]
+        else
+          b = formula_arr[pm_num + 1]
+        end
+      else
+        b_ari = "+"
+        b = 0
+      end
+
+      a_ari == "*" ? a_ari = "/" : a_ari = "*"
+      b_ari == "+" ? b_ari = "-" : b_ari = "+"
+
+      "value" + a_ari + a.to_s + b_ari + b.to_s + a_ari + a.to_s
+    end
+
+    def new_liner_function(formula)
+      fl_arr = formula.split(/(\*|\/|\+|-)/)
+      value_i = fl_arr.index("value")
+
+      a = []
+      b = []
+      pl = false
+      (value_i .. fl_arr.size - 1).each do |i|
+        if pl || fl_arr[i] == "+" || fl_arr[i] == "-"
+          b << reverse_operator(fl_arr[i])
+          pl = true
+        else
+          a << reverse_operator(fl_arr[i])
+        end
+      end
+
+      if value_i != 0
+        (0 .. value_i - 1).reverse_each do |i|
+          if fl_arr[i] == "+" || fl_arr[i] == "-" || i == 0
+            (i .. value_i - 1).reverse_each do |ii|
+              a.unshift(reverse_operator(fl_arr[ii]))
+            end
+
+            if i != 0
+              (0..i).each do |ii|
+                b.unshift(reverse_operator(fl_arr[ii], false))
+              end
+            end
+            break
+          end
+        end
+      end
+      a.join + "+(" + b.join + ")/value"
+    end
+
+    def reverse_operator(operator, opt = true)
+      case operator
+      when "+"
+        "-"
+      when "-"
+        "+"
+      when "*"
+        opt ? "/" : "*"
+      when "/"
+        opt ? "*" : "/"
+      else
+        operator
+      end
+    end
+  end
+end

data/lib/eng_unit.rb

@@ -0,0 +1,196 @@
+require 'yaml'
+require_relative 'eng_formula'
+require_relative 'eng_unit_calc'
+
+module Eng
+  module ExtensionClass
+    include Eng
+    refine Hash do
+      def to_names
+        case self
+        when Unit.variable
+          self.inject([]) do |a, k|
+            a << k[1].keys.inject([]) { |arr, key| arr << key.split(", ") }.flatten
+          end.flatten
+        when  Unit.si_alter
+          self.inject([]) { |a, v| a << v }.flatten
+        when Unit.metric_prefix
+          self.keys
+        when Unit.si_base
+          self.values
+        end
+      end
+
+      def to_find(unit_name)
+        case self
+        when Unit.si_base, Unit.si_derived
+          return {formula: "value", kind: self.key(unit_name)} if self.key(unit_name)
+        when Unit.si_alter
+          self.each do |kind, units|
+            return {formula: "value", kind: kind} if units.include?(unit_name)
+          end
+        when Unit.variable
+          self.each do |kind_unit|
+            kind_unit[1].each do |unit, value|
+              return {formula: value, kind: kind_unit[0]} if unit.split(", ").include?(unit_name)
+            end
+          end
+        end
+        nil
+      end
+
+      def to_reg
+        Regexp.new(self.to_names.sort{ |a,b| b.size <=> a.size }.map{|x| Regexp.escape(x)}.join("|"))
+      end
+    end
+
+    refine Object do
+      def send(name, *args)
+        return self unless name
+        super
+      end
+    end
+  end
+
+  module Unit
+    include Formula
+    attr_accessor :opt
+
+    def convert(value: , unit: )
+      values = nil
+      first_unit = false
+      convert_unit = split_by_ari(unit).map do |e_unit|
+        if e_unit.empty?
+        elsif e_unit =~ /(#{operator_reg(:ari)})/
+          values = e_unit
+          if e_unit == "/" && !first_unit
+            values = value.to_s + "/"
+            first_unit = true
+          end
+          { value: values, unit: e_unit }
+        else
+          values = first_unit ? 1 : value
+          first_unit = true
+          Unit.convert_to_si(value: values.to_f.rationalize, unit: e_unit)
+        end
+      end
+      results = convert_unit.compact.inject({ value: "", unit: [], error: [] }) do |result, convert|
+        result[:value] << convert[:value].to_s
+        result[:unit]  << split_by_ari(convert[:unit]) if convert[:unit]
+        result[:error] << convert[:error] if convert[:error]
+        result
+      end
+      results[:value] = eval(results[:value] << "")
+      results[:unit].flatten!.reject!(&:empty?)
+      results
+    end
+
+    class << self
+      include Formula
+      include UnitCalc
+      using ExtensionClass
+      def si_base
+        @si_base_unit ||= YAML.load_file(File.join(__dir__, 'unit_calc/si_base_unit.yml'))
+        return @si_base_unit.inject({}){ |h, (k,v)| h[k] = v.upcase; h } if @opt
+        @si_base_unit
+      end
+
+      def si_derived
+        @si_derived_unit ||= YAML.load_file(File.join(__dir__, 'unit_calc/si_derived_unit.yml'))
+        return @si_derived_unit.inject({}){ |h, (k,v)| h[k] = v.upcase; h } if @opt
+        @si_derived_unit
+      end
+
+      def variable
+        @variable_unit ||= YAML.load_file(File.join(__dir__, 'unit_calc/variable_unit.yml'))
+        return @variable_unit.inject({}){ |h, (k,v)| h[k] = v.inject({}){ |hh, (kk, vv)| hh[kk.upcase] = vv; hh }; h } if @opt
+        @variable_unit
+      end
+
+      def metric_prefix
+        @metric_prefix ||= YAML.load_file(File.join(__dir__, 'unit_calc/metric_prefix.yml'))
+        return @metric_prefix.inject({}){ |h, (k,v)| h[k.upcase] = v; h } if @opt
+        @metric_prefix
+      end
+
+      def si_alter
+        @si_alter_unit ||= YAML.load_file(File.join(__dir__, 'unit_calc/si_alter_unit.yml'))
+        return @si_alter_unit.inject({}){ |h, (k,v)| h[k] = v.inject([]){ |a, aa| a << aa.upcase; a }; h } if @opt
+        @si_alter_unit
+      end
+
+      def find_all(unit)
+        [:si_base, :si_alter, :si_derived, :variable].each do |method|
+          result = Unit.send(method).to_find(unit)
+          return result if result
+        end
+        nil
+      end
+
+      def convert_to_si(value: , unit: , opt: nil)
+        value = value.rationalize
+        metric = nil
+        num = 1
+        @opt = opt
+        original_unit = unit
+        unit = unit.send(opt)
+        if unit.match(to_si_reg) do |si_unit|
+            break if si_unit[0] != unit || si_unit[0].upcase == "KG"
+            metric = si_unit[:metric]
+            unit = si_unit[:si] + (si_unit[:num] || "")
+            num = si_unit[:num] || 1
+          end
+        end
+
+        result = find_all(unit)
+
+        if !result && !opt
+          convert_to_si(value: value, unit: unit, opt: :upcase)
+        elsif result
+          @opt = nil
+          metric = metric ? (metric_prefix[original_unit[0]].to_f ** num.to_f).rationalize : 1
+          {
+            value: eval(result[:formula].to_s + "*#{metric}").to_f,
+            unit: to_si(result[:kind]),
+            kind: result[:kind],
+            error: opt ? { unit_upcase: original_unit } : nil
+          }
+        else
+          {
+            value: value,
+            unit: original_unit,
+            kind: nil,
+            error: original_unit.empty? ? nil : { unit_not_found: original_unit }
+          }
+        end
+      end
+
+      def kind_by_si(unit)
+        s_unit = unit_arrange(split_by_ari(unit))
+        si_base.merge(si_derived).each do |e_unit|
+          return e_unit[0] if s_unit == unit_arrange(split_by_ari(e_unit[1]))
+        end
+        false
+      end
+
+      def to_si(kind_unit)
+        si_base[kind_unit] || si_derived[kind_unit]
+      end
+
+      def to_si_reg
+        /((?<metric>#{metric_prefix.to_reg})(?<si>#{si_base.to_reg}|g){1}(?<num>-*\d)*)|((?<metric>#{metric_prefix.to_reg})(?<si>#{si_alter.to_reg}))/
+      end
+
+      def unit_reg
+        /(#{si_derived.to_reg})|((?:#{metric_prefix.to_reg})?#{si_alter.to_reg})|(#{variable.to_reg})|((?:#{metric_prefix.to_reg})?(?:#{si_base.to_reg}|g){1}-*\d*)|(#{operator_reg(:ari)})/
+      end
+
+      def variable_names
+        variable.inject({}) do |a, k|
+          a[k[0]] = k[1].keys.join(", ").split(", ")
+          a
+        end
+      end
+    end
+  end
+end

data/lib/eng_unit_calc.rb

@@ -0,0 +1,128 @@
+require_relative "eng_formula"
+
+module Eng
+  module UnitCalc
+    include Formula
+    def calc_unit(units)
+      @error = {}
+      units = split_by_ari(units) unless units.class == Array
+      par = parenthesis_unit(units)
+      par.reverse_each do |index|
+        by_value = units[index[0]..index[1]]
+        unit = plus_minus_split(by_value)
+        unit.map! do |each_unit|
+          multi_div_unit each_unit
+        end
+        unit = plus_minus_unit(unit)
+        add = by_value.include?("(") ? 1 : 0
+        units[(index[0]+add)..(index[1]-add)] = unit + Array.new(units[(index[0]+add)..(index[1]-add)].size-unit.size)
+      end
+      units.compact!
+      units.reject!{ |x| x =~ /\(|\)/ }
+      { unit: unit_arrange(units), error: @error }
+    end
+
+    def plus_minus_unit(array)
+      array.each_with_index do |value, i|
+        unless i == 0 || (array[i-1].sort == array[i].sort)
+          @error[:plus_minus] ||= []
+          @error[:plus_minus] << "#{unit_arrange(array[i-1])} + #{unit_arrange(array[i])}"
+        end
+      end
+      array[0]
+    end
+
+    def plus_minus_split(units)
+      if units.any?{|x| x=="+" || x=="-"}
+        num = [0]
+        array = []
+        units.each_with_index { |x, i| num << i if x == "+" || x == "-" }
+        num << units.size - 1
+        num.each_with_index { |x, i| array << units[num[i-1]..x].reject!{|x| ["+", "-"].include?(x) } unless i==0 }
+        array
+      else
+        [units]
+      end
+    end
+
+    def multi_div_unit(units)
+      unit_hash = Hash.new(0)
+      ari = "+"
+      end_par = "+"
+      units.compact! unless units.nil?
+      units.each do |unit|
+        case unit
+        when "*", "・", "⋅"
+          ari = "+" unless end_par == "-"
+        when "/"
+          ari = "-"
+        when "("
+          end_par = "-" if ari == "-"
+        when ")"
+          end_par = "+"
+        else
+          num = unit.match(/(?<base>\D+){1}(?<num>-*\d*)/)
+          base = num[:base]
+          num = num[:num].empty? ? 1 : num[:num]
+          unit_hash[base] = eval(unit_hash[base].to_s + ari + num.to_s)
+          ari = "+" unless end_par == "-"
+        end
+      end
+      unit_hash.sort{|a,b| b[1] <=> a[1]}.map { |key, value| value == 0 ? nil : key + value.to_s }.compact
+    end
+
+    def parenthesis_unit(formula) #formula = ["(", "m","/","s", ")"]
+      array = []
+      count = []
+      formula.each_with_index do |value, index|
+        case value
+        when "("
+          array.push [index, nil]
+          count << array.size - 1
+        when ")"
+          array[count.pop][1] = index
+        end
+      end
+      array.unshift([0,formula.size-1])
+    end
+
+    def unit_arrange(units)
+      pos = []
+      neg = []
+      units.each do |unit|
+        num = unit.match(/(?<base>(?:[a-zA-Z]+))(?<num>-*\d*)/)
+        unless num.nil?
+          if num[:num].nil? || num[:num].to_i.positive?
+            number = num[:num].to_i == 1 ? nil : num[:num]
+            pos << num[:base] + number.to_s
+          else
+            number = num[:num].to_i == -1 ? nil : - (num[:num].to_i)
+            neg << num[:base] + number.to_s
+          end
+        end
+      end
+      div = neg.size > 1 ? ("/" + "(" + neg.join("*") + ")") : (neg.empty? ? nil : "/" + neg.join.to_s)
+      pos.join("*") + div.to_s
+    end
+
+    def split_si_unit(si_unit)
+      unit = si_unit.split(/([\*\/\(\)])/).reject(&:empty?).map do |s_unit|
+        s_unit =~ /([\*\/\(\)])/ ? s_unit : extraction_metric(s_unit)
+      end
+      value = String.new
+      unit_si = []
+      unit.each do |each_unit|
+        case each_unit
+        when Array
+          value << each_unit[0].to_s
+          unit_si << each_unit[1]
+        when String
+          value << each_unit.to_s
+          unit_si << each_unit
+        end
+      end
+      [eval(value.gsub(/^(#{operator_reg(:ari)})/,"")), unit_si]
+    end
+
+  end
+end

data/lib/engineer_calculator.rb

@@ -34,6 +34,7 @@ module Engineer
           value << x[0].to_s.sub("^","**") + (x[0].to_s =~ Regexp.union(reg(:ari),/(?:#{reg(:num)})*(?:#{reg(:double)})+/) ? "" : ".rationalize") unless x[0].empty?
           units << x[1]
         end
+        p units
         @opt = nil
         converted_formula = formula.inject(String.new){ |f, v| f << v[0].to_s + (v[0] != v[1].join ? v[1].join : " ") }
         return @result = { value: eval(value).to_f, unit: units.flatten.join, convert_formula: converted_formula } unless @error[:unit_not_found].nil?
@@ -274,21 +275,6 @@ module Engineer
       end
     end
 
-    def split_test(formula)
-      unit_array = []
-      formula_pre = formula.to_s.delete(" ")
-      formula_pre.scan(/(#{reg(:tri)})|(?:(#{reg(:num)}(?:#{reg(:double)})*)((?:\/?\(?\/?[a-z]+\d*(?:\*[a-z])*(?:\W*[a-z]\d*\)*)*)(?:-*\d[^[a-z]])*\)?))|(#{reg(:ari)})|((?:#{reg(:num)})*(?:#{reg(:double)})?)/i).each do |data|
-        unit_array << { value: (data[0] || data[1] || data[3] || data[4]), unit: (data[2] || data[3]) }
-      end
-      unit_array.each_with_index do |data, index|
-        if data[:unit] =~ /^[^\(].+\)$/
-          data[:unit].gsub!(/.$/,'')
-          unit_array.insert(index+1, { value: ")", unit: ")" })
-        end
-      end
-      unit_array
-    end
-
     def split_unit(formula)
       unit_array = []
       formula_pre = formula.to_s.delete(" ")

data/lib/engineer_calculator/version.rb

@@ -1,3 +1,3 @@
 module Engineer
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

data/lib/unit/si_alter_unit.yml

@@ -89,22 +89,10 @@ Radiant Intensity:
 Spectral Intensity:
   - W/(sr*m)
   - watt per steradian metre
-Speed, Velocity:
-  - m/s
-Acceleration:
-  - m/s2
-Jerk, Jolt:
-  - m/s3
-Snap, Jounce:
-  - m/s4
 Angular Velocity:
   - rad/s
 Angular Acceleration:
   - rad/s2
-Frequency Drift:
-  - /s2
-Volumetric Flow:
-  - m3/s
 Frequency:
   - Hz
   - hertz
@@ -155,7 +143,6 @@ Electrical Capacitance:
 Electrical Resistance, Impedance, Reactance:
   - Ω
   - ohm
-  - /S
   - V/A
 Electrical Conductance:
   - S
@@ -196,7 +183,6 @@ Illuminance:
 Radioactivity (Decays Per Unit Time):
   - Bq
   - becquerel
-  - /s
 Absorbed Dose (Of Ionizing Radiation):
   - Gy
   - gray
@@ -208,4 +194,3 @@ Equivalent Dose (Of Ionizing Radiation):
 Catalytic Activity:
   - kat
   - katal
-  - mol/s

data/lib/unit/test_unit.yml

@@ -0,0 +1,10 @@
+Tempreture:
+  K: input
+  °C, degree, Celsius: input-273.15r
+  °F, Fahrenheit: input*1.8r-459.67r
+  °R, Rankine scale: input*1.8r
+
+Length:
+  m: input
+  inch, in, ": input*39.370078740158
+  feet, ft, ': input*3.2808398950131

data/lib/unit_calc/metric_prefix.yml

@@ -0,0 +1,20 @@
+Y: 10e23
+Z: 10e20
+E: 10e17
+P: 10e14
+T: 10e11
+G: 10e8
+M: 10e5
+k: 10e2
+h: 10e1
+da: 1
+d: 10e-2
+c: 10e-3
+m: 10e-4
+μ: 10e-7
+n: 10e-10
+p: 10e-13
+f: 10e-16
+a: 10e-19
+z: 10e-22
+y: 10e-25

data/lib/unit_calc/si_alter_unit.yml

@@ -0,0 +1,211 @@
+Area:
+  - square metre
+Volume:
+  - cubic metre
+Momentum, Impulse:
+  - N*s
+  - Ns
+  - newton second
+Angular Momentum:
+  - newton metre second
+  - N*m*s
+  - Nms
+Torque, moment of force:
+  - newton metre
+  - N*m
+  - J/rad
+Yank:
+  - newton per second
+  - N/s
+Wavenumber, Optical Power, Curvature, Spatial Frequency:
+  - reciprocal metre
+Area Density:
+  - kilogram per square metre
+Density, Mass density:
+  - kilogram per cubic metre
+Specific Volume:
+  - cubic metre per kilogram
+Action:
+  - J*s
+  - joule second
+Specific Energy:
+  - J/kg
+  - joule per kilogram
+Energy Density:
+  - J/m3
+  - joule per cubic metre
+Surface Tension, Stiffness:
+  - N/m
+  - J/m2
+  - newton per metre
+Heat Flux Density, Irradiance:
+  - W/m2
+  - watt per square metre
+Kinematic Viscosity, Thermal Diffusivity, Diffusion Coefficient:
+  - square metre per second
+Dynamic Viscosity:
+  - Pa*s
+  - N*s/m2
+  - pascal second
+linear Mass Density:
+  - kilogram per metre
+Mass Flow Rate:
+  - kilogram per second
+Radiance:
+  - W/(sr*m2)
+  - watt per steradian square metre
+Spectral Radiance:
+  - W/(sr*m3)
+  - watt per steradian cubic metre
+Spectral Power:
+  - W/m
+  - watt per metre
+Absorbed Dose Rate:
+  - Gy/s
+  - gray per second
+Fuel Efficiency:
+  - m/m3
+  - metre per cubic metre
+Spectral Irradiance, Power Density:
+  - W/m3
+  - watt per cubic metre
+Energy Flux Density:
+  - J/(m2⋅s)
+  - joule per square metre second
+Compressibility:
+  - /Pa
+  - reciprocal pascal
+Radiant Exposure:
+  - J/m2
+  - joule per square metre
+Moment of Inertia:
+  - kilogram square metre
+Specific Angular Momentum:
+  - N*m*s/kg
+  - newton metre second per kilogram
+Radiant Intensity:
+  - W/sr
+  - watt per steradian
+Spectral Intensity:
+  - W/(sr*m)
+  - watt per steradian metre
+Speed, Velocity:
+  - m/s
+Acceleration:
+  - m/s2
+Jerk, Jolt:
+  - m/s3
+Snap, Jounce:
+  - m/s4
+Angular Velocity:
+  - rad/s
+Angular Acceleration:
+  - rad/s2
+Frequency Drift:
+  - /s2
+Volumetric Flow:
+  - m3/s
+Frequency:
+  - Hz
+  - hertz
+Angle:
+  - rad
+  - radian
+Solid Angle:
+  - sr
+  - steradian
+Force, Weight:
+  - N
+  - newton
+Pressure, Stress:
+  - Pa
+  - pascal
+Energy, Work, Heat:
+  - J
+  - joule
+  - N*m
+  - Nm
+  - C*V
+  - CV
+  - W*s
+  - Ws
+Power, Radiant Flux:
+  - W
+  - watt
+  - J/s
+  - V*A
+  - VA
+Electric Charge Or Quantity Of Electricity:
+  - C
+  - coulomb
+  - s*A
+  - sA
+  - V*A
+  - VA
+Voltage, Electrical Potential Difference, Electromotive Force:
+  - V
+  - volt
+  - W/A
+  - J/C
+Electrical Capacitance:
+  - F
+  - farad
+  - C/V
+  - s/Ω
+Electrical Resistance, Impedance, Reactance:
+  - Ω
+  - ohm
+  - /S
+  - V/A
+Electrical Conductance:
+  - S
+  - siemens
+  - /Ω
+  - A/V
+Magnetic Flux:
+  - Wb
+  - weber
+  - J/A
+  - T*m2
+  - Tm2
+Magnetic Field Strength, Magnetic Flux Density:
+  - T
+  - tesla
+  - V*s/m2
+  - Vs/m2
+  - Wb/m2
+  - N/(A*m)
+  - N/(Am)
+Electrical Inductance:
+  - H
+  - henry
+  - V*s/A
+  - Vs/A
+  - Ω*s
+  - Ωs
+  - Wb/A
+Luminous Flux:
+  - lm
+  - lumen
+  - cd*sr
+  - cdsr
+Illuminance:
+  - lx
+  - lux
+  - lm/m2
+Radioactivity (Decays Per Unit Time):
+  - Bq
+  - becquerel
+  - /s
+Absorbed Dose (Of Ionizing Radiation):
+  - Gy
+  - gray
+  - J/kg
+Equivalent Dose (Of Ionizing Radiation):
+  - Sv
+  - sievert
+  - J/kg
+Catalytic Activity:
+  - kat
+  - katal
+  - mol/s

data/lib/unit_calc/si_base_unit.yml

@@ -0,0 +1,7 @@
+Length: m
+Weight: kg
+Time: s
+Current: A
+Tempreture: K
+Amaount of Substance: mol
+Luminous intensity: cd

data/lib/unit_calc/si_derived_unit.yml

@@ -0,0 +1,62 @@
+Area: m2
+Volume:	m3
+Momentum, Impulse: m*kg/s
+Angular Momentum: m2*kg/s
+Torque, moment of force: m2*kg/s2
+Yank: m*kg/s3
+Wavenumber, Optical Power, Curvature, Spatial Frequency: /m
+Area Density: kg/m2
+Density, Mass density: kg/m3
+Specific Volume: m3/kg
+Action: m2*kg/s
+Specific Energy: m2/s2
+Energy Density: kg/(m*s2)
+Surface Tension, Stiffness: kg/s2
+Heat Flux Density, Irradiance: kg/s3
+Kinematic Viscosity, Thermal Diffusivity, Diffusion Coefficient: m2/s
+Dynamic Viscosity: kg/(m*s)
+linear Mass Density: kg/m
+Mass Flow Rate: kg/s
+Radiance: kg/s3
+Spectral Radiance: kg/(m*s3)
+Spectral Power: m*kg/s3
+Absorbed Dose Rate: m/s3
+Fuel Efficiency: /m2
+Spectral Irradiance, Power Density: kg/(m*s3)
+Energy Flux Density: kg/s3
+Compressibility: m*s2/kg
+Radiant Exposure: kg/s2
+Moment of Inertia: kg*m2
+Specific Angular Momentum: m2/s
+Radiant Intensity: m2*kg/s3
+Spectral Intensity: m*kg/s3
+Speed, Velocity: m/s
+Acceleration: m/s2
+Jerk, Jolt: m/s3
+Snap, Jounce: m/s4
+Angular Velocity: /s
+Angular Acceleration: /s2
+Frequency Drift: /s2
+Volumetric Flow: m3/s
+Frequency: /s
+Angle: m/m
+Solid Angle: m2/m2
+Force, Weight: kg*m/s2
+Pressure, Stress: kg/(m*s2)
+Energy, Work, Heat: kg*m2/s2
+Power, Radiant Flux: kg*m2/s3
+Electric Charge Or Quantity Of Electricity: s*A
+Voltage, Electrical Potential Difference, Electromotive Force: kg*m2/(s3*A)
+Electrical Capacitance: s4A2/(kg*m2)
+Electrical Resistance, Impedance, Reactance: kg*m2/(s3*A2)
+Electrical Conductance: s3*A2/(kg*m2)
+Magnetic Flux: kg*m2/(s2*A)
+Magnetic Field Strength, Magnetic Flux Density: kg/(s2*A)
+Electrical Inductance: kg*m2/(s2*A2)
+Temperature: K
+Luminous Flux: cd
+Illuminance: cd/m2
+Radioactivity (Decays Per Unit Time): /s
+Absorbed Dose (Of Ionizing Radiation): m2/s2
+Equivalent Dose (Of Ionizing Radiation): m2/s2
+Catalytic Activity: mol/s

data/lib/unit_calc/variable_unit.yml

@@ -0,0 +1,174 @@
+Length:
+  Å: value/10000000000r
+  thou, mil, milli-inch: value*0.0000254r
+  inch, in, ": value*0.0254r
+  feet, ft, ': value*0.304r
+  yard, yd: value*0.9144r
+  mile, mi: value*1609.344r
+  寸: value*1/33
+  尺: value*0.30303r
+  鯨尺: value*0.37879r
+  丈: value*3.0303r
+  間: value*1.818r
+  町, 丁: value*109.09091r
+  里: value*3927.273r
+  天文単位, astronomical-unit, AU: value*149597870700r
+  光年, light-year, ly: value*9460730472580800r
+  パーセク, parsec, pc: value*3.085677581e16.rationalize
+  海里, nautical-mile: value*1852r
+
+Weight:
+  g, gram: value*1000r
+  ton: value*0.001r
+  grain, gr: value/15432.358352941r
+  dram, dr: value/564.38339119329r
+  ounce, oz: value/35.27396194958r
+  pound, lb: value/2.2046226218488r
+  stone, st: value*6.35029318r
+  quarter: value*12.70058636r
+  short-ton, sh-tn, s.t.: value*907.18474r
+  分: value/2666.6666666667r
+  匁: value/266.66666666667r
+  百目: value/2.6666666666667r
+  斤: value/1.6666666666667r
+
+Time:
+  Planck time, tp: value*5.39121E-44.rationalize
+  au: value*4.1341373345192E+16.rationalize
+  min: value*60r
+  hour: value*3600r
+  day: value*86400r
+  week: value*604800r
+  month: value*2.628E+6
+  year: value*31535965.4396976r
+  century: value*3153600000r
+
+Tempreture:
+  K: value
+  °C, degree, Celsius: "value-273.15r"
+  °F, Fahrenheit: "value*1.8r-459.67r"
+  °R, Rankine scale: "value*1.8r"
+
+Area:
+  are, a: value*100r
+  ha: value*10000r
+  sq-in, in2: value*0.00064516r
+  sq-ft, ft2: value*0.09290304r
+  sq-yd, yd2: value*0.83612736r
+  rood, ro: value*1011.7141056r
+  acre, ac: value*4046.8564224r
+  sq-mi, mi2: value*2589988.110336r
+  坪: value*3.3057851239669r
+  畝: value*99.173553719008r
+  反: value*991.73553719008r
+  町: value*9917.3553719008r
+
+Volume:
+  ml: value/1000000r
+  cl: value/100000r
+  dl: value/10000r
+  l: value/1000r
+  小さじ: value*5.0E-6.rationalize
+  大さじ: value*1.5E-5.rationalize
+  cc: value*1.0E-6.rationalize
+  cu-in, in3: value*1.6387064E-5.rationalize
+  cu-ft, ft3: value*0.028316846592r
+  ac-ft: value*1233.4818375475r
+  U.S.fluid-gallon, gallon, gal, U.S.gal, USG: value*0.003785411784r
+  Imperial-gallon, imp.gal: value*0.00454609r
+  Winchester-bushel, bushel, bsh., bu: value*0.03523907016688r
+  us-fluid-once, fl-oz: value*2.84130625E-5.rationalize
+  uk-fluid-ounce: value*2.95735295625E-5.rationalize
+  us-gill, gi: value*0.00011829411825r
+  uk-gill, uk-gi: value*0.0001420653125r
+  us-pint, pt: value*0.000473176473r
+  uk-pint, uk-pt: value*0.00056826125r
+  us-quart, qt: value*0.000946352946r
+  uk-quart, uk-qt: value*0.0011365225r
+  us-barrel, bbl: value*0.119240471196r
+  uk-barrel, uk-bbl: value*0.16365924r
+  勺: value*1.8039068369647E-5.rationalize
+  合: value*0.00018039068369647r
+  升: value*0.0018039068369647r
+  斗: value*0.018039068369647r
+  石: value*0.18039068369647r
+
+Power:
+  dyn: value*100000r
+  N: value
+  kgf: value*0.10197162129779r
+  lbf: value*0.22480894309971r
+  pdl: value*7.2330138512099r
+
+Pressure, Stress:
+  N/mm2: value*1E-06.rationalize
+  bar: value*100000r
+  atm: value*101325r
+  at: value*98066.5r
+  kgf/cm2: value/1.0197162129779E-05.rationalize
+  mmH2O: value*9.80665r
+  cmH2O: value*98.0665r
+  mmH2O(3.98°C): value*9.80638r
+  cmH2O(3.98°C): value*98.0638r
+  mmHg: value*133.322387415r
+  inHg: value*3386.388640341r
+  torr: value*133.32236842105r
+  psi: value*6894.7572931684r
+
+Electric power:
+  mW: value/1000000r
+  W: value/1000r
+  kW: value
+  dBm: value/60r
+  kgfm/s: value/101.97162129779r
+  PS: value/1.3596216173039r
+  HP: value/1.341022089595r
+  ft.lbf/s: value/737.56214927727r
+  cal/s: value/238.8458966275r
+  kcal/s: value/0.2388458966275r
+  BTU/s: value/0.94781712031332r
+
+Energy, Work, Heat:
+  erg: value/10000000r
+  kWh: value/2.7777777777778E-07
+  calth: value/0.23900573613767r
+  kcalth: value/2.3900573613767E-04.rationalize
+  calIT: value/0.2388458966275r
+  kcalIT: value/2.388458966275E-04.rationalize
+  eV: value/6.2415094796077E+18.rationalize
+  BTU: value/9.4781712031332E-04.rationalize
+  ftlbf: value/0.73756214945755r
+  ftpdl: value/23.730360457056r
+  atm: value/0.0098692326671601r
+
+Speed, Velocity:
+  fps: value/3.2808398950131r
+  fpm: value/196.85039370079r
+  fph: value/11811.023622047r
+  mps: value/0.00062137119223733r
+  mpm: value/0.03728227153424r
+  mph: value/2.2369362920544r
+  kn: value/1.9438444924406r
+  Mach: value/0.0029411764705882r
+
+Acceleration:
+  km/h/s: value/3.6r
+  Gal: value/100r
+  fps2: value/3.2808398950131r
+  fpm/s: value/196.85039370079r
+  fph/s: value/11811.023622047r
+  mps2: value/6.2137119223733E-04.rationalize
+  mpm/s: value/0.03728227153424r
+  mph/s: value/2.2369362920544r
+  kn/s: value/1.9438444924406r
+  G: value/0.10197162129779r
+
+Angle:
+  °: value
+  ′: value/60r
+  ″: value/3,600r
+  grad: value/1.1111111111111r
+  rad: value/0.017453292519943r
+  mil: value/17.777777777778r
+  /%: value/1.7455064928218r
+  ‰: value/17.455064928218r

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: engineer_calculator
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Azeroyear
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-02 00:00:00.000000000 Z
+date: 2019-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,6 +73,10 @@ files:
 - config.ru
 - engineering_calculator.gemspec
 - favicon.ico
+- lib/eng_calc.rb
+- lib/eng_formula.rb
+- lib/eng_unit.rb
+- lib/eng_unit_calc.rb
 - lib/engineer_calculator.rb
 - lib/engineer_calculator/version.rb
 - lib/unit/convert_to_japanese.yml
@@ -80,7 +84,13 @@ files:
 - lib/unit/si_alter_unit.yml
 - lib/unit/si_base_unit.yml
 - lib/unit/si_derived_unit.yml
+- lib/unit/test_unit.yml
 - lib/unit/variable_unit.yml
+- lib/unit_calc/metric_prefix.yml
+- lib/unit_calc/si_alter_unit.yml
+- lib/unit_calc/si_base_unit.yml
+- lib/unit_calc/si_derived_unit.yml
+- lib/unit_calc/variable_unit.yml
 homepage: https://github.com/AZeroyear/engineering_calculator
 licenses:
 - MIT