sy 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd4b854cf2fceae1fb55d2e657f219807f88f6c6
-  data.tar.gz: 730fec5dad579f42e482d49cbaad66b56e901685
+  metadata.gz: 666dbe08efdd97d407e931045726b9668f5bf3c2
+  data.tar.gz: aa13e418672f7223bcdb63683eb42c511974b2f2
 SHA512:
-  metadata.gz: 2b2c9f2994e1d30db45eeeed40f952aad46e619a3935db909b2446f2b08f169525216cca37f49747abaf3dbc30213f38da505dd3e0ef0d4e84e678bf00d67807
-  data.tar.gz: ca82955c039d47f775292f3b1ee9c92ef6cba91ea0b0b99af4ae4f2666f90b0f9366b267b8e98299d195d94902d82dcb50f68fb632a6e32a3fb9fe4d0f314030
+  metadata.gz: deb58fde2b519570d6fc891a9e259aeafca50d541e6807c26075e4e1cd7415355378070baa05f231d449a36252d8cbd286120fdd37245fde87b79501a2e19dd2
+  data.tar.gz: 695f6feedb083dd82b35ebc7720a6aa89586dba97bee1ce4ff0a28a93fcf012e1957f0e7a8cabd618e328b89226f272eb5673dec1770c0ffcc211c1f847ad420

data/lib/sy/absolute_magnitude.rb

@@ -1,19 +1,30 @@
 # -*- coding: utf-8 -*-
-# Qualities specific to absolute magnitudes.
+# Qualities specific to absolute magnitudes (mixin).
+#
+# Absolute magnitude may not be negative  – physical amounts cannot have
+# negative number of unit objects. (<em>Difference</me> between magnitudes
+# (relative magnitude) can be positive as well as negative.
+#
+# While ordinary #+ and #- methods of absolute magnitudes return relative
+# magnitudes, absolute magnitudes have additional methods #add and #subtract,
+# that return absolute magnitudes (it is the responsibility of the caller to
+# avoid negative results). Furthermore, absolute magnitudes have one more
+# special method #take, which perfoms #subtract whilst protecting against
+# subtraction of more than, there is to take.
 # 
 module SY::AbsoluteMagnitude
   # Absolute magnitude constructor takes :quantity (alias :of) named argument,
   # and :amount named argument, where amount must be nonnegative.
   # 
-  def initialize( of: ( fail ArgumentError, ":of argument missing!" ),
-                  amount: nil )
+  def initialize( of: nil, amount: nil )
+    fail ArgumentError, "Quantity (:of) argument missing!" if of.nil?
     @quantity = of
     @amount = case amount
               when Numeric then amount
               when nil then 1
               else
                 begin
-                  amount.amount
+                  amount.( @quantity ).amount
                 rescue NameError, NoMethodError
                   amount
                 end

data/lib/sy/expressible_in_units.rb

@@ -2,8 +2,114 @@
 # This mixin provides ability to respond to SY unit symbol methods.
 # 
 module SY::ExpressibleInUnits
+  COLLISION_WARNING = "Unit %s collision, method already defined on %s!"
+  REDEFINE_WARNING = "Method %s being defined on %s shadows SY unit method!"
   RecursionError = Class.new StandardError
 
