Class: CAIterator

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/carray/base/iterator.rb

Overview

carray/base/iterator.rb

This file is part of Ruby/CArray extension library.
You can redistribute it and/or modify it under the terms of
the Ruby Licence.

Copyright (C) 2005 Hiroki Motoyoshi

Direct Known Subclasses

CAClassIterator

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.define_calculate_method(data_type, name) ⇒ Object 



64
65
66
67
68
69
 
# File 'lib/carray/base/iterator.rb', line 64

def self.define_calculate_method (data_type, name)
  define_method(name) { |*args|
    _data_type = data_type || self.reference.data_type
    self.calculate(_data_type, name, *args) 
  }
end

.define_evaluate_method(name) ⇒ Object 



17
18
19
20
21
 
# File 'lib/carray/base/iterator.rb', line 17

def self.define_evaluate_method (name)
  define_method(name) { |*args|
    self.evaluate(name, *args) 
  }
end

.define_filter_method(data_type, name) ⇒ Object 



40
41
42
43
44
45
 
# File 'lib/carray/base/iterator.rb', line 40

def self.define_filter_method (data_type, name)
  define_method(name) { |*args|
    _data_type = data_type || self.reference.data_type
    self.filter(_data_type, name, *args) 
  }
end

Instance Method Details

#[](*idx) ⇒ Object 



143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/carray/base/iterator.rb', line 143

def [] (*idx)
  if idx.any?{|x| x.is_a?(Symbol) }
    return ca[*idx]
  else
    case idx.size
    when 0
      return clone
    when 1
      return kernel_at_addr(idx[0])
    else
      return kernel_at_index(idx)
    end
  end
end

#[]=(*idx) ⇒ Object 



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/carray/base/iterator.rb', line 158

def []= (*idx)
  val = idx.pop
  if idx.any?{|x| x.is_a?(Symbol) }
    ca[*idx] = [val]
  else
    case idx.size
    when 0
      asign!(val)
    when 1
      kernel_at_addr(idx[0])[] = val
    else
      kernel_at_index(idx)[] = val
    end
  end
end

#asign!(val) ⇒ Object 



136
137
138
139
140
141
 
# File 'lib/carray/base/iterator.rb', line 136

def asign! (val)
  each do |elem|
    elem[] = val
  end
  return self
end

#ca ⇒ Object 



118
119
120
121
 
# File 'lib/carray/base/iterator.rb', line 118

def ca
  @iterary ||= CAIteratorArray.new(self)
  return @iterary
end

#convert(data_type, options = {}) ⇒ Object 



183
184
185
186
187
188
189
190
 
# File 'lib/carray/base/iterator.rb', line 183

def convert (data_type, options={})
  out = prepare_output(data_type, options)
  out.map_addr!{ |addr|
    blk = kernel_at_addr(addr)
    yield(blk.clone)
  }
  return out
end

#each ⇒ Object 



192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/carray/base/iterator.rb', line 192

def each ()
  retval = nil
  if self.class::UNIFORM_KERNEL
    reference.attach! {
      blk = kernel_at_addr(0)
      elements.times do |addr|
        kernel_move_to_addr(addr, blk)
        retval = yield(blk.clone)
      end
    }
  else
    elements.times do |addr|
      retval = yield(kernel_at_addr(addr).clone)
    end
  end
  return retval
end

#each_with_addr ⇒ Object 



210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/carray/base/iterator.rb', line 210

def each_with_addr ()
  retval = nil
  if self.class::UNIFORM_KERNEL
    reference.attach! {
      elements.times do |addr|
        blk = kernel_at_addr(addr)
        retval = yield(blk.clone, addr)
      end
    }
  else
    elements.times do |addr|
      retval = yield(kernel_at_addr(addr).clone, addr)
    end
  end
  return retval
end

#each_with_index ⇒ Object 



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/carray/base/iterator.rb', line 227

def each_with_index ()
  retval = nil
  if self.class::UNIFORM_KERNEL
    reference.attach! {
      CArray.each_index(*dim) do |*idx|
        blk = kernel_at_index(idx)
        retval = yield(blk.clone, idx)
      end
    }
  else
    CArray.each_index(*dim) do |*idx|
      retval = yield(kernel_at_index(idx).clone, idx)
    end
  end
  return retval
end

#inject(*argv) ⇒ Object 



244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
 
# File 'lib/carray/base/iterator.rb', line 244

def inject (*argv)
  case argv.size
  when 0
    memo = nil
    each_with_addr do |val, addr|
      if addr == 0
        memo = val
      else
        memo = yield(memo, val)
      end
    end
    return memo
  when 1
    memo = argv.first
    each do |val|
      memo = yield(memo, val)
    end
    return memo
  else
    raise "invalid number of arguments (#{argv.size} for 0 or 1)"
  end
end

#pick(*idx) ⇒ Object 



127
128
129
130
131
132
133
134
 
# File 'lib/carray/base/iterator.rb', line 127

def pick (*idx)
  out = prepare_output(reference.data_type, :bytes=>reference.bytes)
  elements.times do |addr|
    blk = kernel_at_addr(addr)
    out[addr] = blk[*idx]
  end
  return out
end

#put(*idx) ⇒ Object 



174
175
176
177
178
179
180
181
 
# File 'lib/carray/base/iterator.rb', line 174

def put (*idx)
  val = idx.pop
  elements.times do |addr|
    blk = kernel_at_addr(addr)
    blk[*idx] = val
  end
  return self
end

#sort_by(&block) ⇒ Object 



273
274
275
276
277
278
279
280
 
# File 'lib/carray/base/iterator.rb', line 273

def sort_by (&block)
  out = reference.template
  idx = ca.convert(:object, &block).sort_addr
  ca[idx].each_with_addr do |blk, i|
    kernel_at_addr(i, out)[] = blk
  end
  return out
end

#sort_by!(&block) ⇒ Object 



267
268
269
270
271
 
# File 'lib/carray/base/iterator.rb', line 267

def sort_by! (&block)
  ia = self.ca
  ia[] = ia.to_a.sort_by(&block).map{|x| x.to_ca }
  return reference
end

#sort_with(&block) ⇒ Object 



282
283
284
285
286
287
288
289
 
# File 'lib/carray/base/iterator.rb', line 282

def sort_with (&block)
  out = reference.template
  idx = CA.sort_addr(*yield(self))
  ca[idx].each_with_addr do |blk, i|
    kernel_at_addr(i, out)[] = blk
  end
  return out
end

#to_a ⇒ Object 



123
124
125
 
# File 'lib/carray/base/iterator.rb', line 123

def to_a
  return ca.to_a
end