sy 1.0.0

data/lib/sy/signed_magnitude.rb

@@ -0,0 +1,51 @@
+#encoding: utf-8
+
+# Qualities specific to relative magnitudes.
+# 
+module SY::SignedMagnitude
+  # Relative magnitude constructor takes :quantity (alias :of) named argument,
+  # and :amount named argument, where :amount is allowed to be negative.
+  # 
+  def initialize args={}
+    @quantity = args[:quantity] || args[:of]
+    amnt = args[:amount]
+    @amount = case amnt
+              when Numeric then amnt
+              when nil then 1
+              else
+                begin
+                  amnt.amount
+                rescue NameError, NoMethodError
+                  amnt
+                end
+              end
+  end
+
+  # Addition.
+  # 
+  def + m2
+    return magnitude( amount + m2.amount ) if quantity == m2.quantity
+    return quantity.absolute.magnitude( amount + m2.amount ) if
+      quantity.absolute == m2.quantity
+    compat_1, compat_2 = m2.coerce self
+    return compat_1 + compat_2
+  end
+
+  # Subtraction.
+  # 
+  def - m2
+    return magnitude( amount - m2.amount ) if m2.quantity == quantity.relative
+    return quantity.relative.magnitude( amount - m2.amount ) if
+      quantity == m2.quantity
+    compat_1, compat_2 = m2.coerce self
+    return compat_1 - compat_2
+  end
+
+  private
+
+  # String describing this class.
+  # 
+  def çς
+    "±Magnitude"
+  end
+end # module SY::SignedMagnitudeMixin

data/lib/sy/unit.rb

