sy 1.0.0

data/lib/sy/abstract_algebra.rb

@@ -0,0 +1,102 @@
+#encoding: utf-8
+
+# Adds abstract algebra concepts to Ruby.
+#
+module Algebra
+  # A Monoid requires:
+  #
+  # Closed and associative addition: #add method
+  # Additive identity element: #additive_identity
+  # 
+  module Monoid
+    def + summand; add summand end
+    def zero; additive_identity end
+  end
+
+  # A group is a monoid with additive inverse.
+  #
+  # additive inversion: #additive_inverse
+  # 
+  module Group
+    include Monoid
+    def -@; additive_inverse end
+    def - subtrahend; add subtrahend.additive_inverse end
+  end
+
+  # A group that fulfills the condition of commutativity
+  #
+  # ( a.add b == b.add a ).
+  # 
+  module AbelianGroup
+    include Group
+  end
+
+  # A ring is a commutative group with multiplication.
+  # 
+  # multiplication: #multiply (associative, distributive)
+  # multiplicative identity element: #multiplicative_identity
+  # 
+  module Ring
+    include AbelianGroup
+    def * multiplicand; multiply multiplicand end
+    def one; multiplicative_identity end
+  end
+
+  # A field is a ring that can do division.
+  # 
+  module Field
+    include Ring
+    def inverse; multiplicative_inverse end
+    def / divisor; multiply divisor.multiplicative_inverse end
+  end
+end
+
+# Patching Integer with Algebra::Ring compliance methods.
+# 
+class << Integer
+  def additive_identity; 0 end
+  alias zero additive_identity
+  def add( other ); self + other end
+  def additive_inverse; -self end
+  def multiply( other ); self * other end
+  def multiplicative_identity; 1 end
+end
+
+# Patching Float with Algebra::Field compliance methods.
+# 
+class << Float
+  def additive_identity; 0.0 end
+  alias zero additive_identity
+  def add( other ); self + other end
+  def additive_inverse; -self end
+  def multiply( other ); self * other end
+  def multiplicative_identity; 1.0 end
+  alias one multiplicative_identity
+  def multiplicative_inverse; 1.0 / self end
+end
+
+# Patching Rational with Algebra::Field compliance methods.
+# 
+class << Rational
+  def additive_identity; Rational 0, 1 end
+  alias zero additive_identity
+  def add( other ); self + other end
+  def additive_inverse; -self end
+  def multiply( other ); self * other end
+  def multiplicative_identity; Rational 1, 1 end
+  alias one multiplicative_identity
+  def multiplicative_inverse; Rational( 1, 1 ) / self end
+end
+
+# Patching Complex with #zero method.
+# 
+class << Complex
+  def additive_identity; Complex 0.0, 0.0 end
+  alias zero additive_identity
+  def add( other ); self + other end
+  def additive_inverse; -self end
+  def multiply( other ); self * other end
+  def multiplicative_identity; Complex 1, 0 end
+  alias one multiplicative_identity
+  def multiplicative_inverse; Complex( 1, 0 ) / self end
+end

data/lib/sy/composition.rb