+  # This is a mixin for the target class of this mixin, that causes it to warn
+  # upon detecting newly defined methods shadowing the SY unit methods.
+  # 
+  module DetectRedefine
+    def method_added ß
+      # warn "#{self}: method added: :#{ß}"
+      uu = ::SY::ExpressibleInUnits.known_units
+      nn = uu.map &:name
+      aa = uu.map &:abbreviation
+      ꜧ = Hash[ nn.zip( uu ) ].merge Hash[ aa.zip( uu ) ]
+      w = ::SY::ExpressibleInUnits::REDEFINE_WARNING % [ ß, self ]
+      if nn.include? ß then
+        if instance_methods.include? ß then
+          im = instance_method ß
+          warn w unless ::SY::ExpressibleInUnits.method_family.include? im if
+            ꜧ[ß].warns? unless instance_variable_get( :@no_collision ) == ß
+          instance_variable_set( :@no_collision, nil ) # FIXME: This is too clumsy
+        else
+          warn w if ꜧ[ß].warns?
+        end
+      end
+      if aa.include? ß then
+        if instance_methods.include? ß then
+          im = instance_method ß
+          warn w unless ::SY::ExpressibleInUnits.method_family.include? im if
+            ꜧ[ß].warns? unless instance_variable_get( :@no_collision ) == ß
+          instance_variable_set( :@no_collision, nil ) # FIXME: This is too clumsy
+        else
+          warn w if ꜧ[ß].warns?
+        end
+      end
+    end
+  end
+
+  class << self
+    # #included hook of this module is set to perfom a casual check for blatant
+    # name collisions between SY::Unit-implied methods, and existing methods of
+    # the include receiver.
+    # 
+    def included receiver
+      included_in << receiver # keep track of where the mixin has been included
+      # Warn if the receiver has potentially colliding methods.
+      inst_methods = receiver.instance_methods
+      w = COLLISION_WARNING % ["%s", receiver]
+      known_units.each do |unit|
+        next unless unit.warns?
+        name, short = unit.name, unit.abbreviation
+        warn w % "name method ##{name}" if inst_methods.include? name
+        warn w % "abbreviation method ##{short}" if inst_methods.include? short
+      end
+      # Warn if shadowing methods are defined on the receiver later.
+      if receiver.is_a? Class
+        receiver.extend ::SY::ExpressibleInUnits::DetectRedefine
+      end
+    end
+
+    # Modules in which this mixin has been included.
+    # 
+    def included_in
+      @included_in ||= []
+    end
+
+    # Currently defined unit instances, if any.
+    # 
+    def known_units
+      unit_namespace = begin
+                         SY::Unit
+                       rescue NameError
+                         return [] # no SY::Unit yet
+                       end
+      begin
+        unit_namespace.instances
+      rescue NoMethodError 
+        [] # no #instances method defined yet
+      end
+    end
+
+    # All methods defined by this mixin.
+    # 
+    def method_family
+      @method_family ||= []
+    end
+
+    # Find unit based on name / abbreviation.
+    # 
+    def find_unit ς
+      known_units.find { |u| u.name.to_s == ς || u.short.to_s == ς }
+    end
+
+    # Return prefix method or empty string, if prefix method not necessary.
+    # 
+    def prefix_method_string prefix
+      puts "About to call PREFIX TABLE.to_full with #{prefix}" if SY::DEBUG
+      full_prefix = SY::PREFIX_TABLE.to_full( prefix )
+      full_prefix == '' ? '' : ".#{full_prefix}"
+    end
+
+    # Return exponentiation string (suffix) or empty ς if not necessary.
+    # 
+    def exponentiation_string exp
+      exp == 1 ? '' : " ** #{exp}"
+    end
+  end
+
   def method_missing ß, *args, &block
     return self if ß.to_s =~ /begin|end/ # 3rd party bug workaround
     super if ß.to_s =~ /to_.+/ # dissmiss :to_..., esp. :to_ary
@@ -12,7 +118,12 @@ module SY::ExpressibleInUnits
         puts "Method missing: '#{ß}'" if SY::DEBUG
         prefixes, units, exps = parse_unit_symbol ß
         # Define the unit method on self.class:
-        ç.module_eval write_unit_method( ß, prefixes, units, exps )
+        # I'D HAVE TO PERFORM THE COLLISION CHECK HERE
+        # IF NO COLLISION, INFORM THE SUBSEQUENT METHOD DEFINED CALL ON
+        # SELF.CLASS
+        self.class.instance_variable_set "@no_collision", ß # FIXME: This is too clumsy
+        self.class.module_eval write_unit_method( ß, prefixes, units, exps )
+        SY::ExpressibleInUnits.method_family << self.class.instance_method( ß )
       end
     rescue NameError => err
       puts "NameError raised: #{err}" if SY::DEBUG
