sy 2.1.2 → 2.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae8923105001742a2064fd481c4d717be266bb0b
-  data.tar.gz: 17eb6ed00ef92bb3198b924ac1bb26c78e65e43a
+  metadata.gz: 05a4502f974a88c613b402394d0e303bac458836
+  data.tar.gz: 799053c77aef863d27d6d5e816289a26fe48952d
 SHA512:
-  metadata.gz: 260fb7cf5817e8a6f2e6580ed4ad4659907e0ef4c7afb359cb2c2bd3be491f42d0b5db086562d2306139906a7c09e7f004ee5a26ea6213a18d2b5afa77ef69a9
-  data.tar.gz: 90c477a51032265b20e2b4b83d20278ccaa2e1dabca76fab66892226aac7afa646dbd351fa3003ccdb2e28c03f4837d8c6d3d2fa2594e6441aab7b3e8de5a15d
+  metadata.gz: 9d83e13e2eac8a780dce7ea70f9f578586bbf749e9d1aec39345b9a6d5f0b4dc24754ce0cfd81671cddef6016cc6a242a1885e3b0be09f827cd410139c6a6d8d
+  data.tar.gz: 90f1266a32befff128873f820ebc679ff97de0a5f3325724864f3b24b7e4c9d32b8b50d362a256419a886f5ab61f9ac8bf0af087d2915422b6f5aa9b956e6bb5

data/lib/sy.rb

@@ -5,7 +5,6 @@ require 'y_support/name_magic'
 require 'y_support/core_ext/hash'
 require 'y_support/typing'
 require 'y_support/unicode'
-require 'y_support/abstract_algebra'
 
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/array/extract_options'
@@ -71,10 +70,7 @@ module SY
   # 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.
-  puts "About to construct UNIT." if SY::DEBUG
   UNIT = Unit.standard of: Amount
-  puts "UNIT constructed. SY::Unit instances are " +
-    "#{SY::Unit.instance_names}" if SY::DEBUG
 
   # AVOGADRO_CONSTANT (Nᴀ) is a certain well-known amount of things:
   Nᴀ = AVOGADRO_CONSTANT = 6.02214e23
@@ -83,11 +79,7 @@ module SY
   MoleAmount = Quantity.dimensionless coerces: Amount
 
   # And let SY::MOLE be its standard unit, related to SY::Amount via Nᴀ:
-  puts "About to construct MOLE." if SY::DEBUG
   MOLE = Unit.standard of: MoleAmount, short: "mol", amount: Nᴀ * UNIT
-  puts SY::Unit.__instances__ if SY::DEBUG
-  puts "MOLE constructed. SY::Unit instances are" +
-    "#{SY::Unit.instance_names}" if SY::DEBUG
 
   # === Basic dimension L (length)
 
@@ -185,7 +177,7 @@ module SY
       super
     end
 
-    # FIXME: #% method etc
+    # TODO: #% method etc
   end
 
   # Making sure that for Celsius temperature, #°C returns absolute magnitude.
@@ -196,10 +188,6 @@ module SY
     end
   end
 
-  # FIXME: Make this more systematic.
-  # FIXME: Make sure that SI prefixes may not be used with Celsius
-  # FIXME: Make sure that highly unusual SI prefixes may not be used
-
   class << CelsiusTemperature.send( :Magnitude )
     include SY::CelsiusMagnitude
   end
@@ -208,32 +196,9 @@ module SY
     include SY::CelsiusMagnitude
   end
 
-  # alias :°C :celsius                 # with U+00B0 DEGREE SIGN
-  # alias :˚C :celsius                 # with U+02DA RING ABOVE
-  # alias :℃ :celsius                  # U+2103 DEGREE CELSIUS
-
-  # FahrenheitTemperature = Quantity.of :Θ
-  # FAHRENHEIT = Unit.standard of: FahrenheitTemperature, short: '°F'
-  # # alias :°F :fahrenheit              # with U+00B0 DEGREE SIGN
-  # # alias :˚F :fahrenheit              # with U+02DA RING ABOVE
-  # # alias :℉ :fahrenheit               # U+2109 DEGREE FAHRENHEIT
-  # # FIXME: Patch FahrenheitTemperature to make it work with SY::Temperature
-
-  
-  # HUMAN_BODY_TEMPERATURE = 37.°C.( KELVIN )
-  # STANDARD_TEMPERATURE = 25.°C.( KELVIN )
   HUMAN_BODY_TEMPERATURE = TP_H₂O + 37 * KELVIN
   STANDARD_LABORATORY_TEMPERATURE = TP_H₂O + 25 * KELVIN
 
-  # === Dimensionless quantities
-
-  # For now, these are just unimplemented proposals of what users might expect
-  # from SY:
-  # 
-  # degree, alias deg, ° # angle measure
-  # arcminute, alias ʹ, ′ # angle measure
-  # arcsecond, alias ʹʹ, ′′, ″
-
   # === Quantities of composite dimensions
 
   # Quantity SY::Area is obtained by raising quantity SY::Length to 2:
@@ -281,7 +246,7 @@ module SY
   # of its dimension.
   Speed = ( Length / Time ).standard!
 
-  # Common constant
+  # Commonly used constant.
   SPEED_OF_LIGHT = 299_792_458 * METRE / SECOND
 
   # Supplementary unit of length.
@@ -299,7 +264,7 @@ module SY
   # For SY::Energy...
   Energy = ( Force * Length ).standard!
 
