M500 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2cb0b2efe7e5502e3cb7fac1fc3d1112cf9645ba
-  data.tar.gz: 6b2c11cb1099ab9ee98922eb937c094a71ea78e5
+  metadata.gz: f192b4fe1ad28c8858892daba9c685b3b8113700
+  data.tar.gz: 514c03db3500f1091f8bd4d363f8af27ddf65848
 SHA512:
-  metadata.gz: 19c82406a324b55fe0d46de4354fb1a083ce733d325a60f7cb52165a089790ed4c08534e7a22687f3479e5bfe06cdab84a921ea85c2e4fe2584f72ae9d4bd1da
-  data.tar.gz: c158461ff3b8c4c8b11cbf2d0c0b6b7b29b5651be8792ec4854c73d6e4b37e685115c083bac561de8a33e49adb317399abb2415d0600433c052ac89e181e58c3
+  metadata.gz: 8800d206c4ddfd7caa61defc8dba29ab5e8b8bc5b7a267916e332b214ac1c7209fb9e3d9cf51ac10c809d8b90ef0b1329eefef76c82f5c2014b461f0b69cbcdf
+  data.tar.gz: 382234406fa4e5907ca2a83f61b48ebc382d486fd8c67c42a8ddf0d9753c2a36de6385cfdcfd061f9b7d721a39df66e6a7c55dea49137ebecc19596f1d8cc305

data/lib/M500_containers.rb