@@ -27,8 +138,10 @@ module SY::ExpressibleInUnits
   def respond_to_missing? ß, *args, &block
     # dismiss :to_... methods and /begin|end/ (3rd party bug workaround)
     return false if ß.to_s =~ /to_.+|begin|end/
-    begin
-      anti_recursion_exec token: ß, var: :@SY_Units_rmiss do parse_unit ß end
+    !! begin
+      anti_recursion_exec token: ß, var: :@SY_Units_rmiss do
+        parse_unit_symbol ß
+      end
     rescue NameError, SY::ExpressibleInUnits::RecursionError
       false
     else
@@ -50,26 +163,13 @@ module SY::ExpressibleInUnits
   # Arrays must be of equal length. (Note: 'ß' is 'symbol', 'ς' is 'string')
   # 
   def write_unit_method ß, prefixes, units, exponents
-    known_units = SY::Unit.instances
-    # A procedure to find unit based on name or abbreviation:
-    find_unit = lambda do |ς|
-      known_units.find { |u| u.name.to_s == ς || u.short.to_s == ς }
-    end
-    # Return prefix method or empty ς if not necessary.
-    prefix_method_ς = lambda do |prefix|
-      puts "About to call PREFIX TABLE.to_full with #{prefix}" if SY::DEBUG
-      full_prefix = SY::PREFIX_TABLE.to_full( prefix )
-      full_prefix == '' ? '' : ".#{full_prefix}"
-    end
-    # Return exponentiation string (suffix) or empty ς if not necessary.
-    exponentiation_ς = lambda do |exp| exp == 1 ? '' : " ** #{exp}" end
     # Prepare prefix / unit / exponent triples for making factor strings:
     triples = [ prefixes, units, exponents ].transpose
     # A procedure for triple processing before use:
     process_triple = lambda do |pfx, unit_ς, exp|
-      [ find_unit.( unit_ς ).name.to_s.upcase, 
-        prefix_method_ς.( pfx ),
-        exponentiation_ς.( exp ) ]
+      [ ::SY::ExpressibleInUnits.find_unit( unit_ς ).name.to_s.upcase, 
+        ::SY::ExpressibleInUnits.prefix_method_string( pfx ),
+        ::SY::ExpressibleInUnits.exponentiation_string( exp ) ]
     end
     # Method skeleton:
     if triples.size == 1 && triples.first[-1] == 1 then

data/lib/sy/fixed_assets_of_the_module.rb

@@ -2,9 +2,9 @@
 # Here, fixed assets of the main module are set up.
 # 
 module SY