@@ -0,0 +1,219 @@
+#encoding: utf-8
+
+# Composition of quantities.
+# 
+class SY::Composition < Hash
+  # Simplification rules for quantity combinations.
+  # 
+  SR = SIMPLIFICATION_RULES = []
+
+  # SY::Amount and SY::Amount.relative are disposable:
+  SR << -> ꜧ {
+    ꜧ.reject! { |qnt, _| qnt == SY::Amount || qnt == SY::Amount.relative }
+  }
+  # Relative quantities of the composition are absolutized:
+  SR << -> ꜧ {
+    ꜧ.select { |qnt, _| qnt.relative? }.each { |qnt, exp|
+      ꜧ.delete qnt
+      ꜧ.update qnt.absolute => exp
+    }
+  }
+  # Any quantities with exponent zero can be deleted:
+  SR << -> ꜧ {
+    ꜧ.reject! { |_, exp| exp == 0 }
+  }
+  # 
+  SR << -> ꜧ {
+    begin
+      q1, q2, q3 = SY::MoleAmount, SY::LitreVolume, SY::Molarity
+    rescue NameError
+      return ꜧ
+    end
+    # transform = -> e1, e2 {
+    #   return e1, e2 unless e1 != 0 && e2 != 0 && ( e1 <=> 0 ) != ( e2 <=> 0 )
+    #   n = e1 <=> 0
+    #   return e1 - n, e2 + n
+    # }
+    # e1 = ꜧ.delete q1
+    # e2 = ꜧ.delete q2
+    # ꜧ.merge! q1 => e1, q2 => e2
+    # else
+    #   ꜧ.update q1 => e1, q2 => e2
+    # end
+    e1 = ꜧ.delete q1
+    e2 = ꜧ.delete q2
+    if e1 && e2 && e1 > 0 && e2 < 0 then
+      e1 -= 1
+      e2 += 1
+      e3 = ꜧ.delete q3
+      ꜧ.update q3 => ( e3 ? e3 + 1 : 1 )
+    end
+    ꜧ.update q1 => e1 if e1 && e1 != 0
+    ꜧ.update q2 => e2 if e2 && e2 != 0
+    return ꜧ
+  }
+
+  class << self
+    def singular quantity
+      self[ SY.Quantity( quantity ) => 1 ]
+    end
+
+    def empty
+      self[]
+    end
+  end
+
+  # Cache for quantity construction.
+  # 
+  QUANTITY_TABLE = Hash.new { |ꜧ, args|
+    if args.keys.include? [:name] || args.keys.include?( :ɴ ) then
+      ɴ = args.delete( :name ) || args.delete( :ɴ ) # won't cache name
+      ꜧ[args].tap { |ɪ| ɪ.name = ɴ }                # recursion
+    elsif args.keys.include? :mapping then
+      ᴍ = args.delete( :mapping )                   # won't cache mapping
+      ꜧ[args].tap { |ɪ| ɪ.set_mapping ᴍ }           # recursion
+    elsif args.keys.include? :relative then
+      ʀ = args.delete( :relative ) ? true : false   # won't cache :relative
+      ꜧ[args].send ʀ ? :relative : :absolute        # recursion
+    else
+      cᴍ = SY::Composition[ args ].simplify
+      ꜧ[args] = if cᴍ != args then ꜧ[ cᴍ ]          # recursion while #simplify
+                else x = cᴍ.expand # we'll try to #expand now
+                  if x != cᴍ then ꜧ[ x ]            # recursion while #expand
+                  else
+                    if x.empty? then                # use std. ∅ quantity
+                      SY.Dimension( :∅ ).standard_quantity
+                    elsif x.singular? then
+                      x.first[0]                    # unwrap the quantity
+                    else # create new quantity
+                      SY::Quantity.new composition: x
+                    end
+                  end
+                end
+    end
+  }
+
+  # Singular compositions consist of only one quantity.
+  # 
+  def singular?
+    size == 1 && first[1] == 1
+  end
+
+  # Atomic compositions are singular compositions, whose quantity dimension
+  # is a base dimension.
+  # 
+  def atomic?
+    singular? && first[0].dimension.base?
+  end
+
+  # Returns a new instance with same hash.
+  # 
+  def +@
+    self.class[ self ]
+  end
+
+  # Negates hash exponents.
+  # 
+  def -@
+    self.class[ self.with_values do |v| -v end ]
+  end
+
+  # Merges two compositions.
+  # 
+  def + other
+    self.class[ self.merge( other ) { |_, v1, v2| v1 + v2 } ]
+  end
+
+  # Subtracts two compositions.
+  # 
+  def - other
+    self + -other
+  end
+
+  # Multiplication by a number.
+  # 
+  def * number
+    self.class[ self.with_values do |v| v * number end ]
+  end
+
+  # Division by a number.
+  # 
+  def / number
+    self.class[ self.with_values do |val|
+                      raise TErr, "Compositions with rational exponents " +
+                        "not implemented!" if val % number != 0
+                      val / number
+                    end ]
+  end
+
+  # Simplifies a quantity hash by applying simplification rules.
+  # 
+  def simplify
+    ꜧ = self.to_hash
+    puts "simplifying #{ꜧ}" if SY::DEBUG
+    SIMPLIFICATION_RULES.each { |rule| rule.( ꜧ ) }
+    self.class[ ꜧ ].tap { |_| puts "result is #{_}" if SY::DEBUG }
+  end
+
+  # Returns the quantity appropriate to this composition.
+  # 
+  def to_quantity args={}
+    # All the work is delegated to the quantity table:
+    QUANTITY_TABLE[ args.merge( self ) ]
+  end
+
+  # Directly (without attempts to simplify) creates a new quantity from self.
+  # If self is empty or singular, SY::Amount, resp. the singular quantity
+  # in question is returned.
+  # 
+  def new_quantity args={}
+    SY::Quantity.new args.merge( composition: self )
+  end
+
+  # Dimension of a quantity composition is the sum of its dimensions.
+  # 
+  def dimension
+    map { |qnt, exp| qnt.dimension * exp }.reduce SY::Dimension.zero, :+
+  end
+
+  # Infers the mapping of the composition's quantity. (Mapping
+  # defines mapping of a quantity to the standard quantity of its dimension.)
+  # 
+  def infer_mapping
+    puts "#infer_mapping; hash is #{self}" if SY::DEBUG
+    map do |qnt, exp|
+      qnt.standardish? ? SY::Mapping.identity :
+        qnt.mapping_to( qnt.standard ) ** exp
+    end.reduce( SY::Mapping.identity, :* )
+  end
+
+  # Simple composition is one that is either empty or singular.
+  # 
+  def simple?
+    empty? or singular?
+  end
+
+  # Whether it is possible to expand this 
+  def irreducible?
+    all? { |qnt, exp| qnt.irreducible? }
+  end
+
+  # Try to simplify the composition by decomposing its quantities.
+  # 
+  def expand
+    return self if irreducible?
+    puts "#expand: #{self} not irreducible" if SY::DEBUG
+    self.class[ reduce( self.class.empty ) { |cᴍ, pair|
+                  qnt, exp = pair
+                  puts "#expand: qnt: #{qnt}, exp: #{exp}" if SY::DEBUG
+                  puts "cᴍ is #{cᴍ}" if SY::DEBUG
+                  ( cᴍ + if qnt.irreducible? then
+                         self.class.singular( qnt ) * exp
+                       else
+                         qnt.composition * exp
+                       end.tap { |x| puts "Adding #{x}." if SY::DEBUG }
+                    ).tap { |x| puts "Result is #{x}." if SY::DEBUG }
+                } ]
+      .tap{ |rslt| puts "#expand: result is #{rslt}" if SY::DEBUG }
+  end
+end # class SY::Composition