@@ -0,0 +1,448 @@
+# -*- coding: utf-8 -*-
+module Enumerable
+  def to_list(klass = List, *args, &block)
+    klass.new!(self, *args, &block)
+  end
+end
+def List(a=nil,&b)
+  b ?  List.new!(a) {b} : List.new!(a)
+end
+def Set(a,&b)
+  b ?  Set.new!(a) {b} :  Set.new!(a)
+end
+def Sequence(a)
+  Sequence.new(a)
+end
+def Sigma(a,&block)
+  if a.kind_of?(Sigma)
+    a 
+  elsif a.kind_of?(Quotient)
+    Sigma.new!(a,block)
+  elsif a.kind_of?(Natural) or a.kind_of?(Counting) or a.kind_of?(Zahlen) or a.kind_of?(Fraction) or a.kind_of?(Decimal)
+  elsif
+    Sigma.new!(a.to_Q,block)
+  elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptyListClass) or a.kind_of?(NilClass)
+    a unless b
+    new(Quotinet(0,1),block)
+  elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+    a
+  end
+end
+class List
+  def List.new!(a=nil, &b)
+    b ?  new(a) {b} : new(a)
+  end
+  private_class_method :new
+  include Enumerable
+  def self.[](*ary)
+    new(ary)
+  end
+  def initialize(a, &block)
+    @hash ||= Hash.new
+    a.nil? and return
+    if block
+      with_enum(a) {|o| add(block[o]) }
+    else
+      merge(a)
+    end
+  end
+  private :initialize
+  def with_enum(enum, &block)
+    if enum.respond_to?(:each_entry)
+      enum.each_entry(&block)
+    elsif enum.respond_to?(:each)
+      enum.each(&block)
+    else
+      raise ArgumentError, "value must be enumerable"
+    end
+  end
+  private :with_enum
+  def initialize_copy(orig)
+    @hash = orig.instance_variable_get(:@hash).dup
+  end
+  def freeze
+    super
+    @hash.freeze
+    self
+  end
+  def taint
+    super
+    @hash.taint
+    self
+  end
+  def untaint
+    super
+    @hash.untaint
+    self
+  end
+  def size
+    @hash.size
+  end
+  alias length size
+  def empty?
+    @hash.empty?
+  end
+  def clear
+    @hash.clear
+    self
+  end
+  def replace(enum)
+    if enum.instance_of?(self.class)
+      @hash.replace(enum.instance_variable_get(:@hash))
+    else
+      clear
+      merge(enum)
+    end
+    self
+  end
+  def to_a
+    @hash.keys
+  end
+  def flatten_merge(set, seen = List.new!)
+    set.each { |e|
+      if e.is_a?(List)
+        if seen.include?(e_id = e.object_id)
+          raise ArgumentError, "tried to flatten recursive List"
+        end
+        seen.add(e_id)
+        flatten_merge(e, seen)
+        seen.delete(e_id)
+      else
+        add(e)
+      end
+    }
+    self
+  end
+  protected :flatten_merge
+  def flatten
+    self.class.new!.flatten_merge(self)
+  end
+  def flatten!
+    detect {|e| e.is_a?(List) }?  replace(flatten()) : nil
+  end
+  def member?(a)
+    @hash.include?(a)
+  end
+  alias include? member?
+  def contianing_list?(li)
+    li.is_a?(List) or raise ArgumentError, "value must be a List"
+    return false if size < li.size
+    li.all? {|a| include?(a) }
+  end
+  alias superset? contianing_list?
+  alias >= contianing_list?
+  def strict_contianing_list?(li)
+    li.is_a?(List) or raise ArgumentError, "value must be a List"
+    return false if size <= li.size
+    li.all? {|a| include?(a) }
+  end
+  alias proper_superset? strict_contianing_list?
+  alias > strict_contianing_list?
+  def contianed_list?(li)
+    li.is_a?(List) or raise ArgumentError, "value must be a List"
+    return false if li.size < size
+    all? {|a| li.include?(a) }
+  end
+  alias subset? contianed_list?
+  alias <= contianed_list?
+  def strictly_contianed_list?(li)
+    li.is_a?(List) or raise ArgumentError, "value must be a set"
+    return false if li.size <= size
+    all? {|a| li.include?(a) }
+  end
+  alias proper_subset? strictly_contianed_list?
+  alias <  strictly_contianed_list?
+  def each(&block)
+    block or return enum_for(__method__)
+    @hash.each_key(&block)
+    self
+  end
+  def add(a)
+    @hash[a] = true
+    self
+  end
+  alias << add
+  def add?(a)
+   include?(a) ?      nil :      add(a)
+  end
+  def delete(a)
+    @hash.delete(a)
+    self
+  end
+  def delete?(a)
+    include?(a) ?      delete(a) :      nil
+  end
+  def delete_if
+    block_given? or return enum_for(__method__)
+    to_a.each {|a| @hash.delete(a) if yield(a) }
+    self
+  end
+  def keep_if
+    block_given? or return enum_for(__method__)
+    to_a.each {|a| @hash.delete(a) unless yield(a) }
+    self
+  end
+  def collect!
+    block_given? or return enum_for(__method__)
+    li = self.class.new!
+    each {|a| li << yield(a) }
+    replace(li)
+  end
+  alias map! collect!
+  def reject!(&block)
+    block or return enum_for(__method__)
+    n = size
+    delete_if(&block)
+    size == n ? nil : self
+  end
+  def select!(&block)
+    block or return enum_for(__method__)
+    n = size
+    keep_if(&block)
+    size == n ? nil : self
+  end
+  def merge(enum)
+    enum.instance_of?(self.class) ?  @hash.update(enum.instance_variable_get(:@hash)) :       with_enum(enum) { |o| add(o) }
+    self
+  end
+  def subtract(enum)
+    with_enum(enum) {|a| delete(a) }
+    self
+  end
+  def union(a)
+    dup.merge(a)
+  end
+  alias + union 
+  alias | union 
+  def difference(a)
+    dup.subtract(a)
+  end
+  alias - difference
+  def intersection(a)
+    n = self.class.new!
+    with_enum(a) {|b| n.add(b) if include?(b) }
+    n
+  end
+  alias & intersection
+  def symetric_difference(a)
+    n = List.new!(a)
+    each {|b| if n.include?(b) then n.delete(b) else n.add(b) end }
+    n
+  end
+  alias ^ symetric_difference
+  alias sym_diff symetric_difference
+  def ==(other)
+    if self.equal?(other)
+      true
+    elsif other.instance_of?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    elsif other.is_a?(List) && self.size == other.size
+      other.all? {|a| @hash.include?(a) }
+    else
+      false
+    end
+  end
+  def hash
+    @hash.hash
+  end
+  def eql?(a)
+    return false unless a.is_a?(List)
+    @hash.eql?(a.instance_variable_get(:@hash))
+  end
+  def cartisian(a)
+    # E.g.
+    # {1, 2} × {red, white} = {(1, red), (1, white), (2, red), (2, white)}.
+    # {1, 2, green} × {red, white, green} = {(1, red), (1, white), (1, green), (2, red), (2, white), (2, green), (green, red), (green, white), (green, green)}.
+    # {1, 2} × {1, 2} = {(1, 1), (1, 2), (2, 1), (2, 2)}.
+    #Some basic properties of cartesian products:
+    #A × ∅ = ∅.
+    #A × (B ∪ C) = (A × B) ∪ (A × C).
+    #(A ∪ B) × C = (A × C) ∪ (B × C).
+    #Let A and B be finite sets. Then
+    #| A × B | = | B × A | = | A | × | B |.
+  end
+  alias * cartisian
+  alias x cartisian
+  def categorise_list
+  # e.g.:
+  #   files = List.new(Dir.glob("*.rb"))
+  #   ret = files.classify { |f| File.mtime(f).year }
+  #   p ret    # => {2010=>#<List: {"a.rb", "b.rb"}>,2011=>#<List: {"c.rb", "d.rb", "e.rb"}>,2012=>#<List: {"f.rb"}>}
+    block_given? or return enum_for(__method__)
+    h = {}
+    each { |i|
+      x = yield(i)
+      (h[x] ||= self.class.new!).add(i)
+    }
+    h
+  end
+  alias classify  categorise_list
+  def contain_by_rule(&rule)
+    rule or return enum_for(__method__)
+    if rule.arity == 2
+      require 'tsort'
+      class << dig = {}         # :nodoc:
+        include TSort
+        alias tsort_each_node each_key
+        def tsort_each_child(node, &block)
+          fetch(node).each(&block)
+        end
+      end
+      each { |u|
+        dig[u] = a = []
+        each{ |v| rule.call(u, v) and a << v }
+      }
+      li = List.new!()
+      dig.each_strongly_connected_component { |css|
+        li.add(self.class.new!(css))
+      }
+      li
+    else
+      List.new!(classify(&rule).values)
+    end
+    alias contain_by contain_by_rule
+    alias divide contain_by_rule
+  end
+  def inspect
+    ids = (Thread.current[:__inspect_key__] ||= [])
+    return sprintf('#<%s:: {...}>', self.class.name) if ids.include?(object_id)
+    begin
+      ids << object_id
+      return sprintf('#<%s:: {%s}>', self.class, to_a.inspect[1..-2])
+    ensure
+      ids.pop
+    end
+  end
+  def pretty_print(pp)
+    pp.text sprintf('#<%s:: {', self.class.name)
+    pp.nest(1) {
+      pp.seplist(self) { |o|
+        pp.pp o
+      }
+    }
+    pp.text "}>"
+  end
+  alias pp pretty_print
+  def pretty_print_cycle(pp)
+    pp.text sprintf('#<%s:: {%s}>', self.class.name, empty? ? '' : '...')
+  end
+  alias pp_cycle pretty_print_cycle
+end
+class Set < List
+  @@setup = false
+  def Set.new!(*args)
+    new(args)
+  end
+  private_class_method :new
+  private :initialize
+  def initialize(*args, &block)
+    initialize(*args, &block)
+  end
+end
+class Sigma<Numeric
+  def Sigma.new!(a,b)
+    if a.kind_of?(Sigma)
+      a 
+    elsif a.kind_of?(Quotient)
+      new(a,b)
+    elsif a.kind_of?(Natural) or a.kind_of?(Counting) or a.kind_of?(Zahlen) or a.kind_of?(Fraction) or a.kind_of?(Decimal)
+    elsif
+      new(a.to_Q,b)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptyListClass) or a.kind_of?(NilClass)
+      a unless b
+      new(Quotinet(0,1),b) if b
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      a
+    end
+  end
+  private_class_method :new
+  @@epsilon = Quotient(1,100000000000)
+  @@upsilon = "a very large number ceiling to signal change to scientific format"
+  def Sigma::epsilon(e)
+#on epsilon change flag for dirty and recalculate
+  end
+  def initialize(rat,irrat,abs=1)
+    @absolute = abs
+    @rat = rat
+    @irrat = irrat
+    @k = 1
+    @k0 = 0
+    @update_proc = proc{ ret = Quotient(0,1) ; (@k0..@k).to_a.each{|n| ret += @irrat.call(n)}; ret}
+  end
+  attr_accessor :k, :k0
+  def convergents
+    []
+  end
+  def irrational
+    true ? false : true
+  end
+  def rational?
+    true ? true : false
+  end
+  def to_a
+    convergents
+  end
+  def to_s
+    e = ""
+    e = "-" if @absolute == -1
+    # @update_proc
+  end
+  def updateApprox(&block)
+    instance_exec(&block)
+  end
+  def updateApprox1
+    @rat += @update_proc.call
+    #    instance_eval(@update_eval.call)
+  end
+  def next
+    t = @k
+    @k0 = t
+    @k += 1
+    @rat += @update_proc.call
+    t = @k
+    @k0 = t
+    @k += 1
+  end
+  private :initialize
+  attr_accessor :update_proc
+  def to_Q
+    @rat
+  end
+  def to_Dec
+    @rat.to_Dec
+  end
+end
+#class List
+#end
+class Sequence
+  def initialize
+    @index0 = 0
+    @indexn = 50
+    @func = proc{|k|
+      @a_n_minus1 = @a_n
+      @a_n *= (Quotient(1) + Quotient(Zahlen(1),Natural(k+1)))
+    }
+    @a_n_minus1 = Quotient(1)
+    @a_n = Quotient(1)
+    @sequence = List.new!#([])
+    (@index0..@indexn).to_a.each{|n|
+      @sequence << @func.call(n)}
+  end
+  def to_h
+  end
+  def to_cols
+    result = [[],[]]
+    (@index0..@indexn).to_a.each{|n|
+      result.at(0)<< n
+      result.at(1)<< @func.call(n)}
+  end
+  def to_Set
+    Set(@sequence)
+  end
+  def to_Series
+    a = Sigma(@sequence.inject(:+).to_Q) {@func}
+    a.k0 = @index0
+    a.k = @indexn
+    a
+  end
+end

data/lib/{M500.rb → m500.rb}

@@ -1,7 +1,7 @@
 #
 #   m500.rb - 
 #   	$Release Version: 0.9 $
-#       $Revision: 1.44 $
+#       $Revision: 1.45 $
 #   	by mark ingram
 #
 # --
@@ -122,12 +122,15 @@ class String
     ret = naught
     if md then
       t = 1
-      ret = Quotient(Zahlen(md[1].to_i),Natural(md[2].to_i))
+      Natural(md[2].to_i).kind_of?(EmptySetClass) ? ret = infinity : ret = Quotient(Zahlen(md[1].to_i),Natural(md[2].to_i))
     else 
-      ret = Quotient(Zahlen(md[1].to_i),Natural(md[2].to_i))
+      Natural(md[2].to_i).kind_of?(EmptySetClass) ? ret = infinity : ret = Quotient(Zahlen(md[1].to_i),Natural(md[2].to_i))
     end
     ret
   end
+  def to_ST
+    ST.new(self)
+  end
   def to_Dec
     re = /^-/
     md = re.match(self.to_s)
@@ -433,6 +436,63 @@ class Rational
     "<mn #{sgml_id}class='rational'>#{self.to_s}</mn>"
   end
 end
+class ST<Numeric
+  #class SymbolicTerm<Numeric
+  def initialize(a,b=0,c='t') # a*(c) + b
+    if a.kind_of?(String)
+      regex = /(\d+[a-z])*(\+)?(\d+)?/
+      m = regex.match(a)
+      n = /(\d+)([a-z])/.match(m[1]) if m[1]
+      @a = [n.nil? ? 0 : n[1] ? n[1] : 0, m[3] ? m[3] : 0, n.nil? ? c : n[2] ? n[2] : 0]
+    else
+      @a = [a,b,c]
+    end
+  end
+  attr_reader :a
+  def +(o)
+    if o.kind_of?(ST) then
+      "#{@a.at(0).to_i+o.a.at(0).to_i}#{@a.at(2)}+#{@a.at(1).to_i+o.a.at(1).to_i}"
+    elsif o == 0
+      self
+    else
+      a.at(0).to_i ==0 ? o : "#{@a.at(0)}#{@a.at(2)}+#{@a.at(1).to_i+o}" if o.kind_of?(Numeric)
+    end
+  end
+  def *(o)
+    if o.kind_of?(ST) then
+      "#{@a.at(0).to_i*o.a.at(0).to_i}#{@a.at(2)}+#{@a.at(1).to_i*o.a.at(1)}"
+    elsif o == 0
+      "0"
+    else
+      "#{@a.at(0).to_i*o}#{@a.at(2)}+#{@a.at(1).to_i*o}" if o.kind_of?(Numeric)
+    end
+  end
+  def -(o)
+    if o.kind_of?(ST) then
+      "#{@a.at(0).to_i-o.a.at(0).to_i}#{@a.at(2)}+#{@a.at(1)-o.a.at(1)}"
+    else
+      "#{@a.at(0)}#{@a.at(2)}+#{@a.at(1)-o}" if o.kind_of?(Numeric)
+    end
+  end
+  def /(o)
+    if o.kind_of?(ST) then
+      "#{@a.at(0).to_i/o.a.at(0).to_i}#{@a.at(2)}+#{@a.at(1).to_i/o.a.at(1)}"
+    elsif o == 0
+      "OO"
+    else
+      "#{@a.at(0).to_i/o}#{@a.at(2)}+#{@a.at(1).to_i/o}" if o.kind_of?(Numeric)
+    end
+  end
+  def coerce(o)
+    [self, o]
+  end
+  def to_s
+    "'#{@a.at(0)}#{@a.at(2)}+#{@a.at(1)}'"
+  end
+  def inspect
+    "'#{@a.at(0)}#{@a.at(2)}+#{@a.at(1)}'.to_ST"
+  end
+end
 def naught
   NaughtClass.new!
 end
@@ -1157,6 +1217,16 @@ class Counting < Natural
       Counting(x ** y)
     end
   end
+  def factorial_1
+    (Counting(1)..self).inject {|product, n| product * n }
+  end
+  def factorial
+    if self == Counting(0)
+      Counting(1)
+    else
+      self * Counting(self.to_i-1).factorial
+    end
+  end
   def % (a)
     self.to_i%(a.to_i)
   end
@@ -2483,7 +2553,17 @@ t << zz
     elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
       infinity
     else
-      ((self.to_Q) + (a.to_Q)).to_K #not irrational 
+      op = Matrix(2,4)
+      op.at_1_1 = 1
+      op.at_2_1 = 0
+      op.at_1_2 = 0
+      op.at_2_2 = 1
+      op.at_1_3 = 0
+      op.at_2_3 = 0
+      op.at_1_4 = 1
+      op.at_2_4 = 0
+      res = self.operation(op,a)
+      res.to_K
     end
   end
   def -(a)
@@ -2492,7 +2572,17 @@ t << zz
     elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
       infinity
     else
-      ((self.to_Q) - (a.to_Q)).to_K #not irrational 
+      op = Matrix(2,4)
+      op.at_1_1 = 1
+      op.at_2_1 = 0
+      op.at_1_2 = 0
+      op.at_2_2 = -1
+      op.at_1_3 = 0
+      op.at_2_3 = 0
+      op.at_1_4 = 1
+      op.at_2_4 = 0
+      res = self.operation(op,a)
+      res.to_K
     end
   end
   def * (a)
@@ -2501,7 +2591,17 @@ t << zz
     elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
       infinity
     else
-      ((self.to_Q) * (a.to_Q)).to_K
+      op = Matrix(2,4)
+      op.at_1_1 = 0
+      op.at_2_1 = 1
+      op.at_1_2 = 0
+      op.at_2_2 = 0
+      op.at_1_3 = 0
+      op.at_2_3 = 0
+      op.at_1_4 = 1
+      op.at_2_4 = 0
+      res = self.operation(op,a)
+      res.to_K
     end
   end
   def / (a)
@@ -2510,11 +2610,134 @@ t << zz
     elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
       NAN.Class.new
     elsif a.kind_of?(Kuttenbruch)
-      self * a.reciprical
+      op = Matrix(2,4)
+      op.at_1_1 = 1
+      op.at_2_1 = 0
+      op.at_1_2 = 0
+      op.at_2_2 = 0
+      op.at_1_3 = 0
+      op.at_2_3 = 0
+      op.at_1_4 = 0
+      op.at_2_4 = 1
+      res = self.operation(op,a)
+      res.to_K
     else
       (self.to_Q/a.to_Q).to_K
     end
   end
+  def operation(z,other)
+    oa = other.to_a
+    sa = self.to_a
+    a0 = nil
+    b0 = nil
+    c0 = nil
+    d0 = nil
+    e0 = nil
+    f0 = nil
+    g0 = nil
+    h0 = nil
+    a1 = nil
+    b1 = nil
+    c1 = nil
+    d1 = nil
+    e1 = nil
+    f1 = nil
+    g1 = nil
+    h1 = nil
+    x = 0
+    y =0
+    res_a = []
+    if z.kind_of?(Matrix) then
+      # check is z = Matrix(2,4)
+      a0 = z.at_1_1
+      e0 = z.at_2_1
+      b0 = z.at_1_2
+      f0 = z.at_2_2
+      c0 = z.at_1_3
+      g0 = z.at_2_3
+      d0 = z.at_1_4
+      h0 = z.at_2_4
+    else
+      p "raise an input error NOT a MATRIX 2x4"
+    end
+    tmp = 0
+    self.to_pix(a0,b0,c0,d0,e0,f0,g0,h0)
+    p "init"
+    while tmp <19 #true # size of k_res is less than epsilon
+      eggs = true
+      if e0 == 0 or f0 == 0 or g0 == 0 or h0 == 0 then
+        eggs = false if f0 == 0 
+      else # all are positive
+        p "positive"
+        #p a0.div(e0).at(0)
+        eggs = false if a0.divmod(e0).at(0) == c0.divmod(g0).at(0)
+      end
+      #p (f > 0 and e > 0 and g > 0 )?  (b/f-a/e).abs :  f,e,g
+      #p (f > 0 and e > 0 and g > 0 ) ? (c/g-a/e).abs : f,e,g
+      p "### #{eggs}"
+      if eggs then 
+        p "to the right"
+        x = sa.shift
+        a1 = (a0*x)+c0
+        b1 = (b0*x)+d0
+        c1 = a0
+        d1 = b0
+        e1 = (e0*x)+g0
+        f1 = (f0*x)+h0
+        g1 = e0
+        h1 = f0
+        self.to_pix(a1,b1,c1,d1,e1,f1,g1,h1)
+      else
+        p "downwards"
+        y = oa.shift
+        a1 = (a0*y)+b0
+        b1 = a0
+        c1 = (c0*y)+d0
+        d1 = c0
+        e1 = (e0*y)+f0
+        f1 = e0
+        g1 = (g0*y)+h0
+        h1 = g0
+        self.to_pix(a1,b1,c1,d1,e1,f1,g1,h1)
+      end
+      test = false
+      eucint = a0.divmod(e0).at(0) if e0 > 0
+      if y > 1 and x > 1 and f0 > 0 and g0 > 0 and h0>0
+        test = eucint == b0.divmod(f0).at(0) and eucint == c0.divmod(g0).at(0) and eucint == d0.divmod(h0).at(0) and eucint > 0 
+      end
+      if test then
+        p "here"
+        res_a << eucint
+        a0 = e1
+        b0 = f1
+        c0 = g1
+        d0 = h1
+        e0 = a1-(e1*eucint)
+        f0 = b1-(f1*eucint)
+        g0 = c1-(g1*eucint)
+        h0 = d1-(h1*eucint)
+        a1 = a0
+        b1 = b0
+        c1 = c0
+        d1 = d0
+        e1 = e0
+        f1 = f0
+        g1 = g0
+        h1 = h0
+        self.to_pix(a1,b1,c1,d1,e1,f1,g1,h1)
+      end
+      tmp += 1
+      a0 = a1
+      b0 = b1
+      c0 = c1
+      d0 = d1
+      e0 = e1
+      f0 = f1
+      g0 = g1
+      h0 = h1
+    end
+    res_a
+  end
   def ** (a)
     self.to_f ** a.to_f
   end
