Module: RubyHDL::High::SEnumerable

Defined in:
lib/HDLRuby/std/sequencer_sw.rb

Overview

Module adding functionalities to object including the +seach+ method.

Instance Method Summary collapse

Instance Method Details

#sall?(arg = nil, &ruby_block) ⇒ Boolean

Tell if all the elements respect a given criterion given either as +arg+ or as block.

Returns:

  • (Boolean) 


276
277
278
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 276

def sall?(arg = nil,&ruby_block)
  self.seach.sall?(arg,&ruby_block)
end

#sany?(arg = nil, &ruby_block) ⇒ Boolean

Tell if any of the elements respects a given criterion given either as +arg+ or as block.

Returns:

  • (Boolean) 


282
283
284
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 282

def sany?(arg = nil,&ruby_block)
  self.seach.sany?(arg,&ruby_block)
end

#schain(arg) ⇒ Object

Returns an SEnumerator generated from current enumerable and +arg+



287
288
289
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 287

def schain(arg)
  self.seach.schain(arg)
end

#schunk(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby chunk. NOTE: to do, or may be not.



293
294
295
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 293

def schunk(*args,&ruby_block)
  raise "schunk is not supported yet."
end

#schunk_while(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby chunk_while. NOTE: to do, or may be not.



299
300
301
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 299

def schunk_while(*args,&ruby_block)
  raise "schunk_while is not supported yet."
end

#scompact ⇒ Object

HW implementation of the Ruby compact, but remove 0 values instead on nil (since nil that does not have any meaning in HW).



320
321
322
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 320

def scompact
  self.seach.scompact(&ruby_block)
end

#scount(obj = nil, &ruby_block) ⇒ Object

WH implementation of the Ruby count.



326
327
328
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 326

def scount(obj = nil, &ruby_block)
  self.seach.scount(obj,&ruby_block)
end

#scycle(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby cycle.



331
332
333
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 331

def scycle(n = nil,&ruby_block)
  self.seach.scycle(n,&ruby_block)
end

#sdrop(n) ⇒ Object

HW implementation of the Ruby drop.



343
344
345
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 343

def sdrop(n)
  self.seach.sdrop(n)
end

#sdrop_while(&ruby_block) ⇒ Object

HW implementation of the Ruby drop_while.



348
349
350
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 348

def sdrop_while(&ruby_block)
  self.seach.sdrop_while(n)
end

#seach_cons(n, &ruby_block) ⇒ Object

HW implementation of the Ruby each_cons



353
354
355
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 353

def seach_cons(n,&ruby_block)
  self.seach.seach_cons(n,&ruby_block)
end

#seach_entry(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby each_entry. NOTE: to do, or may be not.



359
360
361
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 359

def seach_entry(*args,&ruby_block)
  raise "seach_entry is not supported yet."
end

#seach_nexts(num, &ruby_block) ⇒ Object

Iterator on the +num+ next elements. NOTE:

  • Stop iteration when the end of the range is reached or when there are no elements left
  • This is not a method from Ruby but one specific for hardware where creating a array is very expensive.


573
574
575
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 573

def seach_nexts(num,&ruby_block)
  return self.seach.snexts(num,&ruby_block)
end

#seach_range(rng, &ruby_block) ⇒ Object

Iterator on each of the elements in range +rng+. NOTE:

  • Stop iteration when the end of the range is reached or when there are no elements left
  • This is not a method from Ruby but one specific for hardware where creating a array is very expensive.


270
271
272
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 270

def seach_range(rng,&ruby_block)
  self.seach.seach_range(rng,&ruby_block)
end

#seach_slice(n, &ruby_block) ⇒ Object

HW implementation of the Ruby each_slice



364
365
366
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 364

def seach_slice(n,&ruby_block)
  self.seach.seach_slice(n,&ruby_block)
end

#seach_with_index(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby each_with_index.



369
370
371
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 369

def seach_with_index(*args,&ruby_block)
  self.seach.swith_index(*args,&ruby_block)
end

#seach_with_object(obj, &ruby_block) ⇒ Object

HW implementation of the Ruby each_with_object.