data/lib/sy/dimension.rb

@@ -0,0 +1,182 @@
+#encoding: utf-8
+
+# This class represents physical dimension of a metrological quantity.
+# 
+class SY::Dimension
+  # Let's set up an instance variable (of the class) that will hold standard
+  # quantities of selected dimensions:
+  # 
+  @standard_quantities ||= Hash.new { |ꜧ, missing_key|
+    if missing_key.is_a? SY::Dimension then
+      # Create a new quantity of that dimension:
+      ꜧ[missing_key] = SY::Quantity.of missing_key
+    else
+      # Otherwise, let SY.Dimension constructor judge:
+      ꜧ[ SY.Dimension missing_key ]
+    end
+  }
+
+  class << self
+    alias __new__ new
+    attr_reader :standard_quantities
+    
+    # The #new constructor of SY::Dimension has been changed, so that the
+    # same instance is returned, if that dimension has already been created.
+    # 
+    def new dim={}
+      ꜧ = case dim
+          when Hash then dim
+          when self then return dim # it is a dimension instance
+          else # we'll treat dimension_specification as SPS
+            SY::BASE_DIMENSIONS.parse_sps( dim )
+          end
+      # Zeros by default:
+      ꜧ.default! Hash[ SY::BASE_DIMENSIONS.base_symbols.map { |ß| [ß, 0] } ]
+      # Now we can see whether the instance of this dimension already exists.
+      return instances.find { |inst| inst.to_hash == ꜧ } ||
+        __new__( ꜧ ).tap { |inst| instances << inst }
+    end
+
+    # Presents class-owned instances (array).
+    # 
+    def instances
+      return @instances ||= []
+    end
+
+    # Base dimension constructor. Base dimension symbol is expeced as argument.
+    # 
+    def base symbol
+      raise AErr, "Unknown base dimension: #{symbol}" unless
+        SY::BASE_DIMENSIONS.base_symbols.include? symbol
+      return new( symbol => 1 )
+    end
+    alias basic base
+    
+    # Constructor for zero dimension ("dimensionless").
+    # 
+    def zero; new end
+  end
+
+  attr_accessor *SY::BASE_DIMENSIONS.base_symbols
+
+  # Dimension can be initialized either by supplying a hash
+  # (such as Dimension.new L: 1, T: -2) or by supplying a SPS
+  # (superscripted product string), such as Dimension.new( "L.T⁻²" ).
+  # It is also possible to supply a Dimension instance, which will
+  # result in a new Dimension instance equal to the supplied one.
+  # 
+  def initialize hash
+    SY::BASE_DIMENSIONS.base_symbols.each { |ß|
+      instance_variable_set "@#{ß}", hash[ß]
+    }
+  end
+
+  # #[] method provides access to the dimension components, such as
+  # d = Dimension.new( L: 1, T: -2 ), d[:T] #=> -2
+  # 
+  def [] ß
+    return send ß if SY::BASE_DIMENSIONS.letters.include? ß
+    raise AErr, "Unknown basic dimension: #{ß}"
+  end
+
+  #Two dimensions are equal, if their exponents are equal.
+  # 
+  def == other
+    to_a == other.to_a
+  end
+
+  # Dimension arithmetic: addition. (+, -, *, /).
+  # 
+  def + other
+    ç.new Hash[ SY::BASE_DIMENSIONS.base_symbols.map do |l|
+                  [ l, self.send( l ) + other.send( l ) ]
+                end ]
+  end
+
+  # Dimension arithmetic: subtraction.
+  # 
+  def - other
+    ç.new Hash[ SY::BASE_DIMENSIONS.base_symbols.map do |l|
+                  [ l, self.send( l ) - other.send( l ) ]
+                end ]
+  end
+
+  # Dimension arithmetic: multiplication by a number.
+  # 
+  def * number
+    ç.new Hash[ SY::BASE_DIMENSIONS.base_symbols.map do |l|
+                  [ l, self.send( l ) * number ]
+                end ]
+  end
+
+  # Dimension arithmetic: division by a number.
+  # 
+  def / number
+    ç.new Hash[ SY::BASE_DIMENSIONS.base_symbols.map do |l|
+                  exp = send l
+                  raise TErr, "Dimensions with rational exponents " +
+                    "not implemented!" if exp % number != 0
+                  [ l, exp / number ]
+                end ]
+  end
+
+  # Conversion to an array (of exponents of in the order of the
+  # basic dimension letters).
+  # 
+  def to_a
+    SY::BASE_DIMENSIONS.base_symbols.map { |l| self.send l }
+  end
+
+  # Conversion to a hash (eg. { L: 1, M: 0, T: -2, Q: 0, Θ: 0 } ).⁻³
+  # 
+  def to_hash
+    SY::BASE_DIMENSIONS.base_symbols.each_with_object Hash.new do |l, ꜧ|
+      ꜧ[ l ] = self.send( l )
+    end
+  end
+
+  # True if the dimension is zero ("dimensionless"), otherwise false.
+  # 
+  def zero?
+    to_a.all? { |e| e.zero? }
+  end
+
+  # True if the dimension is basic, otherwise false.
+  # 
+  def base?
+    to_a.count( 1 ) == 1 &&
+      to_a.count( 0 ) == SY::BASE_DIMENSIONS.base_symbols.size - 1
+  end
+  alias basic? base?
+
+  # Converts the dimension into its SPS.
+  # 
+  def to_s
+    sps = SY::SPS.( SY::BASE_DIMENSIONS.base_symbols, to_a )
+    return sps == "" ? "∅" : sps
+  end
+
+  # Produces the inspect string of the dimension.
+  # 
+  def inspect
+    "#<Dimension: #{self} >"
+  end
+
+  # Returns dimension's standard quantity.
+  # 
+  def standard_quantity
+    self.class.standard_quantities[ self ]
+  end
+
+  # Returns default quantity composition for this dimension.
+  # 
+  def to_composition
+    SY::Composition[ SY::BASE_DIMENSIONS.base_symbols
+                       .map { |l| self.class.base l }
+                       .map { |dim| self.class.standard_quantities[ dim ] }
+                       .map { |qnt| qnt.absolute }
+                       .zip( to_a ).delete_if { |qnt, exp| exp.zero? } ]
+  end
+
+  delegate :standard_unit, to: :standard_quantity
+end # class SY::Dimension