-  # make SY::JOULE its standard unit:
+  # Make SY::JOULE its standard unit:
   JOULE = Unit.standard of: Energy, short: "J"
   # SY::CALORIE means thermochemical calorie:
   CALORIE = Unit.of Energy, short: "cal", amount: 4.184 * JOULE
@@ -331,11 +296,6 @@ module SY
   # make SY::VOLT its standard unit:
   VOLT = Unit.standard of: ElectricPotential, short: "V"
 
-  # TODO: This should raise a friendly error:
-  # MOLAR = Unit.standard of: Molarity, short: "M", amount: 1.mol.l⁻¹
-  # (normal way of definition is MOLAR = Unit.standard of: Molarity, short: "M"
-  # and it has already been defined to boot)
-
   # SY::Molality...
   Molality = MoleAmount / Mass
 
@@ -351,4 +311,4 @@ module SY
   ELEMENTARY_CHARGE = 1.60217656535e-19 * COULOMB
 
   ELECTRONVOLT = Unit.of Energy, short: "eV", amount: ELEMENTARY_CHARGE * VOLT
-end
+end

data/lib/sy/absolute_magnitude.rb

@@ -18,24 +18,15 @@ module SY::AbsoluteMagnitude
   # and :amount named argument, where amount must be nonnegative.
   # 
   def initialize( of: nil, amount: nil )
-    puts "Constructing AbsoluteMagnitude of #{of}, amount: #{amount}" if SY::DEBUG
     fail ArgumentError, "Quantity (:of) argument missing!" if of.nil?
     @quantity = of
     @amount = case amount
-              when Numeric then
-                puts "This amount is a Numeric, using it directly" if SY::DEBUG
-                amount
-              when nil then
-                puts "This amount is 'nil', using 1 instead" if SY::DEBUG
-                1
+              when Numeric then amount
+              when nil then 1
               else
                 begin
-                  puts "Amount #{amount} will be reframed to #{@quantity}" if SY::DEBUG
                   amount.( @quantity ).amount
-                rescue NameError, NoMethodError
-                  puts "fail, amount #{amount} will be used directly" if SY::DEBUG
-                  amount
-                end
+                rescue NameError, NoMethodError; amount end
               end
     fail SY::MagnitudeError, "Attempt to construct an unsigned magnitude " +
       "(SY::AbsoluteMagnitude) with a negative amount." if @amount < 0
@@ -44,16 +35,12 @@ module SY::AbsoluteMagnitude
   # For absolute magnitudes, #+ method always returns a result framed in
   # corresponding relative quantity.
   # 
-  # TODO: Figure out which module comes on the top in Quantity@Magnitude, whether Magnitude
-  # or SignedMagnitude, and therefore, whether it is necessary to adjust this method.
   def + m2
     return magnitude amount + m2.amount if m2.quantity == quantity.relative
     return quantity.relative.magnitude( amount + m2.amount ) if
       quantity == m2.quantity
     return self if m2.equal? SY::ZERO
-    # o1, o2 = m2.coerce( self )
-    # return o1 + o2
-    raise SY::QuantityError, "Unable to perform #{quantity} + #{m2.quantity}!"
+    fail SY::QuantityError, "Unable to perform #{quantity} + #{m2.quantity}!"
   end
 
   # Addition of absolute magnitudes that returns a result framed as
@@ -62,24 +49,18 @@ module SY::AbsoluteMagnitude
   def add m2
     return magnitude( amount + m2.amount ) if quantity == m2.quantity
     return self if m2.equal? SY::ZERO
-    # o1, o2 = m2.coerce( self )
-    # return o1.add o2
-    raise SY::QuantityError, "Unable to perform #add with #{m2.quantity}!"
+    fail SY::QuantityError, "Unable to perform #add with #{m2.quantity}!"
   end
 
   # For absolute magnitudes, #- method always returns a result framed in
   # corresponding relative quantity.
   # 
-  # TODO: Figure out which module comes on the top in Quantity@Magnitude, whether Magnitude
-  # or SignedMagnitude, and therefore, whether it is necessary to adjust this method.
   def - m2
     return magnitude amount - m2.amount if m2.quantity == quantity.relative
     return quantity.relative.magnitude( amount - m2.amount ) if
       quantity == m2.quantity
     return self if m2.equal? SY::ZERO
-    # o1, o2 = m2.coerce( self )
-    # return o1 - o2
-    raise( SY::QuantityError, "Unable to perform #{quantity} - #{m2.quantity}!" )
+    fail SY::QuantityError, "Unable to perform #{quantity} - #{m2.quantity}!"
   end
 
   # Subtraction of absolute magnitudes that returns a result framed as
@@ -89,9 +70,7 @@ module SY::AbsoluteMagnitude
   def subtract m2
     return magnitude( amount + m2.amount ) if quantity == m2.quantity
     return self if m2.equal? SY::ZERO
-    # o1, o2 = m2.coerce( self )
-    # return o1.subtract o2
-    raise( SY::QuantityError, "Unable to perform #add with #{m2.quantity}!" )
+    fail SY::QuantityError, "Unable to perform #add with #{m2.quantity}!"
   end
 
   # "Subtraction" of absolute magnitudes, that never takes more thant the
@@ -112,7 +91,5 @@ module SY::AbsoluteMagnitude
 
   # String describing this class.
   # 
-  def çς
-    "Magnitude"
-  end
+  def çς; "Magnitude" end
 end # class SY::AbsoluteMagnitude

data/lib/sy/composition.rb

@@ -28,8 +28,8 @@ class SY::Composition < Hash
     ꜧ.reject! { |_, exp| exp == 0 }
   }
 