374
375
376
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 374

def seach_with_object(obj,&ruby_block)
  self.seach.swith_object(obj,&ruby_block)
end

#sfind(if_none_proc, &ruby_block) ⇒ Object

HW implementation of the Ruby find. NOTE: contrary to Ruby, if_none_proc is mandatory since there is no nil in HW. Moreover, the argument can also be a value.



338
339
340
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 338

def sfind(if_none_proc, &ruby_block)
  self.seach.sfind(if_non_proc,&ruby_block)
end

#sfind_index(obj = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby find_index.



389
390
391
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 389

def sfind_index(obj = nil, &ruby_block)
  self.seach.sfind_index(obj,&ruby_block)
end

#sfirst(n = 1) ⇒ Object

HW implementation of the Ruby first.



394
395
396
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 394

def sfirst(n=1)
  self.seach.sfirst(n)
end

#sflat_map(&ruby_block) ⇒ Object

HW implementation of the Ruby flat_map. NOTE: actually due to the way HDLRuby handles vectors, should work like smap



314
315
316
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 314

def sflat_map(&ruby_block)
  self.seach.sflat_map(&ruby_block)
end

#sgrep(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby grep. NOTE: to do, or may be not.



400
401
402
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 400

def sgrep(*args,&ruby_block)
  raise "sgrep is not supported yet."
end

#sgrep_v(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby grep_v. NOTE: to do, or may be not.



406
407
408
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 406

def sgrep_v(*args,&ruby_block)
  raise "sgrep_v is not supported yet."
end

#sgroup_by(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby group_by. NOTE: to do, or may be not.



412
413
414
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 412

def sgroup_by(*args,&ruby_block)
  raise "sgroup_by is not supported yet."
end

#sinclude?(obj) ⇒ Boolean

HW implementation of the Ruby include?

Returns:

  • (Boolean) 


417
418
419
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 417

def sinclude?(obj)
  return self.seach.sinclude?(obj)
end

#sinject(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby inject.



422
423
424
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 422

def sinject(*args,&ruby_block)
  return self.seach.sinject(*args,&ruby_block)
end

#slazy(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby lazy. NOTE: to do, or may be not.



433
434
435
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 433

def slazy(*args,&ruby_block)
  raise "slazy is not supported yet."
end

#smap(&ruby_block) ⇒ Object

Returns a vector containing the execution result of the given block on each element. If no block is given, return an SEnumerator. NOTE: be carful that the resulting vector can become huge if there are many element.



307
308
309
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 307

def smap(&ruby_block)
  self.seach.smap(&ruby_block)
end

#smax(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby max.



438
439
440
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 438

def smax(n = nil, &ruby_block)
  return self.seach.smax(n,&ruby_block)
end

#smax_by(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby max_by.



443
444
445
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 443

def smax_by(n = nil, &ruby_block)
  return self.seach.smax_by(n,&ruby_block)
end

#smin(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby min.



448
449
450
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 448

def smin(n = nil, &ruby_block)
  return self.seach.smin(n,&ruby_block)
end

#smin_by(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby min_by.



453
454
455
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 453

def smin_by(n = nil, &ruby_block)
  return self.seach.smin_by(n,&ruby_block)
end

#sminmax(&ruby_block) ⇒ Object

HW implementation of the Ruby minmax.



458
459
460
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 458

def sminmax(&ruby_block)
  return self.seach.sminmax(&ruby_block)
end

#sminmax_by(&ruby_block) ⇒ Object

HW implementation of the Ruby minmax_by.



463
464
465
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 463

def sminmax_by(&ruby_block)
  return self.seach.sminmax_by(&ruby_block)
end

#snone?(arg = nil, &ruby_block) ⇒ Boolean

Tell if none of the elements respects a given criterion given either as +arg+ or as block.

Returns:

  • (Boolean) 


469
470
471
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 469

def snone?(arg = nil,&ruby_block)
  return self.seach.snone?(arg,&ruby_block)
end

#sone?(arg = nil, &ruby_block) ⇒ Boolean

Tell if one and only one of the elements respects a given criterion given either as +arg+ or as block.

Returns:

  • (Boolean) 


475
476
477
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 475

def sone?(arg = nil,&ruby_block)
  return self.seach.sone?(arg,&ruby_block)
end

#spartition(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby partition. NOTE: to do, or may be not.



481
482
483
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 481

def spartition(*args,&ruby_block)
  raise "spartition is not supported yet."
end

#sreduce(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby reduce.



427
428
429
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 427

def sreduce(*args,&ruby_block)
  return self.seach.sreduce(*args,&ruby_block)
end

#sreject(&ruby_block) ⇒ Object

HW implementatiob of the Ruby reject.



486
487
488
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 486

def sreject(&ruby_block)
  return self.seach.sreject(&ruby_block)
end

#sreverse_each(*args, &ruby_block) ⇒ Object

HW implementatiob of the Ruby reverse_each.



491
492
493
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 491

def sreverse_each(*args,&ruby_block)
  return self.seach.sreverse_each(*args,&ruby_block)
end

#sselect(&ruby_block) ⇒ Object

HW implementation of the Ruby select.



384
385
386
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 384

def sselect(&ruby_block)
  self.seach.sselect(&ruby_block)
end

#sslice_after(pattern = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby slice_after. NOTE: to do, or may be not.



497
498
499
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 497

def sslice_after(pattern = nil,&ruby_block)
  raise "sslice_after is not supported yet."
end

#sslice_before(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby slice_before. NOTE: to do, or may be not.



503
504
505
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 503

def sslice_before(*args,&ruby_block)
  raise "sslice_before is not supported yet."
end

#sslice_when(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby slice_when. NOTE: to do, or may be not.



509
510
511
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 509

def sslice_when(*args,&ruby_block)
  raise "sslice_before is not supported yet."
end

#ssort(&ruby_block) ⇒ Object

HW implementation of the Ruby sort.



519
520
521
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 519

def ssort(&ruby_block)
  return self.seach.ssort(&ruby_block)
end

#ssort_by(&ruby_block) ⇒ Object

HW implementation of the Ruby sort.



524
525
526
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 524

def ssort_by(&ruby_block)
  return self.seach.ssort_by(&ruby_block)
end

#ssort_merge(arI, arO, first, middle, last, &ruby_block) ⇒ Object

Merge two arrays in order, for ssort only.



514
515
516
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 514

def ssort_merge(arI, arO, first, middle, last, &ruby_block)
  return self.seach.ssort_merge(arI,arO,first,middle,last,&ruby_block)
end

#ssum(initial_value = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby sum.



529
530
531
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 529

def ssum(initial_value = nil,&ruby_block)
  return self.seach.ssum(initial_value,&ruby_block)
end

#stake(n) ⇒ Object

The HW implementation of the Ruby take.



534
535
536
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 534

def stake(n)
  return self.seach.stake(n)
end

#stake_while(&ruby_block) ⇒ Object

The HW implementation of the Ruby take_while.



539
540
541
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 539

def stake_while(&ruby_block)
  return self.seach.stake_while(&ruby_block)
end

#stally(h = nil) ⇒ Object

HW implementation of the Ruby tally. NOTE: to do, or may be not.



545
546
547
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 545

def stally(h = nil)
  raise "stally is not supported yet."
end

#sto_a ⇒ Object

HW implementation of the Ruby to_a.



379
380
381
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 379

def sto_a
  self.seach.sto_a
end

#sto_h(h = nil) ⇒ Object

HW implementation of the Ruby to_h. NOTE: to do, or may be not.



551
552
553
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 551

def sto_h(h = nil)
  raise "sto_h is not supported yet."
end

#suniq(&ruby_block) ⇒ Object

HW implementation of the Ruby uniq.



556
557
558
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 556

def suniq(&ruby_block)
  return self.seach.suniq(&ruby_block)
end

#szip(obj, &ruby_block) ⇒ Object

HW implementation of the Ruby zip. NOTE: for now szip is deactivated untile tuples are properly handled by HDLRuby.



563
564
565
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 563

def szip(obj,&ruby_block)
  return self.seach.szip(obj,&ruby_block)
end