@@ -0,0 +1,288 @@
+#encoding: utf-8
+
+# This class represents a unit of measurement – a predefined magnitude
+# of a metrological quantity.
+# 
+module SY::Unit
+  def self.pre_included target
+    class << target
+      # Overriding this method from NameMagic mixin makes sure that all Unit
+      # subclasses have the same namespace in Unit class, rather then each
+      # parametrized subclass its own.
+      # 
+      def namespace
+        SY::Unit
+      end
+
+      # 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
+        end
+      end
+    end # class << target
+  end # def self.pre_included
+
+  def self.included target
+    target.class_exec do
+      # Let's set up the naming hook for NameMagic:
+      name_set_closure do |name, new_instance, old_name|
+        ɴ = name.to_s
+        up, down = ɴ.upcase, ɴ.downcase
+        unless ɴ == up || ɴ = down
+          raise NameError, "Unit must be either all-upper or all-lower case!"
+        end
+        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
+        up.to_sym
+      end
+
+      # name_get_closure { |name| name.to_s.downcase.to_sym }
+
+      # Using eval, we'll now define all the prefix methods on the target, such
+      # as #mili, #micro, #kilo, #mega, etc. These are defined only for units, to which
+      # they represent multiplication by the factor of the prefix (side effect
+      # of such multiplication is conversion to a normal magnitude). However,
+      # the Unit class offers the opportunity for these prefix methods to cause
+      # <em>reframing</em> into a quantity specified by #quantity_by_prefix
+      # instance method. (This instance method normally returns the unit's own
+      # quantity unchanged, but can and should be overriden for those unit,
+      # which have area-specific prefix use.)
+      # 
+      SY::PREFIX_TABLE.full_prefixes.each do |prefix|
+        unless prefix.empty?
+          define_method prefix do
+            SY::Quantity.instance( quantity_by_prefix( prefix ) )
+              .magnitude( self * SY::PREFIX_TABLE.to_factor( prefix ) )
+          end
+        end
+      end
+    end # module_exec
+  end # def self.included
+
+  include NameMagic
+
+  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 << ꜧ )
+    end
+    
+    # Standard unit constructor. In absence of other named arguments, standard
+    # unit of the specified quantity is merely retrieved. If other named
+    # arguments than :quantity (alias :of) are supplied, they are forwarded to
+    # Quantity#new_standard_unit method, that resets the standard unit of the
+    # specified quantity. Note that :amount for standard units, if supplied, has
+    # special meaning of setting the relationship of that quantity.
+    # 
+    def standard args={}
+      args.must_have :quantity, syn!: :of
+      qnt = SY::Quantity.instance( args.delete :quantity )
+      if args.empty? then
+        qnt.standard_unit 
+      else
+        qnt.new_standard_unit( args )
+      end
+    end
+    
+    # Unit abbreviations as a hash of abbreviation => unit pairs.
+    # 
+    def abbreviations
+      ii = instances
+      Hash[ ii.map( &:short ).zip( ii ).select { |short, _| ! short.nil? } ]
+    end
+
+    # Full list of known unit names and unit abbreviations.
+    # 
+    def known_symbols
+      instance_names + abbreviations.keys
+    end
+
+    # Parses an SPS, curring it with known unit names and abbreviations,
+    # and all known full and short prefixes.
+    # 
+    def parse_sps_using_all_prefixes sps
+      puts "Unit about to sps parse (#{sps})" if SY::DEBUG
+      SY::PREFIX_TABLE.parse_sps( sps, known_symbols )
+    end
+  end # class << self
+
+  # Unlike ordinary magnitudes, units can have names and abbreviations.
+  # 
+  attr_reader :abbreviation
+  alias :short :abbreviation
+  
+  # Unit abbreviation setter.
+  # 
+  def abbreviation= unit_abbreviation
+    @abbreviation = unit_abbreviation.to_sym
+  end
+
+  # Unit abbreviation setter (alias for #abbreviation=).
+  # 
+  def short= unit_abbreviation
+    @abbreviation = unit_abbreviation.to_sym
+  end
+    
+  # Unit name. While named units are typically introduced as constants in
+  # all-upper case, their names are then presented in all-lower case.
+  # 
+  def name
+    ɴ = super
+    return ɴ ? ɴ.to_s.downcase.to_sym : nil
+  end
+
+  # 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.
+  # 
+  def initialize args={}
+    if args.has? :abbreviation, syn!: :short then
+      @abbreviation = args.delete( :abbreviation ).to_sym
+    end
+      
+    # FIXME: Here, we would have to watch out for :amount being set
+    # if it is a number, amount is in standard units
+    # however, if it is a magnitude, especially one of another equidimensional quantity,
+    # 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 args
+  end
+
+  # Addition: Unit is converted to a magnitude before the operation.
+  # 
+  def + other
+    to_magnitude + other
+  end
+
+  # Subtraction: Unit is converted to a magnitude before the operation.
+  # 
+  def - other
+    to_magnitude - other
+  end
+
+  # Multiplication: Unit is converted to a magnitude before the operation.
+  # 
+  def * other
+    to_magnitude * other
+  end
+
+  # Division: Unit is converted to a magnitude before the operation.
+  # 
+  def / other
+    to_magnitude / other
+  end
+
+  # Exponentiation: Unit is converted to a magnitude before the operation.
+  # 
+  def ** exponent
+    to_magnitude ** exponent
+  end
+
+  # Coercion: Unit is converted to a magnitude before coercion is actually
+  # performed.
+  # 
+  def coerce other
+    to_magnitude.coerce( other )
+  end
+
+  # Reframing: Unit is converted to a magnitude before reframing.
+  # 
+  def reframe other_quantity
+    to_magnitude.reframe( other_quantity )
+  end
+
+  # Unit as string.
+  # 
+  def to_s
+    name.nil? ? to_s_when_anonymous : to_s_when_named
+  end
+
+  # Inspect string for the unit.
+  # 
+  def inspect
+    name.nil? ? inspect_when_anonymous : inspect_when_named
+  end
+
+  # Some prefixes of some units are almost exclusively used in certain areas
+  # of science or engineering, and their appearance would indicate such
+  # specific quantity. By default, this method simply returns unit's own
+  # quantity unchanged. But it is expected that the method will be overriden
+  # by a singleton method in those units, which have area-specific prefixes.
+  # For example, centimetre, typical for civil engineering, could cause
+  # reframing into its own CentimetreLength quantity. Assuming METRE unit,
+  # this could be specified for example by:
+  # <tt>
+  # METRE.define_singleton_method :quantity_by_prefix do |full_prefix|
+  #   case full_prefix
+  #   when :centi then CentimetreLength
+  #   else self.quantity end
+  # end
+  # </tt>
+  # 
+  def quantity_by_prefix prefix
+    quantity
+  end
+
+  private
+
+  # Constructs #to_s string when the unit is anonymous.
+  # 
+  def to_s_when_anonymous
+    "[#{çς}: #{amount} of #{quantity}]"
+  end
+
+  # Constructs #to_s string when the unit is named.
+  # 
+  def to_s_when_named
+    name
+  end
+
+  # Constructs inspect string when the unit is anonymous.
+  # 
+  def inspect_when_anonymous
+    "#<#{çς}: #{to_magnitude} >"
+  end
+
+  # Constructs inspect string when the unit is named.
+  # 
+  def inspect_when_named
+    "#<#{çς}: #{name} of #{quantity} >"
+  end
+
+  # String describing this class.
+  # 
+  def çς
+    "Unit"
+  end
+end # class SY::Unit