-  # FIXME: This quick fix simplification rule simplifies MoleAmount and
-  # LitreVolume into Molarity. This solution is insufficiently systematic.
+  # This simplification rule simplifies MoleAmount and LitreVolume into
+  # Molarity.
   # 
   SR << -> ꜧ {
     begin
@@ -61,8 +61,8 @@ class SY::Composition < Hash
     return ꜧ
   }
 
-  # FIXME: This quick fix simplification rule simplifies LitreVolume times
-  # Molarity into MoleAmount. This solution is insufficiently systematic.
+  # This simplification rule simplifies LitreVolume times Molarity into
+  # MoleAmount.
   # 
   SR << -> ꜧ {
     begin
@@ -130,8 +130,6 @@ class SY::Composition < Hash
   # is a base dimension.
   # 
   def atomic?
-    puts "composition is #{self}" if SY::DEBUG
-    puts "first[0].dimension is #{first[0].dimension}" if SY::DEBUG
     singular? && first[0].dimension.base?
   end
 
@@ -206,9 +204,8 @@ class SY::Composition < Hash
   # 
   def simplify
     ꜧ = self.to_hash
-    puts "simplifying #{ꜧ}" if SY::DEBUG
     SIMPLIFICATION_RULES.each { |rule| rule.( ꜧ ) }
-    self.class[ ꜧ ].tap { |_| puts "result is #{_}" if SY::DEBUG }
+    self.class[ ꜧ ]
   end
 
   # Returns the quantity appropriate to this composition.
@@ -236,15 +233,8 @@ class SY::Composition < Hash
   # of the pertinent standard quantity.)
   # 
   def infer_measure
-    puts "#infer_measure; hash is #{self}" if SY::DEBUG
     map do |qnt, exp|
-      puts "#infer_measure: doing quantity #{qnt} with exponent #{exp}!" if SY::DEBUG
-      if qnt.standardish? then
-        puts "#{qnt} standardish" if SY::DEBUG
-        SY::Measure.identity
-      else
-        puts "#{qnt} not standardish" if SY::DEBUG
-        puts "its measure is #{qnt.measure}, class #{qnt.measure.class}" if SY::DEBUG
+      if qnt.standardish? then SY::Measure.identity else
         qnt.measure( of: qnt.standard ) ** exp
       end
     end.reduce( SY::Measure.identity, :* )
@@ -265,18 +255,13 @@ class SY::Composition < Hash
   # 
   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 }
+                       end )
                 } ]
-      .tap{ |rslt| puts "#expand: result is #{rslt}" if SY::DEBUG }
   end
 end # class SY::Composition

data/lib/sy/dimension.rb

@@ -39,9 +39,7 @@ class SY::Dimension
 
     # Presents class-owned instances (array).
     # 
-    def instances
-      return @instances ||= []
-    end
+    def instances; return @instances ||= [] end
 
     # Base dimension constructor. Base dimension symbol is expeced as argument.
     # 

data/lib/sy/expressible_in_units.rb

@@ -23,7 +23,7 @@ module SY::ExpressibleInUnits
           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
+          instance_variable_set( :@no_collision, nil )
         else
           warn w if ꜧ[ß].warns?
         end
@@ -33,7 +33,7 @@ module SY::ExpressibleInUnits
           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
+          instance_variable_set( :@no_collision, nil )
         else
           warn w if ꜧ[ß].warns?
         end
@@ -83,10 +83,7 @@ module SY::ExpressibleInUnits
     def known_units
       begin
         unit_namespace.instances
-      rescue NoMethodError 
-        [] # no #instances method defined yet
-      end
-        .tap { |r| puts "Known units are #{r}" if SY::DEBUG }
+      rescue NoMethodError; [] end
     end
 
     # All methods defined by this mixin.
@@ -98,7 +95,6 @@ module SY::ExpressibleInUnits
     # Find unit based on name / abbreviation.
     # 
     def find_unit ς
-      puts "searching for unit #{ς}" if SY::DEBUG
       known_units.find do |u|
         u.name.to_s.downcase == ς.downcase &&
           ( ς == ς.downcase || ς == ς.upcase ) ||
@@ -109,7 +105,6 @@ module SY::ExpressibleInUnits
     # 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
@@ -126,19 +121,12 @@ module SY::ExpressibleInUnits
     super if ß.to_s =~ /to_.+/ # dissmiss :to_..., esp. :to_ary
     begin # prevent recurrent call of method_missing for the same symbol
       anti_recursion_exec token: ß, var: :@SY_Units_mmiss do
-        puts "Method missing: '#{ß}'" if SY::DEBUG
         prefixes, units, exps = parse_unit_symbol ß
-        # Define the unit method on self.class:
-        # I'D HAVE TO PERFORM THE COLLISION CHECK HERE
-        # IF NO COLLISION, INFORM THE SUBSEQUENT METHOD DEFINED CALL ON
-        # SELF.CLASS
-        puts "parsed" if SY::DEBUG
-        self.class.instance_variable_set "@no_collision", ß # FIXME: This is too clumsy
+        self.class.instance_variable_set "@no_collision", ß
         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
       super # give up
     rescue SY::ExpressibleInUnits::RecursionError
       super # give up
@@ -167,7 +155,6 @@ module SY::ExpressibleInUnits
   # figures out which SY units it represents, along with prefixes and exponents. 
   # 
   def parse_unit_symbol ß
-    puts "About to parse #{ß} using all prefixes" if SY::DEBUG
     SY::Unit.parse_sps_using_all_prefixes( ß ) # rely on SY::Unit
   end
 
@@ -176,12 +163,10 @@ module SY::ExpressibleInUnits
   # Arrays must be of equal length. (Note: 'ß' is 'symbol', 'ς' is 'string')
   # 
   def write_unit_method ß, prefixes, units, exponents
-    puts "writing unit method #{ß}" if SY::DEBUG
     # 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|
-      puts "Processing triple #{pfx}, #{unit_ς}, #{exp}." if SY::DEBUG
       [ ::SY::ExpressibleInUnits.find_unit( unit_ς ).name.to_s.upcase, 
         ::SY::ExpressibleInUnits.prefix_method_string( pfx ),
         ::SY::ExpressibleInUnits.exponentiation_string( exp ) ]
@@ -211,7 +196,7 @@ module SY::ExpressibleInUnits
       method_body = factors.join( " * \n    " )
     end
     # Return the finished method string:
-    return ( method_skeleton % method_body ).tap { |ς| puts ς if SY::DEBUG }
+    return ( method_skeleton % method_body )
   end
 
   # Takes a token as the first argument, a symbol of the instance variable to
@@ -230,9 +215,4 @@ module SY::ExpressibleInUnits
       registry.delete token
     end
   end
-
-  # FIXME: There should be an option to define by default, already at the
-  # beginning, certain methods for certain classes, to get in front of possible
-  # collisions. Collision was detected for example for #second with
-  # active_support/duration.rb
 end

data/lib/sy/fixed_assets_of_the_module.rb

@@ -18,22 +18,16 @@ module SY
   class << BASE_DIMENSIONS
     # Letters of the base dimensions.
     #
-    def letters
-      keys
-    end
+    def letters; keys end
 
     # Base dimensions letters with prefixes. (Remark: I forgot what did I mean
     # those prefixes for. Something important, I just forgot what.)
     # 
-    def prefixed_letters
-      [] # none for now
-    end
+    def prefixed_letters; [] end
 
     # Base dimension symbols – letters and prefixed letters.
     # 
-    def base_symbols
-      @baseß ||= letters + prefixed_letters
-    end
+    def base_symbols; @baseß ||= letters + prefixed_letters end
     alias basic_symbols base_symbols
 
     # Takes an sps representing a dimension, and converts it to a hash of
@@ -45,7 +39,7 @@ module SY
     end
   end
 
-    # Table of standard prefixes and their corresponding unit multiples.
+  # Table of standard prefixes and their corresponding unit multiples.
   # 
   PREFIX_TABLE = [ { full: "exa", short: "E", factor: 1e18 },
                    { full: "peta", short: "P", factor: 1e15 },
@@ -144,9 +138,7 @@ module SY
   SUPERSCRIPT = Hash.new { |ꜧ, key|
     if key.is_a? String then
       key.size <= 1 ? nil : key.each_char.map{|c| ꜧ[c] }.join
-    else
-      ꜧ[key.to_s]
-    end
+    else ꜧ[key.to_s] end
   }.merge! Hash[ '-/0123456789'.each_char.zip( '⁻⎖⁰¹²³⁴⁵⁶⁷⁸⁹'.each_char ) ]
 
   # Reverse conversion of Unicode superscript exponents (from exponent
@@ -155,9 +147,7 @@ module SY
   SUPERSCRIPT_DOWN = Hash.new { |ꜧ, key|
     if key.is_a? String then
       key.size == 1 ? nil : key.each_char.map{|c| ꜧ[c] }.join
-    else
-      ꜧ[key.to_s]
-    end
+    else ꜧ[key.to_s] end
   }.merge!( SUPERSCRIPT.invert ).merge!( '¯' => '-', # other superscript chars
                                          '´' => '/' )
 

data/lib/sy/magnitude.rb

@@ -265,124 +265,16 @@ module SY::Magnitude
 
   # 
   def to_s( unit=quantity.units.first || quantity.standard_unit,
-            number_format=default_amount_format ) # FIXME: TUTO JE TO KUREVSTVO TU SA TA JEDNOTKA KONSTRUUJE
-    puts "#to_s called on a magnitude of quantity #{quantity}" if SY::DEBUG
-    # step 1: produce pairs [number, unit_presentation],
-    #         where unit_presentation is an array of triples
-    #         [prefix, unit, exponent], which together give the
-    #         correct dimension for this magnitude, and correct
-    #         factor so that number * factor == self.amount
-    # step 2: define a goodness function for them
-    # step 3: define a satisfaction criterion
-    # step 4: maximize this goodness function until the satisfaction
-    #         criterion is met
-    # step 5: interpolate the string from the chosen choice
-    
-    # so, let's start doing it
-    # how do we produce the first choice?
-    # if the standard unit for this quantity is named, we'll start with it
-    
-    # let's say that the abbreviation of this std. unit is Uu, so the first
-    # choices will be:
-    # 
-    #                        amount.Uu
-    #                        (amount * 1000).µUu
-    #                        (amount / 1000).kUu
-    #                        (amount * 1_000_000).nUu
-    #                        (amount / 1_000_000).MUu
-    #                        ...
-    #                        
-    # (let's say we'll use only short prefixes)
-    #
-    # which one do we use?
-    # That depends. For example, CelsiusTemperature is never rendered with
-    # SI prefixes, so their cost should be +Infinity
-    # 
-    # Cost of the number could be eg.:
-    #
-    #          style:                cost:
-    #          3.141                 0
-    #          31.41, 314.1          1
-    #          0.3141                2
-    #          3141.0                3
-    #          0.03141               4
-    #          31410.0               5n
-    #          0.003141              6
-    #          ...
-    #          
-    # Default cost of prefixes could be eg.
-    #
-    #          unit representation:  cost:
-    #          U                     0
-    #          dU                    +Infinity
-    #          cU                    +Infinity
-    #          mU                    1
-    #          dkU                   +Infinity
-    #          hU                    +Infinity
-    #          kU                    1
-    #          µU                    2
-    #          MU                    2
-    #          nU                    3
-    #          GU                    3
-    #          pU                    4
-    #          TU                    4
-    #          fU                    5
-    #          PU                    5
-    #          aU                    6
-    #          EU                    6
-    #
-    # Cost of exponents could be eg. their absolute value, and +1 for minus sign
-    #
-    # Same unit with two different prefixes may never be used (cost +Infinity)
-    #
-    # Afterwards, there should be cost of inconsistency. This could be implemented
-    # eg. as computing the first 10 possibilities for amount: 1 and giving them
-    # bonuses -20, -15, -11, -8, -6, -5, -4, -3, -2, -1. That would further reduce the variability of the
-    # unit representations.
-    #
-    # Commenting again upon default cost of prefixes, prefixes before second:
-    #
-    #          prefix:               cost:
-    #          s                     0
-    #          ms                    4
-    #          ns                    5
-    #          ps                    6
-    #          fs                    7
-    #          as                    9
-    #          ks                    +Infinity
-    #          Ms                    +Infinity
-    #          ...
-    #
-    # Prefixes before metre
-    #
-    #          prefix:               cost:
-    #          m                     0
-    #          mm                    2
-    #          µm                    2
-    #          nm                    3
-    #          km                    3
-    #          Mm                    +Infinity
-    #          ...
-    #          
-
-    # number, unit_presentation = choice
-
-    # return "#{amount} of #{quantity}"
-
+            number_format=default_amount_format )
     begin
-      
       un = unit.short || unit.name
-      
       if un then
         number = self.in unit
         number_ς = number_format % number
-        
         prefix = ''
         exp = 1
         # unit_presentation = prefix, unit, exp
-        
         unit_ς = SY::SPS.( [ "#{prefix}#{unit.short}" ], [ exp ] )
-        
         [ number_ς, unit_ς ].join '.'
       else
         number = amount
@@ -406,7 +298,6 @@ module SY::Magnitude
         return number_ς if unit_ς == '' || unit_ς == 'unit'
         [ number_ς, unit_ς ].join '.'
       end
-      
     rescue
       fail
       number_ς = number_format % amount
@@ -414,29 +305,9 @@ module SY::Magnitude
     end
   end
 
-  # def to_s unit=quantity.units.first, number_format='%.3g'
-  #   begin
-  #     return to_string( unit ) if unit and unit.abbreviation
-  #   rescue
-  #   end
-  #   # otherwise, use units of basic dimensions – here be the magic:
-  #   hsh = dimension.to_hash
-  #   symbols, exponents = hsh.each_with_object Hash.new do |pair, memo|
-  #     dimension_letter, exponent = pair
-  #     std_unit = SY::Dimension.basic( dimension_letter ).standard_unit
-  #     memo[ std_unit.abbreviation || std_unit.name ] = exponent
-  #   end.to_a.transpose
-  #   # assemble the superscripted product string:
-  #   sps = SY::SPS.( symbols, exponents )
-  #   # and finally, interpolate the string
-  #   "#{number_format}#{sps == '' ? '' : '.' + sps}" % amount
-  #   "#{amount}#{sps == '' ? '' : '.' + sps}"
-  # end
-  
   # Inspect string of the magnitude
   # 
   def inspect
-    puts "inspect called on a magnitude of quantity #{quantity}" if SY::DEBUG
     "#<#{çς}: #{self} >"
   end
 

data/lib/sy/mapping.rb

@@ -12,15 +12,11 @@ class SY::Measure
   class << self
     # Identity measure.
     # 
-    def identity
-      simple_scale 1
-    end
+    def identity; simple_scale 1 end
 
     # Simple scaling measure. (Eg. pounds vs kilograms)
     # 
-    def simple_scale scale
-      new( ratio: scale )
-    end
+    def simple_scale scale; new( ratio: scale ) end
 
     # Simple offset measure. (Such as °C)
     # 
@@ -89,11 +85,8 @@ class SY::Measure
   # Inverse measure.
   # 
   def inverse
-    if ratio.nil? then
-      self.class.new( r: w, w: r ) # swap closures
-    else
-      self.class.new( ratio: 1 / ratio )
-    end
+    if ratio.nil? then self.class.new( r: w, w: r ) # swap closures
+    else self.class.new( ratio: 1 / ratio ) end
   end
 
   # Measure composition (like f * g function composition).

data/lib/sy/matrix.rb

@@ -65,9 +65,7 @@ class Matrix
   def /(other)
     case other
     when Numeric
-      rows = @rows.collect {|row|
-        row.collect {|e| e / other }
-      }
+      rows = @rows.collect do |row| row.collect {|e| e / other } end
       return new_matrix rows, column_count
     when Matrix
       return self * other.inverse

data/lib/sy/measure.rb

@@ -87,11 +87,8 @@ class SY::Measure
   # Inverse measure.
   # 
   def inverse
-    if ratio.nil? then
-      self.class.new( r: w, w: r ) # swap closures
-    else
-      self.class.new( ratio: 1 / ratio )
-    end
+    if ratio.nil? then self.class.new( r: w, w: r ) # swap closures
+    else self.class.new( ratio: 1 / ratio ) end
   end
 
   # Measure composition (like f * g function composition).
@@ -101,9 +98,7 @@ class SY::Measure
       r1, r2, w1, w2 = r, other.r, w, other.w
       self.class.new( r: lambda { |ref_amnt| r1.( r2.( ref_amnt ) ) },
                       w: lambda { |amnt| w2.( w1.( amnt ) ) } )
-    else
-      self.class.new( ratio: ratio * other.ratio )
-    end
+    else self.class.new( ratio: ratio * other.ratio ) end
   end
 
   # Measure composition with inverse of another measure.

data/lib/sy/quantity.rb

@@ -5,10 +5,6 @@
 class SY::Quantity
   include NameMagic
 
-  # name_set_hook do |name, new_instance, old_name|
-  #   new_instance.protect!; name
-  # end
-
   RELATIVE_QUANTITY_NAME_SUFFIX = "±"
 
   attr_reader :MagnitudeModule, :Magnitude, :Unit
@@ -38,7 +34,6 @@ class SY::Quantity
     # 
     def standard( of: nil )
       fail ArgumentError, "Dimension (:of argument) must be given!" if of.nil?
-      puts "Constructing standard quantity of #{of} dimension" if SY::DEBUG
       return SY.Dimension( of ).standard_quantity
     end
 
@@ -64,14 +59,11 @@ class SY::Quantity
                   coerces: [],
                   coerces_to: [],
                   **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
       @dimension = SY.Dimension( of )
     else
-      puts "Composition received (#{composition})." if SY::DEBUG
       @composition = SY::Composition[ composition ]
       @dimension = @composition.dimension
     end
@@ -86,9 +78,6 @@ class SY::Quantity
       end
     coerces( *Array( coerces ) )
     Array( coerces_to ).each { |qnt| qnt.coerces self }
-    puts "Composition of the initialized instance is #{composition}." if SY::DEBUG
-    puts "Initialized instance is #{relative? ? :relative : :absolute}" if SY::DEBUG
-    puts "Initialized instance object_id is #{object_id}" if SY::DEBUG
   end
 
   # Simple quantity is one with simple composition. If nontrivial composition
@@ -193,21 +182,15 @@ class SY::Quantity
   # 
   def measure( of: nil )
     return @measure if of.nil? # act as simple getter if :of not specified
-    puts "#{self.inspect} asked about measure of #{of}" if SY::DEBUG
     return SY::Measure.identity if of == self or of == colleague
-    raise SY::DimensionError, "#{self} vs. #{of}!" unless same_dimension? of
+    fail SY::DimensionError, "#{self} vs. #{of}!" unless same_dimension? of
     return of.measure( of: of.standard ).inverse if standardish?
     m = begin
-          puts "composition is #{composition}, class #{composition.class}" if SY::DEBUG
-          measure ||
-            colleague.measure ||
-            composition.infer_measure
+          measure || colleague.measure || composition.infer_measure
         rescue NoMethodError
           fail SY::QuantityError, "Measure of #{of} by #{self} impossible!"
         end
     return m if of.standardish?
-    puts "#{of} not standardish, obtained measure relates to #{standard}, and " +
-      "it will have to be extended to #{of}." if SY::DEBUG
     return m * standard.measure( of: of )
   end
 
@@ -266,11 +249,7 @@ class SY::Quantity
   # Constructs a absolute magnitude of this quantity.
   # 
   def magnitude amount
-    puts "self.object_id is #{object_id}" if SY::DEBUG
-    puts "composition is #{composition}" if SY::DEBUG
-    puts "Constructing #{self}#magnitude with amount #{amount}." if SY::DEBUG
     Magnitude().new( of: self, amount: amount )
-      .tap { puts "#{self}#magnitude constructed!" if SY::DEBUG }
   end
 
   # Constructs a new unit of this quantity.
@@ -307,7 +286,6 @@ class SY::Quantity
   # Quantity multiplication.
   # 
   def * q2
-    puts "#{self.name} * #{q2.name}" if SY::DEBUG
     rel = [ self, q2 ].any? &:relative
     ( SY::Composition[ self => 1 ] + SY::Composition[ q2 => 1 ] )
       .to_quantity relative: rel
@@ -316,7 +294,6 @@ class SY::Quantity
   # Quantity division.
   # 
   def / q2
-    puts "#{self.name} / #{q2.name}" if SY::DEBUG
     rel = [ self, q2 ].any? &:relative?
     ( SY::Composition[ self => 1 ] - SY::Composition[ q2 => 1 ] )
       .to_quantity relative: rel
@@ -325,7 +302,6 @@ class SY::Quantity
   # Quantity raising to a number.
   # 
   def ** num
-    puts "#{self.name} ** #{num}" if SY::DEBUG
     SY::Composition[ self => num ].to_quantity relative: relative?
   end
 
@@ -344,8 +320,6 @@ class SY::Quantity
   # Returns the standard quantity for this quantity's dimension.
   # 
   def standard
-    puts "Dimension of this quantity is #{dimension}" if SY::DEBUG
-    puts "Its standard quantity is #{dimension.standard_quantity}" if SY::DEBUG
     dimension.standard_quantity
   end
 
@@ -397,21 +371,16 @@ class SY::Quantity
   # Main parametrized (ie. quantity-specific) module for magnitudes.
   # 
   def MagnitudeModule
-    puts "#{self}#MagnitudeModule called" if SY::DEBUG
     @MagnitudeModule ||= if absolute? then
                            Module.new { include SY::Magnitude }
-                         else
-                           absolute.MagnitudeModule
-                         end
+                         else absolute.MagnitudeModule end
   end
 
   # Parametrized magnitude class.
   # 
   def Magnitude