-  QuantityError = Class.new StandardError # mixing incompatible quantities
-  DimensionError = Class.new StandardError # mixing incompatible dimensions
-  MagnitudeError = Class.new StandardError # creating impossible magnitude
+  QuantityError = Class.new TypeError # mixing incompatible quantities
+  DimensionError = Class.new TypeError # mixing incompatible dimensions
+  MagnitudeError = Class.new TypeError # creating impossible magnitude
 
   BASE_DIMENSIONS = {                # Basic physical dimensions.
     L: :LENGTH,
@@ -273,5 +273,12 @@ module SY
     SY::Magnitude.of qnt, args
   end
 
-  module_function :Dimension, :Quantity, :Unit, :Magnitude
+  # Convenitence constructor of amounts (SY::Amount if the standard
+  # dimensionless quantity of SY).
+  # 
+  def Amount number
+    SY::Amount.relative.magnitude( number )
+  end
+
+  module_function :Dimension, :Quantity, :Unit, :Magnitude, :Amount
 end

data/lib/sy/magnitude.rb

@@ -1,17 +1,6 @@
 # -*- coding: utf-8 -*-
-# This class here represents absolute magnitude – physical number of unit
-# objects, that make up the amount of some metrological quantity. Amount of
-# an absolute magnitudes may not be negative – physical amounts cannot have
-# negative number of unit objects. But as for the <em>difference</me> between
-# magnitudes, this can be positive as well as negative – relative magnitudes
-# are used for this purpose.
-#
-# While ordinary #+ and #- methods of absolute magnitudes return relative
-# magnitudes, absolute magnitudes have additional methods #add and #subtract,
-# that return absolute magnitudes (it is the responsibility of the caller to
-# avoid negative results). Furthermore, absolute magnitudes have one more
-# special method #take, which perfoms #subtract whilst protecting against
-# subtraction of more than, there is to take.
+# This module stores assets pertaining to a magnitude – be it absolute magnitude
+# (physical number of unit objects), or relative magnitude (magnitude differnce).
 # 
 module SY::Magnitude
   class << self
@@ -169,6 +158,18 @@ module SY::Magnitude
     end
   end
 
+  # Same magnitudes <em>and</em> same (#eql) quantities.
+  # 
+  def eql other
+    raise NotImplementedError
+  end
+
+  # Percent operator (remainder after division)
+  # 
+  def %
+    raise NotImplementedError
+  end
+
   # Type coercion for magnitudes.
   # 
   def coerce m2
@@ -192,8 +193,7 @@ module SY::Magnitude
           "method collision with another library?"
       end
     when SY::Magnitude then
-      return amount / m2.amount if quantity == m2.quantity
-      amount / m2.( quantity ).amount # reframe before division
+      quantity.measure( of: m2.quantity ).w.( amount ) / m2.amount
     else
       raise TypeError, "Unexpected type for Magnitude#in method! (#{m2.class})"
     end

data/lib/sy/quantity.rb

@@ -12,7 +12,7 @@ class SY::Quantity
   RELATIVE_QUANTITY_NAME_SUFFIX = "±"
 
   attr_reader :MagnitudeModule, :Magnitude, :Unit
-  attr_reader :dimension, :composition
+  attr_reader :dimension, :composition, :units
 
   class << self
     # Dimension-based quantity constructor. Examples:
@@ -58,6 +58,7 @@ class SY::Quantity
   # 
   def initialize( relative: nil, composition: nil, of: nil, measure: nil, amount: nil, **nn )
     puts "Quantity init relative: #{relative}, composition: #{composition}, measure: #{measure}, #{nn}" if SY::DEBUG
+    @units = [] # array of units as favored by this quantity
     @relative = relative
     if composition.nil? then
       puts "Composition not given, dimension expected." if SY::DEBUG
@@ -233,12 +234,6 @@ class SY::Quantity
     Unit().standard
   end
 
-  # Presents an array of units ordered as favored by this quantity.
-  # 
-  def units
-    @units ||= []
-  end
-
   # Constructs a new absolute magnitude of this quantity.
   # 
   def magnitude amount
@@ -248,7 +243,8 @@ class SY::Quantity
   # Constructs a new unit of this quantity.
   # 
   def unit **nn
-    Unit().new( nn.update( of: self ) ).tap { |u| ( units << u ).uniq! }
+    Unit().new( nn.update( of: self ) )
+      .tap { |u| ( units << u ).uniq! } # add it to the @units array
   end
 
   # Constructor of a new standard unit (replacing current @standard_unit).
@@ -380,7 +376,7 @@ class SY::Quantity
   def Magnitude
     @Magnitude or
       ( mmod = MagnitudeModule()
-        mixin = relative? ? ::SY::SignedMagnitude : ::SY::AbsoluteMagnitude
+        mixin = relative? ? SY::SignedMagnitude : SY::AbsoluteMagnitude
         qnt_ɴ_λ = -> { name ? "#{name}@%s" : "#<Quantity:#{object_id}@%s>" }
 
         @Magnitude = Class.new do

data/lib/sy/signed_magnitude.rb

@@ -1,22 +1,21 @@
-#encoding: utf-8
-
-# Qualities specific to relative magnitudes.
+# -*- coding: utf-8 -*-
+# Qualities specific to relative magnitudes (mixin).
 # 
 module SY::SignedMagnitude
   # Relative magnitude constructor takes :quantity (alias :of) argument and
   # :amount argument. Amount is allowed to be negative.
   # 
-  def initialize **named_args
-    @quantity = named_args[:quantity] || named_args[:of]
-    amnt = named_args[:amount]
-    @amount = case amnt
-              when Numeric then amnt
+  def initialize( of: nil, amount: nil )
+    fail ArgumentError, "Quantity (:of) argument missing!" if of.nil?
+    @quantity = of
+    @amount = case amount
+              when Numeric then amount
               when nil then 1
               else
                 begin
-                  amnt.amount
+                  amount.( @quantity ).amount
                 rescue NameError, NoMethodError
-                  amnt
+                  amount
                 end
               end
   end

data/lib/sy/unit.rb

@@ -4,6 +4,8 @@
 # of a metrological quantity.
 # 
 module SY::Unit
+  PROTECTED_NAMES = [ "kilogram" ]
+
   def self.pre_included target
     class << target
       # Overriding this method from NameMagic mixin ensures, that all Unit
@@ -12,29 +14,29 @@ module SY::Unit
       def namespace
         SY::Unit
       end
+    end
+  end # def self.pre_included
 
-      # Tweaking instance accessor from NameMagic to make it accept unit
-      # abbreviations and unit names regardless of capitalization
-      # 
-      def instance arg
-        begin
-          super # let's first try the original method
-        rescue NameError               # if we fail...
-          begin # second in order, let's try whether it's an abbreviation
-            super instances.find { |inst|
-              inst.abbreviation.to_s == arg.to_s if inst.abbreviation
-            }
-          rescue NameError, TypeError
-            begin # finally, let's try upcase if we have all-downcase arg
-              super arg.to_s.upcase
-            rescue NameError # if not, tough luck
-              raise NameError, "Unknown unit symbol: #{which}"
-            end
-          end
+  # Tweaking instance accessor from NameMagic to make it accept unit
+  # abbreviations and unit names regardless of capitalization
+  # 
+  def self.instance arg
+    begin
+      super # let's first try the original method
+    rescue NameError               # if we fail...
+      begin # second in order, let's try whether it's an abbreviation
+        super instances.find { |inst|
+          inst.abbreviation.to_s == arg.to_s if inst.abbreviation
+        }
+      rescue NameError, TypeError
+        begin # finally, let's try upcase if we have all-downcase arg
+          super arg.to_s.upcase
+        rescue NameError # if not, tough luck
+          raise NameError, "Unknown unit symbol: #{which}"
         end
       end
-    end # class << target
-  end # def self.pre_included
+    end
+  end # def self.instance
 
   def self.included target
     target.class_exec do
@@ -42,13 +44,30 @@ module SY::Unit
       name_set_closure do |name, new_instance, old_name|
         ɴ = name.to_s
         up, down = ɴ.upcase, ɴ.downcase
+        # Check case (only all-upper or all-lower is acceptable).
         unless ɴ == up || ɴ = down
           raise NameError, "Unit must be either all-upper or all-lower case!"
         end
+        # Reject the names starting with a full prefix.
         conflicter = SY::PREFIX_TABLE.full_prefixes
           .find { |prefix| down.starts_with? prefix unless prefix.empty? }
         raise NameError, "Name #{ɴ} starts with #{conflicter}- prefix" unless
-          down == 'kilogram' if conflicter
+          SY::Unit::PROTECTED_NAMES.include? down if conflicter
+        # Warn about the conflicts in modules where the SY::ExpressibleInUnits
+        # mixin is included.
+        if new_instance.warns? then
+          w = ::SY::ExpressibleInUnits::COLLISION_WARNING
+          ::SY::ExpressibleInUnits.included_in.each do |ɱ|
+            im = ɱ.instance_methods
+            # puts ɱ, "class: #{ɱ.class}"
+            # puts im.size
+            # puts down
+            # puts im.include? down
+            warn w  % [down, ɱ] if im.include? down
+            abbrev = new_instance.abbreviation
+            warn w % [abbrev, ɱ] if im.include? abbrev
+          end
+        end
         up.to_sym
       end
 
@@ -80,17 +99,8 @@ module SY::Unit
   class << self
     # Constructor of units of a given quantity.
     # 
-    def of *args
-      ꜧ = args.extract_options!
-      qnt = case args.size
-            when 0 then
-              ꜧ.must_have( :quantity, syn!: :of )
-              ꜧ.delete :quantity
-            when 1 then args.shift
-            else
-              raise AErr, "Too many ordered arguments!"
-            end
-      return qnt.unit *( ꜧ.empty? ? args : args << ꜧ )
+    def of quantity, **nn
+      quantity.unit **nn
     end
     
     # Standard unit constructor. In absence of other named arguments, standard
@@ -132,7 +142,13 @@ module SY::Unit
   # Unlike ordinary magnitudes, units can have names and abbreviations.
   # 
   attr_reader :abbreviation
-  alias :short :abbreviation
+  alias short abbreviation
+
+  # Whether the unit warns when the module in which unit method mixin is
+  # included contains blatant name collisions with this unit name/abbreviation.
+  # 
+  attr_accessor :warns
+  alias warns? warns
   
   # Unit abbreviation setter.
   # 
@@ -153,16 +169,20 @@ module SY::Unit
     ɴ = super
     return ɴ ? ɴ.to_s.downcase.to_sym : nil
   end
+  alias ɴ name
 
   # Constructor of units provides support for one additional named argument:
   # :abbreviation, alias :short. (This is in addition to :name, alias :ɴ named
   # argument provided by NameMagic.) As a general rule, only named units unit
   # should be given abbreviations. In choosing unit names and abbreviations,
   # ambiguity with regard to standard prefixes and abbreviations thereof should
-  # also be avoided.
+  # also be avoided. Another argument, :warns, Boolean, <em>true</em> by
+  # default, determines whether the method warns about name collisions with
+  # other methods defined where the SY::ExpressibleInUnits mixin is included.
   # 
-  def initialize( short: nil, **nn )
+  def initialize( short: nil, warns: true, **nn )
     @abbreviation = short.to_sym if short
+    @warns = warns # does this unit care about blatant name collisions?
       
     # FIXME: Here, we would have to watch out for :amount being set
     # if it is a number, amount is in standard units
@@ -170,7 +190,7 @@ module SY::Unit
     # it estableshes a relationship between this and that quantity. It means that
     # the unit amount automatically becomes ... one ... and such relationship can
     # only be established for standard quantity
-    super( **nn )
+    super nn
   end
 
   # Addition: Unit is converted to a magnitude before the operation.
@@ -213,7 +233,7 @@ module SY::Unit
   # Reframing: Unit is converted to a magnitude before reframing.
   # 
   def reframe other_quantity
-    to_magnitude.reframe( other_quantity )
+    to_magnnitude.reframe( other_quantity )
   end
 
   # Unit as string.

data/lib/sy/version.rb

@@ -1,5 +1,5 @@
 module SY
-  VERSION = "2.0.4"
+  VERSION = "2.0.5"
   DEBUG = false # debug mode switch - sometimes there are lines like
   # puts "something" if SY::DEBUG
 end

data/lib/sy.rb

@@ -62,22 +62,17 @@ module SY
   # Let SY::Amount be a standard dimensionless quantity:
   Amount = Quantity.standard of: Dimension.zero
 
-  # Convenience constructor of amounts:
-  def self.Amount number
-    SY::Amount.relative.magnitude number
-  end
-
-  # AVOGADRO_CONSTANT (Nᴀ) is a certain well-known amount of things:
-  Nᴀ = AVOGADRO_CONSTANT = SY.Amount 6.02214e23
-
   # Let SY::UNIT be a standard unit of SY::Amount. Note that the upcase name
   # of the constant "UNIT" implies, via YSupport's NameMagic mixin, that the
   # name of the object becomes :unit and that it is possible to use syntax
   # such as 42.unit to create magnitudes of SY::Amount.
   UNIT = Unit.standard of: Amount
 
+  # AVOGADRO_CONSTANT (Nᴀ) is a certain well-known amount of things:
+  Nᴀ = AVOGADRO_CONSTANT = 6.02214e23
+
   # Let SY::MoleAmount be another dimensionless quantity:
-  MoleAmount = Quantity.dimensionless
+  MoleAmount = Quantity.dimensionless # TODO: coerces: Amount
 
   # And let SY::MOLE be its standard unit, related to SY::Amount via Nᴀ:
   MOLE = Unit.standard of: MoleAmount, short: "mol", amount: Nᴀ.unit
@@ -138,13 +133,24 @@ module SY
   # Celsius temperature is a little bit peculiar in that it has offset of
   # 273.15.K with respect to Kelvin temperature, and I am not sure whether
   # at this moment SY is handling this right. But nevertheless:
-  CelsiusTemperature = Quantity.of :Θ
+  CelsiusTemperature = Quantity.of :Θ # coerces_to: Temperature
+
+  CELSIUS_MEASURE = SY::Measure.simple_offset( TRIPLE_POINT_OF_WATER.in( :K ) )
 
   # Degree celsius is SY::CELSIUS
-  CELSIUS = Unit.standard of: CelsiusTemperature, short: '°C', measure: SY::Measure.simple_offset( TRIPLE_POINT_OF_WATER.in( :K ) )
+  CELSIUS = Unit.standard( of: CelsiusTemperature,
+                           short: '°C', measure: CELSIUS_MEASURE )
 
   class << CelsiusTemperature
     # FIXME: Patch CelsiusTemperature to make it work with SY::Temperature
+    # 1.°C + 1.K #=> 2.°C
+    # 1.°C - 1.°C #=> 0.K (unambiguous)
+    # 1.°C + 1.°C #=> QuantityError (ambiguous)
+    # 1.K +- 1.°C #=> QuantityError (ambiguous)
+    # 1.°C +- 1.K #=> 2.°C
+    # 1.mm.°C⁻¹ #=> 1.mm.K⁻¹ etc.
+    # 1.mm.°C #=> 1.mm.K etc.
+    # 1.mm */ 1.°C #=> QuantityError (ambiguous)
   end
 
   # alias :°C :celsius                 # with U+00B0 DEGREE SIGN
@@ -182,7 +188,7 @@ module SY
   Volume = Length ** 3
 
   # SY::LitreVolume is another quantity of the same dimension as SY::Volume:
-  LitreVolume = Quantity.of Volume.dimension
+  LitreVolume = Quantity.of Volume.dimension # TODO: coerces_to: Volume
 
   # SY::LITRE is the standard unit of SY::LitreVolume:
   LITRE = Unit.standard of: LitreVolume, short: "l", amount: 1.dm³

data/test/sy_test.rb

@@ -1,5 +1,5 @@
-#encoding: utf-8
 #! /usr/bin/ruby
+# -*- coding: utf-8 -*-
 
 # **************************************************************************
 # THIS IS SPEC-STYLE TEST FILE FOR SY PHYSICAL UNITS LIBRARY
@@ -169,12 +169,15 @@ describe SY::Quantity, SY::Magnitude do
       1.inch.( @inch_length ).must_equal 1.inch
       1.inch.( SY::Length ).must_equal 2.54.cm
       @inch_length.magnitude( 1 ).to_s.must_equal "1.”"
-      1.inch.in( :mm ).must_equal 25.4
+      1.inch.in( :mm ).must_be_within_epsilon 25.4
+      assert_equal SY::Unit.instance( :SECOND ), SY::Unit.instance( :second )
     end
   end
 
   describe "expected behavior" do
     it "should" do
+      assert_equal SY::Unit.instance( :SECOND ), SY::Unit.instance( :second )
+
       # Length quantity and typical units
       SY::METRE.must_be_kind_of SY::Unit
       SY::METRE.absolute?.must_equal true
@@ -289,7 +292,7 @@ describe SY::Quantity, SY::Magnitude do
       1.s⁻¹.must_equal 1.s ** -1
       q1 = ( 1.s⁻¹ ).quantity
       q1.composition.to_hash.must_equal( { SY::Time => -1 } )
-      
+
       q2 = ( 1 / 1.s ).quantity
       q2.composition.to_hash.must_equal( { SY::Time => -1 } )
       
@@ -311,8 +314,8 @@ describe SY::Quantity, SY::Magnitude do
       end.must_include :M
       SY::Unit.instance_names.must_include :mole
       # Avogadro's number is defined directly in SY
-      1.mol.quantity.object_id.must_equal SY::Nᴀ.( SY::MoleAmount ).quantity.object_id
-      SY::Nᴀ.( SY::MoleAmount ).must_equal 1.mol
+      1.mol.quantity.object_id.must_equal SY::Nᴀ.unit.( SY::MoleAmount ).quantity.object_id
+      SY::Nᴀ.unit.( SY::MoleAmount ).must_equal 1.mol
       0.7.mol.l⁻¹.amount.must_equal 0.7
       1.M.must_equal 1.mol.l⁻¹.( SY::Molarity )
       # (if #reframe conversion method is not used, different quantities
@@ -345,16 +348,20 @@ describe SY::Quantity, SY::Magnitude do
       1e-23.J.K⁻¹.must_equal 1.0e-20.mJ.K⁻¹
       
       
+
       # pascal
       ( 1.N / 1.m ** 2 ).( SY::Pressure ).must_be_within_epsilon 1.Pa, 1e-9
       
       # watt
       ( 1.V * 1.A ).( SY::Power ).must_be_within_epsilon 1.W, 1e-9
       
+
       # pretty representation
-      ( 1.m / 3.s ).to_s.must_equal( "0.333.m.s⁻¹" )
+      assert_equal SY::Unit.instance( :SECOND ), SY::Unit.instance( :second )
+      ( 1.m / 3.s ).to_s.must_equal( "0.333.m.s⁻¹" ) # FIXME: Discovered a problem here, uncomment the line below
+      # assert_equal SY::Unit.instance( :SECOND ), SY::Unit.instance( :second )
       ( 1.m / 7.01e7.s ).to_s.must_equal( "1.43e-08.m.s⁻¹" )
-      
+
       assert_equal 1.m, 1.s * 1.m.s⁻¹
       assert_equal 1.µM.s⁻¹, 1.µM / 1.s
       assert_equal 1.m.s⁻¹, 1.m.s( -1 )
@@ -365,7 +372,7 @@ describe SY::Quantity, SY::Magnitude do
       assert_equal SY::Amount( 1 ), 1.µM / ( 1.µM + 0.µM )
       assert_equal 1.µM, 1.µM * 1.µM / ( 1.µM + 0.µM )
       assert_in_epsilon 1.µM, 1.µmol / 1.dm( 3 ).( SY::LitreVolume )
-      
+
       assert_equal SY::Molarity.relative, 1.mol.l⁻¹.quantity
       
       assert_equal 1 / SY::Time, 1 / SY::Time
@@ -380,6 +387,11 @@ describe SY::Quantity, SY::Magnitude do
       assert_equal Matrix[[2.m, 3.m], [4.m, 5.m]],
       Matrix[[1.m, 2.m], [3.m, 4.m]] + Matrix[[1.m, 1.m], [1.m, 1.m]]
       assert_equal Matrix[[5.µM]], Matrix[[1.µM]] + Matrix[[2.µM.s⁻¹]] * Matrix[[2.s]]
+      XOXO = SY::Unit.of SY::Volume, amount: 1.l
+      assert_equal 1.l.( SY::Volume ), 1.xoxo.( SY::Volume )
+      assert_equal SY::TRIPLE_POINT_OF_WATER, 0.°C.( SY::Temperature )
+      assert_equal 273.15, 0.°C.in( :K )
+      # assert_equal SY::TRIPLE_POINT_OF_WATER, 0.°C # so far unfinished coercion behavior
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sy
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.5
 platform: ruby
 authors:
 - boris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-19 00:00:00.000000000 Z
+date: 2013-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport