Ruby Study 5 : Hash, Martix, Vector and Set class

h1 = Hash.new()
print(h1.methods.sort)

[:!, :!=, :!~, :<=>, :==, :===, :=~, :[], :[]=, :__id__, :__send__, :all?, :any?, :assoc, :chunk, :class, :clear, :clone, :collect, :collect_concat, :compare_by_identity, :compare_by_identity?, :count, :cycle, :default, :default=, :default_proc, :default_proc=, :define_singleton_method, :delete, :delete_if, :detect, :display, :drop, :drop_while, :dup, :each, :each_cons, :each_entry, :each_key, :each_pair, :each_slice, :each_value, :each_with_index, :each_with_object, :empty?, :entries, :enum_for, :eql?, :equal?, :extend, :fetch, :find, :find_all, :find_index, :first, :flat_map, :flatten, :freeze, :frozen?, :grep, :group_by, :has_key?, :has_value?, :hash, :include?, :index, :initialize_clone, :initialize_dup, :inject, :inspect, :instance_eval, :instance_exec, :instance_of?, :instance_variable_defined?, :instance_variable_get, :instance_variable_set, :instance_variables, :invert, :is_a?, :keep_if, :key, :key?, :keys, :kind_of?, :length, :map, :max, :max_by, :member?, :merge, :merge!, :method, :methods, :min, :min_by, :minmax, :minmax_by, :nil?, :none?, :object_id, :one?, :partition, :private_methods, :protected_methods, :public_method, :public_methods, :public_send, :rassoc, :reduce, :rehash, :reject, :reject!, :replace, :respond_to?, :respond_to_missing?, :reverse_each, :select, :select!, :send, :shift, :singleton_class, :singleton_methods, :size, :slice_before, :sort, :sort_by, :store, :taint, :tainted?, :take, :take_while, :tap, :to_a, :to_enum, :to_hash, :to_s, :trust, :untaint, :untrust, :untrusted?, :update, :value?, :values, :values_at, :zip]

h1 = {
    'room1'=>'The Treasure Room',
    'room2'=>'The Throne Room',
    'loc1'=>'A Forest Glade',
    'loc2'=>'A Mountain Stream' 
    }
    
h2 = {1=>'one', 2=>'two', 3=> 'three'}
h1['room1'] = 'You have wandered into a dark room'
h1.delete('loc2')
p(h1)
#=> {"room1"=>"You have wandered into a dark room",
#=> "room2"=>"The Throne Room", 
#=> "loc1"=>"A Forest Glade"}
p(h1.has_key?('loc2')) #=> false
p(h2.has_value?("two")) #=>true
p(h2.invert)         #=> {"one"=>1, "two"=>2, "three"=>3}
p(h2.keys)            #=>[1, 2, 3]
p(h2.values)        #=>["one", "two", "three"]

{"room1"=>"You have wandered into a dark room", "room2"=>"The Throne Room", "loc1"=>"A Forest Glade"}
false
true
{"one"=>1, "two"=>2, "three"=>3}
[1, 2, 3]
["one", "two", "three"]

h1 = {
    'room1'=>'The Treasure Room',
    'room2'=>'The Throne Room',
    'loc1'=>'A Forest Glade',
    'loc2'=>'A Mountain Stream' 
    }
p h1.to_a
p h1.keys
p h1.values

[["room1", "The Treasure Room"], ["room2", "The Throne Room"], ["loc1", "A Forest Glade"], ["loc2", "A Mountain Stream"]]
["room1", "room2", "loc1", "loc2"]
["The Treasure Room", "The Throne Room", "A Forest Glade", "A Mountain Stream"]

h1 = {'key1'=>'val1', 'key2'=>'val2', 'key3'=>'val3', 'key4'=>'val4'}
h2 = {'key1'=>'val1', 'KEY_TWO'=>'val2', 'key3'=>'VALUE_3', 'key4'=>'val4'}
p( h1.keys & h2.keys )             # set intersection (keys)
#=> ["key1", "key3", "key4"]
p( h1.values & h2.values )        # set intersection (values)
#=> ["val1", "val2", "val4"]    
p( h1.keys+h2.keys )            # concatenation
#=> [ "key1", "key2", "key3", "key4", "key1", "key3", "key4", "KEY_TWO"]
p( h1.values-h2.values )            # difference
#=> ["val3"]
p( (h1.keys << h2.keys)  ) # append
#=> ["key1", "key2", "key3", "key4", ["key1", "key3", "key4", "KEY_TWO"]]
p( (h1.keys << h2.keys).flatten.reverse  ) # 'un-nest' arrays and reverse
#=> ["KEY_TWO", "key4", "key3", "key1", "key4", "key3", "key2", "key1"]

require "Matrix"    # This is essential!
m1 = Matrix[ [1,2,3,4],
            [5,6,7,8],
            [9,10,11,12],
            [13,14,15,16]  ]
m2 = Matrix[ [10,20,30,40],
            [50,60,70,80],
            [90,100,110,120],
            [130,140,150,160]  ]
m3 = m1+m2
p(m3)

Matrix[[11, 22, 33, 44], [55, 66, 77, 88], [99, 110, 121, 132], [143, 154, 165, 176]]

v1 = Vector[1,2,3,4,5]
v2 = Vector[6,7,8,9,10]
m1 = Matrix.columns([v1,v2]) # 按列组织成Matrix
p( m1 )
m2 = Matrix.rows([v1,v2])  # 按行组装成Matrix
p( m2 )

Matrix[[1, 6], [2, 7], [3, 8], [4, 9], [5, 10]]
Matrix[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]

require "Set"
s1 = Set.new([nil,nil,1,1,2,2,3,4,5,0,0])
p s1

#<Set: {nil, 1, 2, 3, 4, 5, 0}>

[:!, :!=, :!~, :&, :+, :-, :<<, :<=>, :==, :===, :=~, :^, :__id__, :__send__, :add, :add?, :all?, :any?, :chunk, :class, :classify, :clear, :clone, :collect, :collect!, :collect_concat, :count, :cycle, :define_singleton_method, :delete, :delete?, :delete_if, :detect, :difference, :display, :divide, :drop, :drop_while, :dup, :each, :each_cons, :each_entry, :each_slice, :each_with_index, :each_with_object, :empty?, :entries, :enum_for, :eql?, :equal?, :extend, :find, :find_all, :find_index, :first, :flat_map, :flatten, :flatten!, :flatten_merge, :freeze, :frozen?, :grep, :group_by, :hash, :include?, :initialize_clone, :initialize_dup, :inject, :inspect, :instance_eval, :instance_exec, :instance_of?, :instance_variable_defined?, :instance_variable_get, :instance_variable_set, :instance_variables, :intersection, :is_a?, :keep_if, :kind_of?, :length, :map, :map!, :max, :max_by, :member?, :merge, :method, :methods, :min, :min_by, :minmax, :minmax_by, :nil?, :none?, :object_id, :one?, :partition, :pretty_print, :pretty_print_cycle, :private_methods, :proper_subset?, :proper_superset?, :protected_methods, :public_method, :public_methods, :public_send, :reduce, :reject, :reject!, :replace, :respond_to?, :respond_to_missing?, :reverse_each, :select, :select!, :send, :singleton_class, :singleton_methods, :size, :slice_before, :sort, :sort_by, :subset?, :subtract, :superset?, :taint, :tainted?, :take, :take_while, :tap, :to_a, :to_enum, :to_s, :to_set, :trust, :union, :untaint, :untrust, :untrusted?, :zip, :|]