-    puts "#{self}#Magnitude called" if SY::DEBUG
     @Magnitude or
-      ( puts "Constructing #{self}@Magnitude parametrized class" if SY::DEBUG
-        mmod = MagnitudeModule()
+      ( mmod = MagnitudeModule()
         mixin = relative? ? SY::SignedMagnitude : SY::AbsoluteMagnitude
         qnt_ɴ_λ = -> { name ? "#{name}@%s" : "#<Quantity:#{object_id}@%s>" }
 
@@ -439,18 +408,15 @@ class SY::Quantity
   # Parametrized unit class.
   # 
   def Unit
-    puts "#{self}#Unit called" if SY::DEBUG
-    @Unit ||= ( puts "Constructing #{self}@Unit parametrized class" if SY::DEBUG
-                if relative? then absolute.Unit else
+    @Unit ||= ( if relative? then absolute.Unit else
                   qnt = self
                   ɴλ = -> { name ? "#{name}@%s" : "#<Quantity:#{object_id}@%s>" }
                   
-                  Class.new Magnitude() do puts "Creating @Unit class!" if SY::DEBUG
-                    include SY::Unit; puts "Included SY::Unit" if SY::DEBUG
+                  Class.new Magnitude() do
+                    include SY::Unit
                     
                     singleton_class.class_exec do
                       define_method :standard do |**nn|      # Customized #standard.
-                        puts "parametrized #{qnt}@Unit#standard called" if SY::DEBUG
                         @standard ||= new **nn.update( of: qnt )
                       end
                       
@@ -462,20 +428,15 @@ class SY::Quantity
                     unit_parametrized_subclass.namespace = SY::Unit
                   end
                 end ).tap do |u|
-      puts "@Unit constructed, its namespace is #{u.namespace}" if SY::DEBUG
-      puts "its instances are #{u.namespace.instances}" if SY::DEBUG
-      puts "its instance names are #{u.namespace.instance_names}" if SY::DEBUG
     end
   end
 
   private
 
   def construct_colleague
-    puts "#{self}#construct_colleague" if SY::DEBUG
     ɴ = name
     ʀsuffix = SY::Quantity::RELATIVE_QUANTITY_NAME_SUFFIX
     rel = relative?
-    puts "#{self} is #{rel ? 'relative' : 'absolute'}" if SY::DEBUG
     # Here, it is impossible to rely on Composition::QUANTITY_TABLE –
     # on the contrary, the table relies on Quantity#colleague.
     constr_ɴ = ->( ɴ, ʀ ) { ç.new composition: composition, ɴ: ɴ, relative: ʀ }

data/lib/sy/signed_magnitude.rb

@@ -7,31 +7,20 @@ module SY::SignedMagnitude
   # :amount argument. Amount is allowed to be negative.
   # 
   def initialize( of: nil, amount: nil )
-    puts "Constructing AbsoluteMagnitude of #{of}, amount: #{amount}" if SY::DEBUG
     fail ArgumentError, "Quantity (:of) argument missing!" if of.nil?
     @quantity = of
     @amount = case amount
-              when Numeric then
-                puts "This amount is a Numeric, using it directly" if SY::DEBUG
-                amount
-              when nil then
-                puts "This amount is 'nil', using 1 instead" if SY::DEBUG
-                1
+              when Numeric then amount
+              when nil then 1
               else
                 begin
-                  puts "Amount #{amount} will be reframed to #{@quantity}" if SY::DEBUG
                   amount.( @quantity ).amount
-                rescue NameError, NoMethodError
-                  puts "fail, amount #{amount} will be used directly" if SY::DEBUG
-                  amount
-                end
+                rescue NameError, NoMethodError; amount end
               end
   end
 
   # Addition.
   # 
-  # TODO: Figure out which module comes on the top in Quantity@Magnitude, whether Magnitude
-  # or SignedMagnitude, and therefore, whether it is necessary to adjust this method.
   def + m2
     return magnitude( amount + m2.amount ) if quantity == m2.quantity
     return quantity.absolute.magnitude( amount + m2.amount ) if
@@ -42,7 +31,6 @@ module SY::SignedMagnitude
 
   # Subtraction.
   #
-  # TODO: ditto
   def - m2
     return magnitude( amount - m2.amount ) if m2.quantity == quantity.relative
     return quantity.relative.magnitude( amount - m2.amount ) if

data/lib/sy/unit.rb

@@ -46,16 +46,12 @@ module SY::Unit
           w = SY::ExpressibleInUnits::COLLISION_WARNING
           SY::ExpressibleInUnits.included_in.each do |modul|
             im = modul.instance_methods
-            # puts ɱ, "class: #{ɱ.class}"
-            # puts im.size
-            # puts down
-            # puts im.include? down
             warn w % [down, modul] if im.include? down
             abbrev = new_instance.abbreviation
             warn w % [abbrev, modul] if im.include? abbrev
           end
         end
-        up.to_sym.tap { |sym| puts "name_set_hook #{sym}" if SY::DEBUG }
+        up.to_sym
       end
 
       # We'll now define all the prefix methods on the target (#mili, #mega...),
@@ -94,7 +90,6 @@ module SY::Unit
     # special meaning of setting the relationship of that quantity.
     # 
     def standard( of: nil, **nn )
-      puts "Constructing a standard unit of #{of}." if SY::DEBUG
       fail ArgumentError, ":of argument missing!" if of.nil?
       qnt = SY::Quantity.instance( of )
       nn.empty? ? qnt.standard_unit : qnt.new_standard_unit( **nn )
@@ -110,7 +105,7 @@ module SY::Unit
     # Full list of known unit names and unit abbreviations.
     # 
     def known_symbols
-      instance_names.map( &:downcase ) + abbreviations.keys
+      instances.names( false ).map( &:downcase ) + abbreviations.keys
     end
 
     # Parses an SPS, curring it with known unit names and abbreviations,
@@ -156,13 +151,6 @@ module SY::Unit
   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
-    # 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 nn
   end
 
@@ -269,7 +257,5 @@ module SY::Unit
 
   # String describing this class.
   # 
-  def çς
-    "Unit"
-  end
+  def çς; "Unit" end
 end # class SY::Unit

data/lib/sy/version.rb

@@ -1,7 +1,5 @@
 # coding: utf-8
 
 module SY
-  VERSION = "2.1.2"
-  DEBUG = false # debug mode switch - sometimes there are lines like
-  # puts "something" if SY::DEBUG
+  VERSION = "2.1.4"
 end

data/test/sy_test.rb

@@ -1,21 +1,21 @@
 #! /usr/bin/ruby
 # encoding: utf-8
 
-# **************************************************************************
+# *****************************************************************
 # THIS IS SPEC-STYLE TEST FILE FOR SY PHYSICAL UNITS LIBRARY
-# **************************************************************************
+# *****************************************************************
 
 # The following will load Ruby spec-style library
 require 'mathn'
 require 'minitest/autorun'
 
 # The following will load SY library
-require 'sy'
-# require './../lib/sy'
+# require 'sy'
+require './../lib/sy'
 
-# **************************************************************************
+# *****************************************************************
 # THE SPECIFICATIONS START HERE
-# **************************************************************************
+# *****************************************************************
 
 describe SY do
   it "should have basic assets" do
@@ -253,7 +253,7 @@ describe SY::Quantity, SY::Magnitude do
       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 ]
       
@@ -298,7 +298,7 @@ describe SY::Quantity, SY::Magnitude do
       
       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⁻¹
@@ -312,9 +312,10 @@ describe SY::Quantity, SY::Magnitude do
         rescue
         end
       end.must_include :M
-      SY::Unit.instance_names.must_include :MOLE
+      SY::Unit.instances.names( false ).must_include :MOLE
       # Avogadro's number is defined directly in SY
-      1.mol.quantity.object_id.must_equal SY::Nᴀ.unit.( SY::MoleAmount ).quantity.object_id
+      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 )
@@ -325,7 +326,6 @@ describe SY::Quantity, SY::Magnitude do
       # 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,
@@ -353,10 +353,17 @@ describe SY::Quantity, SY::Magnitude do
       # 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⁻¹" )
+      # Custom unit creation
+      XOXO = SY::Unit.of SY::Volume, amount: 1.l
+      assert_equal 1.l.( SY::Volume ), 1.xoxo.( SY::Volume )
 
+      # TRIPLE_POINT_OF_WATER
+      assert_equal SY::TRIPLE_POINT_OF_WATER, 0.°C.( SY::Temperature )
+      assert_equal 273.15, 0.°C.in( :K )
+      assert_equal SY::Unit.instance( :SECOND ), SY::Unit.instance( :second )
+      assert_equal SY::TRIPLE_POINT_OF_WATER, 0.°C # coercion behavior
+
+      # other tests
       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 )