data/lib/sy/version.rb

@@ -0,0 +1,4 @@
+module SY
+  VERSION = "1.0.0"
+  DEBUG = false # ignore this; debugging only
+end

data/lib/sy/wildcard_zero.rb

@@ -0,0 +1,29 @@
+#encoding: utf-8
+
+# Wildcard zero, stronger than ordinary numeric literal 0.
+# 
+( WILDCARD_ZERO = NullObject.new ).instance_exec {
+  ɪ = self
+  singleton_class.class_exec { define_method :zero do ɪ end }
+  def * other; other.class.zero end
+  def / other
+    self unless other.zero?
+    fail ZeroDivisionError, "The divisor is zero! (#{other})"
+  end
+  def + other; other end
+  def - other; -other end
+  def coerce other; return other, other.class.zero end
+  def zero?; true end
+  def to_s; "∅" end
+  def inspect; to_s end
+  def to_f; 0.0 end
+  def to_i; 0 end
+  def == other
+    z = begin
+          other.class.zero
+        rescue NoMethodError
+          return false
+        end
+    other == z
+  end
+}

data/sy.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sy/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["boris"]
+  gem.email         = ["\"boris@iis.sinica.edu.tw\""]
+  gem.description   = %q{Physical units library}
+  gem.summary       = %q{Simple and concise way to express physical units.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "sy"
+  gem.require_paths = ["lib"]
+  gem.version       = SY::VERSION
+
+  gem.add_dependency "activesupport"
+end

data/test/sy_test.rb

@@ -0,0 +1,385 @@
+#encoding: utf-8
+#! /usr/bin/ruby
+
+# **************************************************************************
+# THIS IS SPEC-STYLE TEST FILE FOR SY PHYSICAL UNITS LIBRARY
+# **************************************************************************
+
+# The following will load Ruby spec-style library
+require 'mathn'
+require 'minitest/spec'
+require 'minitest/autorun'
+
+# The following will load SY library
+# require 'sy'
+require './../lib/sy'
+
+# **************************************************************************
+# THE SPECIFICATIONS START HERE
+# **************************************************************************
+
+describe SY do
+  it "should have basic assets" do
+    # Basic physical dimensions:
+    SY::BASE_DIMENSIONS.to_a.sort
+      .must_equal [ [:L, :LENGTH], [:M, :MASS], [:T, :TIME],
+                    [:Q, :ELECTRIC_CHARGE], [:Θ, :TEMPERATURE] ].sort
+    
+    # Standard unit prefixes:
+    SY::PREFIX_TABLE.map{|row| row[:full] }.sort
+      .must_equal [ "exa", "peta", "tera", "giga", "mega", "kilo",
+                    "mili", "micro", "nano", "pico", "femto", "atto",
+                    "hecto", "deka","deci", "centi", "" ].sort
+  end
+end
+
+describe SY::Dimension do
+  it "should" do
+    # Dimension#new should return same instance when asked twice.
+    assert_equal *[ :L, :L ].map { |d| SY::Dimension.new( d ).object_id }
+
+    # Other Dimension constructors: #basic and #zero.
+    SY::Dimension.basic( :L ).must_equal SY.Dimension( :L )
+    SY::Dimension.zero.must_equal SY::Dimension.new( '' )
+
+    # SY should have table of standard quantities.
+    assert SY.Dimension( :L ).standard_quantity.is_a? SY::Quantity
+
+    # Instances should provide access to base dimensions.
+    assert_equal [0, 1], [:L, :M].map { |ß| SY.Dimension( :M ).send ß }
+    assert_equal [1, 0], [:L, :M].map { |ß| SY.Dimension( :L )[ß] }
+
+    # #to_a, #to_hash, #zero?, 
+    ll = SY::BASE_DIMENSIONS.letters
+    SY.Dimension( :M ).to_a.must_equal ll.map { |l| l == :M ? 1 : 0 }
+    SY.Dimension( :M ).to_hash.must_equal Hash[ ll.zip SY.Dimension( :M ).to_a ]
+    SY.Dimension( :M ).zero?.must_equal false
+    SY::Dimension.zero.zero?.must_equal true
+    SY.Dimension( nil ).to_a.must_equal [ 0, 0, 0, 0, 0 ]
+
+    # Dimension arithmetic
+    assert SY.Dimension( :L ) + SY.Dimension( :M ) == SY.Dimension( 'L.M' )
+    assert SY.Dimension( :L ) - SY.Dimension( :M ) == SY.Dimension( 'L.M⁻¹' )
+    assert SY.Dimension( :L ) * 2 == SY.Dimension( 'L²' )
+    assert SY.Dimension( M: 2 ) / 2 == SY.Dimension( :M )
+  end
+end
+
+describe SY::Mapping do
+  it "should" do
+    i = SY::Mapping.identity
+    a, b = SY::Mapping.new( 2 ), SY::Mapping.new( 3 )
+    assert_equal 1, i.ratio
+    assert_equal 4, a.im.( 8 )
+    assert_equal 3, b.ex.( 1 )
+    assert_equal 6, (a * b).ex.( 1 )
+    assert_equal 2, (a * b / b).ex.( 1 )
+    assert_equal 4, (a ** 2).ex.( 1 )
+    assert_equal 2, a.inverse.im.( 1 )
+  end
+end
+
+describe SY::Composition do
+  it "should" do
+    assert_equal SY::Amount, SY.Dimension( :∅ ).standard_quantity
+    a = SY::Composition[ SY::Amount => 1 ]
+    l = SY::Composition[ SY::Length => 1 ]
+    assert SY::Composition.new.empty?
+    assert a.singular?
+    assert l.atomic?
+    assert_equal SY::Composition[ SY::Amount => 1, SY::Length => 1 ], a + l
+    assert_equal SY::Composition[ SY::Amount => 1, SY::Length => -1 ], a - l
+    assert_equal SY::Composition[ SY::Length => 2 ], l * 2
+    assert_equal l, l * 2 / 2
+    assert_equal l.to_hash, (a + l).simplify.to_hash
+    assert_equal SY::Amount, a.to_quantity
+    assert_equal SY::Length, l.to_quantity
+    assert_equal( SY.Dimension( 'L' ),
+                  SY::Composition[ SY::Amount => 1, SY::Length => 1 ]
+                    .to_quantity.dimension )
+    assert_equal SY.Dimension( 'L' ), l.dimension
+    assert_kind_of SY::Mapping, a.infer_mapping
+  end
+end
+
+describe SY::Quantity, SY::Magnitude do
+  before do
+    @q1 = SY::Quantity.new of: '∅'
+    @q2 = SY::Quantity.dimensionless
+    @amount_in_dozens = begin
+                          SY.Quantity( "AmountInDozens" )
+                        rescue
+                          SY::Quantity.dimensionless mapping: 12, ɴ: "AmountInDozens"
+                        end
+    @inch_length = begin
+                     SY.Quantity( "InchLength" )
+                   rescue NameError
+                     SY::Quantity.of SY::Length.dimension, ɴ: "InchLength"
+                   end
+  end
+
+  it "should" do
+    refute_equal @q1, @q2
+    assert @q1.absolute? && @q2.absolute?
+    assert @q1 == @q1.absolute
+    assert_equal false, @q1.relative?
+    assert_equal SY::Composition.new, @q1.composition
+    @q1.set_composition SY::Composition[ SY::Amount => 1 ]
+    assert_equal SY::Composition[ SY::Amount => 1 ], @q1.composition
+    @amount_in_dozens.must_be_kind_of SY::Quantity
+    d1 = @amount_in_dozens.magnitude 1
+    a12 = SY::Amount.magnitude 12
+    mda = @amount_in_dozens.mapping_to SY::Amount
+    i, e = mda.im, mda.ex
+    ia = i.( a12.amount )
+    @amount_in_dozens.magnitude ia
+    im = @amount_in_dozens.import( a12 )
+    assert_equal @amount_in_dozens.magnitude( 1 ),
+                 @amount_in_dozens.import( SY::Amount.magnitude( 12 ) )
+    assert_equal SY::Amount.magnitude( 12 ),
+                 @amount_in_dozens.export( 1, SY::Amount )
+    SY::Length.composition.must_equal SY::Composition.singular( :Length )
+  end
+
+  describe "Magnitude, Unit" do
+    before do
+      @m1 = 1.metre
+      @inch = SY::Unit.standard( of: @inch_length, amount: 2.54.cm,
+                                 ɴ: 'inch', short: '”' )
+      @i1 = @inch_length.magnitude 1
+      @il_mapping = @inch_length.mapping_to SY::Length
+    end
+    
+    it "should" do
+      @m1.quantity.must_equal SY::Length.relative
+      @inch_length.colleague.name.must_equal :InchLength±
+      @m1.to_s.must_equal "1.m"
+      @i1.amount.must_equal 1
+      assert_kind_of SY::Mapping, @il_mapping
+      assert_kind_of Numeric, @il_mapping.ratio
+      assert_in_epsilon 0.0254, @il_mapping.ratio
+      @il_mapping.ex.( 1 ).must_be_within_epsilon 0.0254
+      begin
+        impossible_mapping = @inch_length.mapping_to SY::Amount
+      rescue SY::DimensionError
+        :dimension_error
+      end.must_equal :dimension_error
+      # reframing
+      1.inch.reframe( @inch_length ).amount.must_equal 1
+      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
+    end
+  end
+end
+
+describe "expected behavior" do
+  it "should" do
+    # Length quantity and typical units
+    SY::METRE.must_be_kind_of SY::Unit
+    SY::METRE.absolute?.must_equal true
+    1.metre.absolute.must_equal SY::METRE
+    assert 1.metre.absolute != 1.metre.relative
+    1.metre.relative.relative?.must_equal true
+
+
+    SY::METRE.relative.must_equal 1.metre
+    1.m.must_equal 1.metre
+    1.m.must_equal 1000.mm
+    SY::METRE.quantity.name.must_equal :Length
+    assert_in_delta 0.9.µm, 900.nm, 1e-6.nm
+    [ 1.m, 1.m ].min.must_equal 1.m
+    1.m + 1.m == 1.m
+    assert_in_epsilon 1.m, 1.m, 0.1
+    600.m.must_equal 0.6.km
+    SY::METRE.quantity.must_equal SY::Length
+    SY::Length.dimension.must_equal SY.Dimension( :L )
+    SY.Dimension( :L ).standard_quantity.must_equal SY::Length
+    SY::Length.standard_unit.must_equal SY::METRE
+    SY::METRE.amount.must_equal 1
+    SY::METRE.mili.amount.must_equal 0.001
+    3.km.in( :dm ).must_equal 30_000
+    ( 1.m + 20.cm ).must_equal 1_200.mm
+    assert 1.mm.object_id != 1.mm.object_id
+    assert 1.mm == 1.mm
+    assert 1.01.m != 1.m
+    assert_equal 1, 1.01.m <=> 1.m
+    assert_equal 0, 1.00.m <=> 1.m
+    assert_equal -1, 0.99.m <=> 1.m
+    assert 0.9.mm < 1.mm
+    assert 1.1.mm > 1.09.mm
+    assert ( 0.1.m - ( 1.m - 0.9.m ) ).abs < 1.nm.abs
+    # Mass quantity and typical units
+    SY::KILOGRAM.must_be_kind_of SY::Unit
+    SY::GRAM.must_be_kind_of SY::Unit
+    assert SY::Mass.standard_unit.equal?( SY::KILOGRAM )
+    1.kilogram.must_be_kind_of SY::Magnitude
+    1.gram.must_be_kind_of SY::Magnitude
+    1.kilogram.absolute.quantity.must_equal SY::Mass
+    1.gram.absolute.quantity.must_equal SY::Mass
+    ( SY::KILOGRAM * 1 ).must_equal SY::GRAM * 1000
+    1.kilogram.must_equal 1000.g
+    1.kg.to_f.must_equal 1
+    1.g.to_f.must_equal 0.001
+    1.miligram.must_equal 0.001.g
+    1.mg.must_equal 1.miligram
+    1.µg.must_equal 0.001.miligram
+    1.ng.must_equal 0.001.microgram
+    1.pg.quantity.must_equal 0.001.nanogram.quantity
+    1.pg.amount.must_be_within_epsilon 0.001.nanogram.amount, 1e-6
+    assert_equal 1.g, [1.g, 2.g].min
+    assert_equal 1.mg, 1.g * 0.001
+    1.pg.abs.must_be_within_epsilon 0.001.nanogram.abs, 1e-6
+    SY::TON.must_be_kind_of SY::Unit
+    1.ton.must_equal 1000.kg
+    1.t.must_equal 1.ton
+    1.kt.must_equal 1000.ton
+    1.Mt.must_equal 1000.kiloton
+    1.mm.quantity.name.must_equal :Length±
+    SY::Length.standard_unit.must_equal SY::METRE
+    SY::Length.standard_unit.name.must_equal :metre
+    SY::Length.standard_unit.must_equal SY::METRE
+    SY.Quantity( :Length ).object_id.must_equal SY::Length.object_id
+    SY::Length.relative.object_id.must_equal SY.Quantity( :Length± ).object_id
+    SY.Quantity( :Length± ).colleague.name.must_equal :Length
+    SY.Quantity( :Length± ).colleague.class.must_equal SY::Quantity
+    SY.Quantity( :Length± ).colleague.object_id.must_equal SY::Length.object_id
+    SY.Quantity( :Length± ).send( :Unit ).object_id
+      .must_equal SY::Length.send( :Unit ).object_id
+    1.mm.quantity.standard_unit.name.must_equal :metre
+    1.mm.to_s.must_equal "0.001.m"
+    1.mm.inspect.must_equal "#<±Magnitude: 0.001.m >"
+    1.µs.inspect.must_equal "#<±Magnitude: 1e-06.s >"
+
+    SY::Area.dimension.must_equal SY.Dimension( :L² )
+    SY::Area.composition.must_equal SY::Composition[ SY::Length => 2 ]
+    
+    SY::AMPERE.name.must_equal :ampere
+    SY::AMPERE.abbreviation.must_equal :A
+    SY::AMPERE.dimension.must_equal 1.A.dimension
+    SY.Magnitude( of: SY::ElectricCurrent, amount: 1 ).must_equal 1.A.absolute
+    1.A.quantity.must_equal SY::ElectricCurrent.relative
+    1.A.quantity.standard_unit.name.must_equal :ampere
+    1.A.to_s( SY::AMPERE ).must_equal "1.A"
+    1.A.to_s.must_equal "1.A"
+    1.A.amount.must_equal 1
+    1.A.quantity.standard_unit.abbreviation.must_equal :A
+    1.A.inspect.must_equal "#<±Magnitude: 1.A >"
+
+    1.l⁻¹.reframe( SY::Molarity ).quantity.must_equal SY::Molarity
+    x = ( SY::Nᴀ / SY::LITRE )
+    x = x.reframe( SY::Molarity )
+    y = 1.molar.absolute
+    y.quantity.must_equal x.quantity
+    y.amount.must_equal y.amount
+    SY::MoleAmount.protected?.must_equal true
+    SY::LitreVolume.protected?.must_equal true
+    SY::MOLAR.quantity.name.must_equal :Molarity
+    m = 1.µM
+    1.µM.quantity.relative?.must_equal true
+    1.µM.quantity.name.must_equal :Molarity±
+    1.µM.quantity.absolute.name.must_equal :Molarity
+    7.µM.must_be_within_epsilon 5.µM + 2.µM, 1e-6
+    +1.s.must_equal 1.s
+    # -1.s.must_equal -1 * 1.s # must raise
+    assert_equal -(-(1.s)), +(1.s)
+    1.s⁻¹.quantity.must_equal ( 1.s ** -1 ).quantity
+    1.s⁻¹.quantity.must_equal ( 1 / 1.s ).quantity
+    1.s⁻¹.amount.must_equal ( 1.s ** -1 ).amount
+    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 } )
+
+    q1.relative?.must_equal true
+    q2.relative?.must_equal true
+
+    q1.object_id.must_equal q2.object_id
+    ( 1.s⁻¹ ).quantity.object_id.must_equal ( 1 / 1.s ).quantity.object_id
+    ( 1 / 1.s ).must_equal 1.s⁻¹
+    1.s⁻¹.( SY::Frequency ).must_equal 1.Hz
+    # 7.°C.must_equal( 8.°C - 1.K )
+    # (-15).°C.must_equal 258.15.K
+    # 7000.µM.must_be_within_epsilon( 7.mM, 1e-9 )
+    ::SY::Unit.instances.map do |i|
+      begin
+        i.abbreviation
+      rescue
+      end
+    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
+    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
+    # do not compare. Arithmetics is possible because Magnitude operators
+    # mostly give their results only in standard quantities.
+
+    # Avogadro's number is defined directly in SY
+    1.mol.must_equal SY::Nᴀ.unit.( SY::MoleAmount )
+
+
+    0.7.M.must_equal 0.7.mol.l⁻¹.( SY::Molarity )
+    # (if #is_actually! conversion method is not used, current
+    # implementation will refuse to compare different quantities,
+    # even if their dimensions match)
+
+    30.Hz.must_equal 30.s⁻¹.( SY::Frequency )
+
+    # Dalton * Avogadro must be 1 gram
+    ( 1.Da * SY::Nᴀ ).must_be_within_epsilon( 1.g, 1e-6 )
+
+    # kilogram
+    1.kg.must_equal 1000.g
+    SY::Speed.dimension.must_equal SY::Dimension( "L.T⁻¹" )
+    SY::Acceleration.dimension.must_equal SY::Dimension( "L.T⁻²" )
+    SY::Force.dimension.must_equal SY::Dimension( "L.M.T⁻²" )
+    ( 1.kg * 1.m.s⁻² ).( SY::Force ).must_be_within_epsilon 1.N, 1e-9
+
+    # joule
+    ( 1.N * 1.m ).( SY::Energy ).must_equal 1.J
+    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⁻¹" )
+    ( 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 )
+    assert_equal 2_000.mm.s⁻², 2.m.s( -2 )
+    assert_equal 3.µM, 1.µM + 2.µM
+    assert_equal SY::Amount, SY::Molarity / SY::Molarity
+    assert_equal SY::Amount( 1 ), 1.µM / 1.µM
+    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
+    assert_equal 1 / SY::Time.relative, 1 / SY::Time
+    assert_equal ( 1 / SY::Time.relative ), 1.mol.s⁻¹.( 1 / SY::Time ).quantity
+    assert_equal ( 1 / SY::Time ).object_id,
+                 ( 1.0.µmol.min⁻¹.mg⁻¹ * 100.kDa ).( 1 / SY::Time ).quantity.object_id
+    assert_equal SY::Time.magnitude( 1 ), SY::SECOND
+    assert_equal Matrix[[60.mM], [60.mM]], Matrix[[1e-03.s⁻¹.M], [1e-3.s⁻¹.M]] * 60.s
+
+    assert_equal Matrix[[5.m]], Matrix[[1.m.s⁻¹, 2.m.s⁻¹]] * Matrix.column_vector( [1.s, 2.s] )
+    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]]
+  end
+end