@@ -2648,6 +2871,7 @@ class Real < Numeric
 end
 class Matrix
   include SGML
+  include Comparable
   def to_sgml
     tmp =     "<mn #{sgml_id}class='matrix'><mrow><mo>(</mo><mtable>"
     (1..@nsize).to_a.each{|a|
@@ -2745,6 +2969,9 @@ attr_accessor :msize, :nsize
   def og!
     @tr =  false
   end
+  def size
+    self.msize * self.nsize
+  end
   def +(nm)
     a = ""
     if  not(nm.is_tr? or @tr) then
@@ -2781,14 +3008,14 @@ attr_accessor :msize, :nsize
     end
     return a
   end
-  def *(nm)
+def -(nm)
     a = ""
     if  not(nm.is_tr? or @tr) then
       if nm.msize == @msize and nm.nsize == @nsize then
         a= Matrix(@nsize, @msize)
         (1..@nsize).to_a.each{|x|
           (1..@msize).to_a.each{|y|
-            eval("a.at_#{x}_#{y}= self.at_#{x}_#{y} * nm.at_#{x}_#{y}")
+            eval("a.at_#{x}_#{y}= self.at_#{x}_#{y} - nm.at_#{x}_#{y}")
           }
         }
       else
@@ -2798,7 +3025,7 @@ attr_accessor :msize, :nsize
         a= Matrix(@nsize, @msize)
         (1..@nsize).to_a.each{|x|
           (1..@msize).to_a.each{|y|
-            eval("a.at_#{x}_#{y}= self.at_#{x}_#{y} * nm.tr_#{x}_#{y}")
+            eval("a.at_#{x}_#{y}= self.at_#{x}_#{y} - nm.tr_#{x}_#{y}")
           }
         }
       else
@@ -2808,7 +3035,7 @@ attr_accessor :msize, :nsize
         a= Matrix(@msize, @nsize)
         (1..@msize).to_a.each{|x|
           (1..@nsize).to_a.each{|y|
-            eval("a.at_#{x}_#{y}= self.tr_#{x}_#{y} + nm.at_#{x}_#{y}")
+            eval("a.at_#{x}_#{y}= self.tr_#{x}_#{y} - nm.at_#{x}_#{y}")
           }
         }
       else
@@ -2817,6 +3044,111 @@ attr_accessor :msize, :nsize
     end
     return a
   end
+ def *(nm)
+    a = nil
+    cmd = ""
+    if nm.kind_of?(Matrix) then
+      if  not(nm.is_tr? or @tr) then
+        if nm.msize == @msize and nm.nsize == @nsize then
+          a= Matrix(@nsize, @msize)
+          (1..@nsize).to_a.each{|x|
+            (1..@msize).to_a.each{|y|
+              cmd += "a.at_#{x}_#{y}= self.at_#{x}_#{y} * nm.at_#{x}_#{y};"
+            }
+          }
+        else
+        end
+      elsif nm.is_tr? and not @tr then
+        if nm.msize == @nsize and nm.nsize == @msize then
+          a= Matrix(@nsize, @msize)
+          (1..@nsize).to_a.each{|x|
+            (1..@msize).to_a.each{|y|
+              cmd += "a.at_#{x}_#{y}= self.at_#{x}_#{y} * nm.tr_#{x}_#{y};"
+            }
+          }
+        else
+        end
+      elsif not nm.is_tr? and @tr then
+        if nm.msize == @nsize and nm.nsize == @msize then
+          a= Matrix(@msize, @nsize)
+          (1..@msize).to_a.each{|x|
+            (1..@nsize).to_a.each{|y|
+              cmd += "a.at_#{x}_#{y}= self.tr_#{x}_#{y} + nm.at_#{x}_#{y};"
+            }
+          }
+        else
+        end
+      else
+      end
+    elsif nm.kind_of?(Numeric)
+      a= Matrix(@msize, @nsize)
+      (1..@msize).to_a.each{|x|
+        (1..@nsize).to_a.each{|y|
+          cmd += "a.at_#{x}_#{y}= self.at_#{x}_#{y} * nm;"
+        }
+      }
+    end
+    eval(cmd)
+    return a
+  end
+  def <=>(o)
+    r = -1 if self.size < o.size
+    r = 0 if self.size == o.size
+    r = 1 if self.size > o.size
+    r
+  end
+  def ==(o)
+    t = []
+    if self.msize == o.msize and self.nsize == o.nsize then
+      m = (1..self.msize)
+      n = (1..self.nsize)
+      for x in m
+        for y in n
+          self.send("at_#{x}_#{y}") == o.send("at_#{x}_#{y}") ? t << true : t << false
+        end
+      end
+    end
+    t.include?(false) ? false : true
+  end
+  def each
+    m = (1..self.msize)
+    n = (1..self.nsize)
+    for x in m
+      for y in n
+        #p  ".at_#{x}_#{y}"
+        yield self.send("at_#{x}_#{y}")
+      end
+    end
+  end
+  def column_vectors
+    #each_m
+  end
+  def row_vectors
+    r = []
+    # self.each_n{||}
+  end
+  def each_m
+    m = (1..self.msize)
+    n = (1..self.nsize)
+    for x in m
+      r = Matrix(1,self.nsize)
+      for y in n
+        r.send("at_1_#{y}=",self.send("at_#{x}_#{y}"))
+      end
+      yield r
+    end  
+  end
+  def each_n
+    m = (1..self.msize)
+    n = (1..self.nsize)
+    for x in n
+      r = Matrix(self.msize,1)
+      for y in m
+        r.send("at_#{y}_1=",self.send("at_#{y}_#{x}"))
+      end
+      yield r
+    end  
+  end
   def to_s
     t = ""
     (1..@nsize).to_a.each{|a|
@@ -2987,16 +3319,29 @@ tu +=  "\na\n}"
     return a
   end
   def to_s
-    tmp = "{"
-    c = 0
-    indicies.each{|q|
-      p = "at#{q}"
-      tmp << "'#{p}' => '#{send(p)}'" if c == 0
-      tmp << ",'#{p}' => '#{send(p)}'" unless c==0 
-      c += 1    
+    t = ""
+    page = 4
+    (1..@order.at(0)).to_a.each{|a|
+      t << "|"
+      (1..@order.at(1)).to_a.each{|b|
+        t << eval("at_#{a}_#{b}_#{page}").to_s
+        unless b == @order.at(1) then t << 9 end
+      }
+      t << "|"
+      unless a == @order.at(1) then t << 10 end
     }
-    tmp << "}"
-    return tmp
+    t
+  end
+  def to_csv
+    t = ""
+    (1..@order.a(0)).to_a.each{|a|
+      (1..@order.at(1)).to_a.each{|b|
+        t << eval("at_#{a}_#{b}_1").to_s
+        unless b == @order.at(1) then  t << 44 end
+      }
+      t << 10
+    }
+    t
   end
   def to_sgml
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: M500
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors:
 - mark ingram
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-24 00:00:00.000000000 Z
+date: 2015-02-16 00:00:00.000000000 Z
 dependencies: []
 description: ''
 email:
@@ -17,7 +17,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/M500.rb
+- lib/M500_containers.rb
+- lib/m500.rb
 homepage: 
 licenses:
 - Ruby