@@ -367,64 +374,39 @@ 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 SY::MoleAmount.relative, 1.M.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
+                   ( 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
+    end
+
+    describe "pretty representation" do
+      it "should" do
+        ( 1.0.m / 3.s ).to_s.must_be_kind_of String
+        ( 1.0.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⁻¹" )
+      end
+    end
+
+    describe "matrix integration" do
+      it "should" do
+        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]]
-      assert_equal Matrix[[1.s]], Matrix[[1]] * 1.s
-      assert_equal Matrix[[1.s]], 1.s * Matrix[[1]]
-      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::Unit.instance( :SECOND ), SY::Unit.instance( :second )
-      assert_equal SY::TRIPLE_POINT_OF_WATER, 0.°C # coercion behavior
-      assert 2.°C.eql?( 1.°C + 1.K )
-      assert ( 1.°C - 1.°C ).eql?( 0.K )
-      assert_equal :raised, begin
-                              1.°C + 1.°C
-                              :nothing_raised
-                            rescue QuantityError
-                              :raised
-                            end
-      assert_equal :raised, begin
-                              1.K + 1.°C
-                              :nothing_raised
-                            rescue QuantityError
-                              :raised
-                            end
-      assert_equal :raised, begin
-                              1.K - 1.°C
-                              :nothing_raised
-                            rescue QuantityError
-                              :raised
-                            end
-      assert 1.mm.K⁻¹.eql?( 1.mm.°C⁻¹ )
-      assert 1.mm.K.eql?( 1.mm.°C )
-      assert_equal :raised, begin
-                              1.mm / 1.°C
-                              :nothing_raised
-                            rescue QuantityError
-                              :raised
-                            end
-      assert_equal :raised, begin
-                              1.mm * 1.°C
-                              :nothing_raised
-                            rescue QuantityError
-                              :raised
-                            end
+        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]]
+        assert_equal Matrix[[1.s]], Matrix[[1]] * 1.s
+        assert_equal Matrix[[1.s]], 1.s * Matrix[[1]]
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sy
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.1.4
 platform: ruby
 authors:
 - Boris Stitnicky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-20 00:00:00.000000000 Z
+date: 2016-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler