1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
# coding: utf-8
##
# Array
#
# ISO 15.2.12
class Array
##
# Calls the given block for each element of +self+
# and pass the respective element.
#
# ISO 15.2.12.5.10
def each(&block)
return to_enum :each unless block
idx = 0
while idx < length
block.call(self[idx])
idx += 1
end
self
end
##
# Calls the given block for each element of +self+
# and pass the index of the respective element.
#
# ISO 15.2.12.5.11
def each_index(&block)
return to_enum :each_index unless block
idx = 0
while idx < length
block.call(idx)
idx += 1
end
self
end
##
# Calls the given block for each element of +self+
# and pass the respective element. Each element will
# be replaced by the resulting values.
#
# ISO 15.2.12.5.7
def collect!(&block)
return to_enum :collect! unless block
idx = 0
len = size
while idx < len
self[idx] = block.call self[idx]
idx += 1
end
self
end
##
# Alias for collect!
#
# ISO 15.2.12.5.20
alias map! collect!
##
# Private method for Array creation.
#
# ISO 15.2.12.5.15
def initialize(size=0, obj=nil, &block)
raise TypeError, "expected Integer for 1st argument" unless size.kind_of? Integer
raise ArgumentError, "negative array size" if size < 0
self.clear
if size > 0
self[size - 1] = nil # allocate
idx = 0
while idx < size
self[idx] = (block)? block.call(idx): obj
idx += 1
end
end
self
end
def _inspect
return "[]" if self.size == 0
"["+self.map{|x|x.inspect}.join(", ")+"]"
end
##
# Return the contents of this array as a string.
#
# ISO 15.2.12.5.31 (x)
def inspect
begin
self._inspect
rescue SystemStackError
"[...]"
end
end
# ISO 15.2.12.5.32 (x)
alias to_s inspect
##
# Equality---Two arrays are equal if they contain the same number
# of elements and if each element is equal to (according to
# Object.==) the corresponding element in the other array.
#
# ISO 15.2.12.5.33 (x)
def ==(other)
other = self.__ary_eq(other)
return false if other == false
return true if other == true
len = self.size
i = 0
while i < len
return false if self[i] != other[i]
i += 1
end
return true
end
##
# Returns <code>true</code> if +self+ and _other_ are the same object,
# or are both arrays with the same content.
#
# ISO 15.2.12.5.34 (x)
def eql?(other)
other = self.__ary_eq(other)
return false if other == false
return true if other == true
len = self.size
i = 0
while i < len
return false unless self[i].eql?(other[i])
i += 1
end
return true
end
##
# Comparison---Returns an integer (-1, 0, or +1)
# if this array is less than, equal to, or greater than <i>other_ary</i>.
# Each object in each array is compared (using <=>). If any value isn't
# equal, then that inequality is the return value. If all the
# values found are equal, then the return is based on a
# comparison of the array lengths. Thus, two arrays are
# "equal" according to <code>Array#<=></code> if and only if they have
# the same length and the value of each element is equal to the
# value of the corresponding element in the other array.
#
# ISO 15.2.12.5.36 (x)
def <=>(other)
other = self.__ary_cmp(other)
return 0 if 0 == other
return nil if nil == other
len = self.size
n = other.size
len = n if len > n
i = 0
while i < len
n = (self[i] <=> other[i])
return n if n.nil? || n != 0
i += 1
end
len = self.size - other.size
if len == 0
0
elsif len > 0
1
else
-1
end
end
##
# Delete element with index +key+
def delete(key, &block)
while i = self.index(key)
self.delete_at(i)
ret = key
end
return block.call if ret.nil? && block
ret
end
# internal method to convert multi-value to single value
def __svalue
return self.first if self.size < 2
self
end
end
##
# Array is enumerable
class Array
# ISO 15.2.12.3
include Enumerable
##
# Quick sort
# a : the array to sort
# left : the beginning of sort region
# right : the end of sort region
def __sort_sub__(a, left, right, &block)
if left < right
i = left
j = right
pivot = a[i + (j - i) / 2]
while true
while ((block)? block.call(a[i], pivot): (a[i] <=> pivot)) < 0
i += 1
end
while ((block)? block.call(pivot, a[j]): (pivot <=> a[j])) < 0
j -= 1
end
break if (i >= j)
tmp = a[i]; a[i] = a[j]; a[j] = tmp;
i += 1
j -= 1
end
__sort_sub__(a, left, i-1, &block)
__sort_sub__(a, j+1, right, &block)
end
end
# private :__sort_sub__
##
# Sort all elements and replace +self+ with these
# elements.
def sort!(&block)
size = self.size
if size > 1
__sort_sub__(self, 0, size - 1, &block)
end
self
end
def sort(&block)
self.dup.sort!(&block)
end
end
|