class BitSet

::TODO

add document

::TODO

add document

this routine takes a linear binary table and finds a coordinate neighbor. not to be confused with finding a neighbor in a Logic Map.

of a given map

this one will get added to setfu soon.

add this one to setfu … also create non bang version

this should be added to gem …

#### too slow see first, last for improved performance class BitSet

def min
  return nil if empty?
  range = (self.entropy)..(0)
  while((range.first - range.last) >= 2) do
    mid = ((range.first - range.last) >> 1) + range.last
    top = (range.first)..(mid)
    bot = (mid)..(range.last)
    range = self ** bot ? bot : top
  end
  #byebug
  return range.last if (self[range.last])
  range.first
end

def max  #look from left
  #byebug
  return nil if empty?
  range = (self.entropy)..(0)
  while((range.first - range.last) >= 2) do
    mid = ((range.first - range.last) >> 1) + range.last
    top = (range.first)..(mid)
    bot = (mid)..(range.last)
    range = self ** top ? top : bot
  end
  #byebug
  return range.first if (self[range.first])
  range.last
end

end

now the stuff that slows down the editor … so last goes here

Constants

UTF_LOWER_CASE_CHARS
UTF_LOWER_CASE_DUAL_CHARS
UTF_MIXED_CASE_DUAL_CHARS
UTF_UPPER_CASE_CHARS

SETFU 'ɶ' uppercase or lowercase ??? I have this as lowercase, but I could be wrong …

leave in lowercase_dual until you get difinitive answer
UTF_UPPER_CASE_DUAL_CHARS

Attributes

entropy[R]

Public Class Methods

add_utf_case_pairs(str) click to toggle source
# File lib/setfu.rb, line 1489
def self.add_utf_case_pairs(str)
  return if str.empty?
  raise "add_utf_case_pairs requires even number of characters" unless str.length.even?
  0.step(str.length-2,2) do |x|
    @@TRANS_HASH[str[x].ord]=str[x+1].ord
  end
end
default_utf_case_pairs() click to toggle source
# File lib/setfu.rb, line 1427
  def self.default_utf_case_pairs
    @@TRANS_HASH = {
192=>224, 193=>225, 194=>226, 195=>227, 196=>228, 197=>229, 198=>230, 199=>231, 200=>232, 201=>233, 202=>234, 
203=>235, 204=>236, 205=>237, 206=>238, 207=>239, 208=>240, 209=>241, 210=>242, 211=>243, 212=>244, 213=>245,
214=>246, 216=>248, 217=>249, 218=>250, 219=>251, 220=>252, 221=>253, 222=>254, 224=>192, 225=>193, 226=>194,
227=>195, 228=>196, 229=>197, 230=>198, 231=>199, 232=>200, 233=>201, 234=>202, 235=>203, 236=>204, 237=>205,
238=>206, 239=>207, 240=>208, 241=>209, 242=>210, 243=>211, 244=>212, 245=>213, 246=>214, 248=>216, 249=>217,
250=>218, 251=>219, 252=>220, 253=>221, 254=>222, 255=>376, 256=>257, 257=>256, 258=>259, 259=>258, 260=>261,
261=>260, 262=>263, 263=>262, 264=>265, 265=>264, 266=>267, 267=>266, 268=>269, 269=>268, 270=>271, 271=>270,
272=>273, 273=>272, 274=>275, 275=>274, 276=>277, 277=>276, 278=>279, 279=>278, 280=>281, 281=>280, 282=>283,
283=>282, 284=>285, 285=>284, 286=>287, 287=>286, 288=>289, 289=>288, 290=>291, 291=>290, 292=>293, 293=>292,
294=>295, 295=>294, 296=>297, 297=>296, 298=>299, 299=>298, 300=>301, 301=>300, 302=>303, 303=>302, 306=>307,
307=>306, 308=>309, 309=>308, 310=>311, 311=>310, 313=>314, 314=>313, 315=>316, 316=>315, 317=>318, 318=>317,
319=>320, 320=>319, 321=>322, 322=>321, 323=>324, 324=>323, 325=>326, 326=>325, 327=>328, 328=>327, 330=>331,
331=>330, 332=>333, 333=>332, 334=>335, 335=>334, 336=>337, 337=>336, 338=>339, 339=>338, 340=>341, 341=>340,
342=>343, 343=>342, 344=>345, 345=>344, 346=>347, 347=>346, 348=>349, 349=>348, 350=>351, 351=>350, 352=>353,
353=>352, 354=>355, 355=>354, 356=>357, 357=>356, 358=>359, 359=>358, 360=>361, 361=>360, 362=>363, 363=>362,
364=>365, 365=>364, 366=>367, 367=>366, 368=>369, 369=>368, 370=>371, 371=>370, 372=>373, 373=>372, 374=>375,
375=>374, 376=>255, 377=>378, 378=>377, 379=>380, 380=>379, 381=>382, 382=>381, 384=>579, 385=>595, 386=>387,
387=>386, 388=>389, 389=>388, 390=>596, 391=>392, 392=>391, 393=>598, 394=>599, 395=>396, 396=>395, 398=>477,
399=>601, 400=>603, 401=>402, 402=>401, 403=>608, 404=>611, 405=>502, 406=>617, 407=>616, 408=>409, 409=>408,
410=>573, 412=>623, 413=>626, 414=>544, 415=>629, 416=>417, 417=>416, 418=>419, 419=>418, 420=>421, 421=>420, 422=>640,
423=>424, 424=>423, 425=>643, 428=>429, 429=>428, 430=>648, 431=>432, 432=>431, 433=>650, 434=>651, 435=>436,
436=>435, 437=>438, 438=>437, 439=>658, 440=>441, 441=>440, 444=>445, 445=>444, 447=>503, 452=>454, 454=>452, 455=>457, 457=>455, 458=>460, 460=>458, 461=>462, 462=>461,
463=>464, 464=>463, 465=>466, 466=>465, 467=>468, 468=>467, 469=>470, 470=>469, 471=>472, 472=>471, 473=>474,
474=>473, 475=>476, 476=>475, 477=>398, 478=>479, 479=>478, 480=>481, 481=>480, 482=>483, 483=>482, 484=>485,
485=>484, 486=>487, 487=>486, 488=>489, 489=>488, 490=>491, 491=>490, 492=>493, 493=>492, 494=>495, 495=>494, 497=>499, 499=>497, 
500=>501, 501=>500, 502=>405, 503=>447, 504=>505, 505=>504, 506=>507, 507=>506, 508=>509, 509=>508, 510=>511,
511=>510, 512=>513, 513=>512, 514=>515, 515=>514, 516=>517, 517=>516, 518=>519, 519=>518, 520=>521, 521=>520,
522=>523, 523=>522, 524=>525, 525=>524, 526=>527, 527=>526, 528=>529, 529=>528, 530=>531, 531=>530, 532=>533,
533=>532, 534=>535, 535=>534, 536=>537, 537=>536, 538=>539, 539=>538, 540=>541, 541=>540, 542=>543, 543=>542,
544=>414, 546=>547, 547=>546, 548=>549, 549=>548, 550=>551, 551=>550, 552=>553, 553=>552, 554=>555, 555=>554,
556=>557, 557=>556, 558=>559, 559=>558, 560=>561, 561=>560, 562=>563, 563=>562, 570=>11365, 571=>572, 572=>571,
573=>410, 574=>11366, 575=>11390, 576=>11391, 577=>578, 578=>577, 579=>384, 580=>649, 581=>652, 582=>583, 583=>582,
584=>585, 585=>584, 586=>587, 587=>586, 588=>589, 589=>588, 590=>591, 591=>590, 592=>11375, 593=>11373, 594=>11376,
595=>385, 596=>390, 598=>393, 599=>394, 601=>399, 603=>400, 608=>403, 611=>404, 616=>407, 617=>406, 623=>412, 626=>413,
629=>415, 640=>422, 643=>425, 648=>430, 649=>580, 650=>433, 651=>434, 652=>581, 658=>439, 913=>945, 914=>946, 915=>947, 916=>948,
917=>949, 918=>950, 919=>951, 920=>952, 921=>953, 922=>954, 923=>955, 924=>956, 925=>957, 926=>958, 927=>959, 928=>960,
929=>961, 931=>963, 932=>964, 933=>965, 934=>966, 935=>967, 936=>968, 937=>969, 945=>913, 946=>914, 947=>915, 948=>916,
949=>917, 950=>918, 951=>919, 952=>920, 953=>921, 954=>922, 955=>923, 956=>924, 957=>925, 958=>926, 959=>927, 960=>928,
961=>929, 962=>931, 963=>931, 964=>932, 965=>933, 966=>934, 967=>935, 968=>936, 969=>937, 11365=>570, 11366=>574, 11373=>593,
11375=>592, 11376=>594, 11390=>575, 11391=>576, 64257=>64258, 64258=>64257 }
  end
default_utf_sets() click to toggle source
# File lib/setfu.rb, line 1568
def self.default_utf_sets
  @@UTF_UPPER_CASE_CHARS = UTF_UPPER_CASE_CHARS
  @@UTF_LOWER_CASE_CHARS = UTF_LOWER_CASE_CHARS
  @@UTF_LOWER_CASE_DUAL_CHARS = UTF_LOWER_CASE_DUAL_CHARS
  @@UTF_UPPER_CASE_DUAL_CHARS = UTF_UPPER_CASE_DUAL_CHARS
  @@UTF_MIXED_CASE_DUAL_CHARS = UTF_MIXED_CASE_DUAL_CHARS

  @@UTF_UPPER_CASE_SET = UTF_UPPER_CASE_CHARS.to_bset
  @@UTF_LOWER_CASE_SET = UTF_LOWER_CASE_CHARS.to_bset
  @@UTF_LOWER_CASE_DUAL_SET = UTF_LOWER_CASE_DUAL_CHARS.to_bset
  @@UTF_UPPER_CASE_DUAL_SET = UTF_UPPER_CASE_DUAL_CHARS.to_bset
  @@UTF_MIXED_CASE_DUAL_SET = UTF_MIXED_CASE_DUAL_CHARS.to_bset
end
digit_chars() click to toggle source
# File lib/setfu.rb, line 457
def self.digit_chars
  set = BitSet.new
  set.set_bits!(287948901175001088)
  set.entropy=58
  return set
end
dual_lowercase_utf_chars(return_set=true) click to toggle source
# File lib/setfu.rb, line 1613
def self.dual_lowercase_utf_chars(return_set=true)
  return @@UTF_LOWER_CASE_DUAL_SET.dup if return_set
  return @@UTF_LOWER_CASE_DUAL_CHARS.dup
end
dual_uppercase_utf_chars(return_set=true) click to toggle source
# File lib/setfu.rb, line 1609
def self.dual_uppercase_utf_chars(return_set=true)
  return @@UTF_UPPER_CASE_DUAL_SET.dup if return_set
  return @@UTF_UPPER_CASE_DUAL_CHARS.dup
end
fill(n_elms, start=0) click to toggle source
# File lib/setfu.rb, line 427
def self.fill(n_elms, start=0)
  set = BitSet.new
  bits = (1 << n_elms) - 1
  set.set_bits!(bits)
  set.entropy=n_elms
  set.inc!(start.ord)
  return set
end
generate_pattern(nbits, flag_zero_first, zeros, ones ) click to toggle source
# File lib/setfu.rb, line 135
def self.generate_pattern(nbits, flag_zero_first, zeros, ones )
  bs = BitSet.new
  bs.entropy = nbits
  return bs if ones<=0
  return bs | [0..(nbits-1)] if zeros<=0
  k=0
  hash = {:zero => zeros, :one => ones}
  if flag_zero_first
    ptr = :zero
    val = false
  else
    ptr = :one
    val = true
  end
  nbits.times do |ii|
    if (k >= hash[ptr])
      k = 1
      val = !val
      ptr = (ptr == :zero) ? :one : :zero
    else
      k += 1  
    end
    bs[ii] = val
  end
  return bs
end
get_utf_case_pairs(char=true) click to toggle source
# File lib/setfu.rb, line 1497
def self.get_utf_case_pairs(char=true)
  return @@TRANS_HASH.dup unless char
  rtn = {}
  @@TRANS_HASH.each_pair do |key,value|
    rtn[key.chr(Encoding::UTF_8)] = value.chr(Encoding::UTF_8)
    rtn[value.chr(Encoding::UTF_8)] = key.chr(Encoding::UTF_8)
  end
  return rtn
end
int(int,ent=nil) click to toggle source
# File lib/setfu.rb, line 177
def self.int(int,ent=nil)
  bs = BitSet.new
  bs.set_bits!(int)
  if ent.nil?
    bs.recalculate_entropy!
  else
    bs.entropy=ent
  end
  bs
end
letter_chars() click to toggle source
# File lib/setfu.rb, line 450
def self.letter_chars
  set = BitSet.new
  set.set_bits!(10633823810298881996379053697534001152)
  set.entropy=123
  return set
end
lowercase_chars() click to toggle source
# File lib/setfu.rb, line 443
def self.lowercase_chars
  set = BitSet.new
  set.set_bits!(10633823807823001954701781295154855936)
  set.entropy=123
  return set
end
lowercase_utf_chars(return_set=true) click to toggle source
# File lib/setfu.rb, line 1601
def self.lowercase_utf_chars(return_set=true)
  return @@UTF_LOWER_CASE_SET.dup if return_set
  return @@UTF_LOWER_CASE_CHARS.dup
end
mixcase_utf_chars(return_set=true) click to toggle source
# File lib/setfu.rb, line 1605
def self.mixcase_utf_chars(return_set=true)
  return @@UTF_MIXED_CASE_DUAL_SET.dup if return_set
  return @@UTF_MIXED_CASE_DUAL_CHARS.dup
end
modify_utf_sets(*prms) click to toggle source
# File lib/setfu.rb, line 1618
def self.modify_utf_sets(*prms)
  flag_add = true
  target_chars = nil
  target_set   = nil
  source = nil
  prms.each do |prm|
    if    prm.type_of? String
      source = prm
    elsif prm.type_of? BitSet
      source = prm
    elsif prm.type_of? Array
      source = prm
    elsif prm.type_of? Integer
      source = [prm]
    elsif prm.type_of? Symbol
      if prm == :rm
        flag_add = false
      elsif prm == :add
        flag_add = true
      elsif prm == :mix
        target_chars = "@@UTF_MIXED_CASE_DUAL_CHARS"
        target_set   = "@@UTF_MIXED_CASE_DUAL_SET"
      elsif prm == :upper
        target_chars = "@@UTF_UPPER_CASE_CHARS"
        target_set   = "@@UTF_UPPER_CASE_SET"
      elsif prm == :lower
        target_chars = "@@UTF_LOWER_CASE_CHARS"
        target_set   = "@@UTF_LOWER_CASE_SET"
      elsif prm == :dual_upper
        target_chars = "@@UTF_UPPER_CASE_DUAL_CHARS"
        target_set   = "@@UTF_UPPER_CASE_DUAL_SET"
      elsif prm == :dual_lower
        target_chars = "@@UTF_LOWER_CASE_DUAL_CHARS"
        target_set   = "@@UTF_LOWER_CASE_DUAL_SET"
      end
    end
  end
  return false if target_chars.nil? 
  return false if source.nil?
  if flag_add
    eval("#{target_set} |= source")
    eval("#{target_chars} = #{target_set}.to_s")
  else
    eval("#{target_set} -= source")
    eval("#{target_chars} = #{target_set}.to_s")
  end
  return true
end
new(*data) click to toggle source
# File lib/setfu.rb, line 591
def initialize(*data)
  @bits = 0
  @entropy = 0
  add!(data)
  self
end
parse_chars() click to toggle source
# File lib/setfu.rb, line 464
def self.parse_chars
  set = BitSet.new
  set.set_bits!(159507359650170349735020301117175103487)
  set.entropy=127
  return set
end
rm_utf_case_pairs(obj) click to toggle source
# File lib/setfu.rb, line 1477
def self.rm_utf_case_pairs(obj)
  if obj.respond_to? :each_char
    obj.each_char do |ch|
      @@TRANS_HASH.delete str.ord
    end
  else
    obj.each do |elm|
      @@TRANS_HASH.delete elm
    end  
  end  
end
uppercase_chars() click to toggle source
# File lib/setfu.rb, line 436
def self.uppercase_chars
  set = BitSet.new
  set.set_bits!(2475880041677272402379145216)
  set.entropy=91
  return set
end
uppercase_utf_chars(return_set=true) click to toggle source
# File lib/setfu.rb, line 1597
def self.uppercase_utf_chars(return_set=true)
  return @@UTF_UPPER_CASE_SET.dup if return_set
  return @@UTF_UPPER_CASE_CHARS.dup
end
zap_utf_case_pairs() click to toggle source
# File lib/setfu.rb, line 1473
def self.zap_utf_case_pairs
  @@TRANS_HASH = {}
end
zap_utf_sets() click to toggle source
# File lib/setfu.rb, line 1583
def self.zap_utf_sets
  @@UTF_UPPER_CASE_CHARS = ""
  @@UTF_LOWER_CASE_CHARS = ""
  @@UTF_LOWER_CASE_DUAL_CHARS = ""
  @@UTF_UPPER_CASE_DUAL_CHARS = ""
  @@UTF_MIXED_CASE_DUAL_CHARS = ""

  @@UTF_UPPER_CASE_SET = "".to_bset
  @@UTF_LOWER_CASE_SET = "".to_bset
  @@UTF_LOWER_CASE_DUAL_SET = "".to_bset
  @@UTF_UPPER_CASE_DUAL_SET = "".to_bset
  @@UTF_MIXED_CASE_DUAL_SET = "".to_bset
end

Public Instance Methods

!=(item) click to toggle source
# File lib/setfu.rb, line 735
def !=(item)
  if(item.type_of? BitSet)
    rtn = item.to_i != self.to_i
  else
    rtn = BitSet.new(item).to_i != self.to_i
  end
  rtn
end
&(item) click to toggle source
# File lib/setfu.rb, line 690
def &(item)
  rtn = self.dup
  if(item.type_of? BitSet)
    rtn.set_bits!(rtn.to_i & item.to_i)
  else
    rtn = BitSet.new(item)
    rtn.set_bits!(@bits & rtn.to_i)
  end
  rtn
end
**(item) click to toggle source
# File lib/setfu.rb, line 719
def **(item)  # intersection test
  set_item = BitSet.new(item)
  return false if (self & set_item).empty?
  return true
end
-(item) click to toggle source
# File lib/setfu.rb, line 701
def -(item)
  rtn = BitSet.new
  rtn.entropy = self.entropy
  a = self.to_i
  if(item.type_of? BitSet)
    b = item.to_i
    rtn.entropy = item.entropy
  else
    b = BitSet.new(item)
    rtn.entropy = b.entropy
    b = b.to_i
  end
  c = a & b
  d = c ^ a
  rtn.set_bits!(d)
  rtn
end
<(item) click to toggle source
# File lib/setfu.rb, line 781
def <(item)
  si = BitSet.new item
  return false if (si == self)  # not a 'proper' subset
  return si.include?(self)
end
<=(item) click to toggle source
# File lib/setfu.rb, line 776
def <=(item)
  si = BitSet.new item
  return si.include?(self)
end
==(item) click to toggle source

comparison operators:

# File lib/setfu.rb, line 726
def ==(item)
  if(item.type_of? BitSet)
    rtn = item.to_i == self.to_i
  else
    rtn = BitSet.new(item).to_i == self.to_i
  end
  rtn
end
===(item) click to toggle source
# File lib/setfu.rb, line 753
def ===(item)
  # self ... when clause  ...
  # item ... case clause  ... case(item)
  # Note: coerce does not work in this context ...
  
  md = item.to_bset.mode || @mode
  
  case md
    when :mode_intersection
      return item ** self
    when :mode_sub
      return item <= self
    when :mode_proper
      return item < self
    when :mode_super
      return self <= item
    when :mode_superproper
      return self < item
    else
      return self == item  
  end
end
[](*pset) click to toggle source

new behavior … single element returns true/false multi element … returns subset

# File lib/setfu.rb, line 991
def [](*pset)
  idx = nil
  if pset.count==1  # check for single instance  inst[5], inst['t']
    if pset.first.type_of? Integer
      idx = pset.first
    elsif pset.first.type_of? String
      if pset.first.length == 1
        idx = pset.first.ord
      end
    end
  end
  unless idx.nil?
    raise "Negative indexes are illegal for BitSet" if idx < 0
    self.entropy = idx+1
    y = @bits & (1<<idx)
    return true if y > 0
    return false    
  end
  return pset.to_bset & self
end
[]=(*pset,value) click to toggle source
# File lib/setfu.rb, line 1012
def []=(*pset,value)  # pset goes in the box, value after '='
  pset = pset.to_bset
  state = value ? true : false
  if state
    replace pset | self  # add elements to set
  else
    replace self - pset  # remove elements from set
  end
  return state # this gets ignored, but to be safe, do what the previous version did
end
^(item) click to toggle source
# File lib/setfu.rb, line 667
def ^(item)
  rtn = self.dup
  if(item.type_of? BitSet)
    rtn.set_bits!(rtn.to_i ^ item.to_i)
  else
    rtn = BitSet.new(item)
    rtn.set_bits!(@bits ^ rtn.to_i)
  end
  rtn
end
add(items) click to toggle source
# File lib/setfu.rb, line 819
def add(items)
  dup.add!(items)
end
add!(items) click to toggle source
# File lib/setfu.rb, line 787
def add!(items)
  if(items.type_of? BitSet)
    @bits |= items.to_i
    entropy = items.entropy
  elsif(items.type_of? Range)
    ran = items.reorder.simplify
    return add!(ran.to_a) unless ran.simple?
    f=ran.first.ord
    l=ran.last.ord
    # f,l = l,f if f>l
    t = (l-f)+1
    t = (1 << t)-1
    @bits |= t << f
    self.entropy = l+1
  elsif(items.respond_to? :each_char)
    items.each_char do |item|
      @bits |= 1 << item.ord
      self.entropy = item.ord+1
    end
  elsif(items.respond_to? :each)
    items.each do |item|
      add! item
    end
  else #assume number
    raise "negative numbers are not allowed" if items < 0
    pos = 1 << items
    @bits |= pos
    self.entropy = items+1
  end
  self
end
add_digit_chars() click to toggle source
# File lib/setfu.rb, line 494
def add_digit_chars
  return BitSet.digit_chars | self
end
add_digit_chars!() click to toggle source
# File lib/setfu.rb, line 489
def add_digit_chars!
  add! BitSet.digit_chars
  self
end
add_dual_lower_utf() click to toggle source
# File lib/setfu.rb, line 1703
def add_dual_lower_utf
  return BitSet.dual_lowercase_utf_chars | self
end
add_dual_lower_utf!() click to toggle source
# File lib/setfu.rb, line 1707
def add_dual_lower_utf!
  add! BitSet.dual_lowercase_utf_chars
  self
end
add_dual_upper_utf() click to toggle source
# File lib/setfu.rb, line 1694
def add_dual_upper_utf
  return BitSet.dual_uppercase_utf_chars | self
end
add_dual_upper_utf!() click to toggle source
# File lib/setfu.rb, line 1698
def add_dual_upper_utf!
  add! BitSet.dual_uppercase_utf_chars
  self
end
add_letter_chars() click to toggle source
# File lib/setfu.rb, line 516
def add_letter_chars
  return BitSet.letter_chars | self
end
add_letter_chars!() click to toggle source
# File lib/setfu.rb, line 520
def add_letter_chars!
  add! BitSet.letter_chars
  self
end
add_lowercase_chars() click to toggle source
# File lib/setfu.rb, line 512
def add_lowercase_chars
  return BitSet.lowercase_chars | self
end
add_lowercase_chars!() click to toggle source
# File lib/setfu.rb, line 507
def add_lowercase_chars!
  add! BitSet.lowercase_chars
  self
end
add_lowercase_utf() click to toggle source
# File lib/setfu.rb, line 1667
def add_lowercase_utf
  return BitSet.lowercase_utf_chars | self
end
add_lowercase_utf!() click to toggle source
# File lib/setfu.rb, line 1671
def add_lowercase_utf!
  add! BitSet.lowercase_utf_chars
  self
end
add_mixcase_utf() click to toggle source
# File lib/setfu.rb, line 1685
def add_mixcase_utf
  return BitSet.mixcase_utf_chars | self
end
add_mixcase_utf!() click to toggle source
# File lib/setfu.rb, line 1689
def add_mixcase_utf!
  add! BitSet.mixcase_utf_chars
  self
end
add_opposing_case() click to toggle source
# File lib/setfu.rb, line 1518
def add_opposing_case
  dup.add_opposing_case!
end
add_opposing_case!() click to toggle source
# File lib/setfu.rb, line 1507
def add_opposing_case!
  aa = BitSet.lowercase_chars
  bb = BitSet.uppercase_chars
  ka = aa & self  # subset lower case
  kb = bb & self  # subset upper case
  @bits |= ka.to_i >> 32
  @bits |= kb.to_i << 32
  self.entropy = 32 + kb.recalculate_entropy! if self.entropy <= 123
  self
end
add_opposing_utf_case() click to toggle source
# File lib/setfu.rb, line 1534
def add_opposing_utf_case
  dup.add_opposing_utf_case!  
end
add_opposing_utf_case!() click to toggle source
# File lib/setfu.rb, line 1522
def add_opposing_utf_case!
  add_opposing_case!
  tmp = @@TRANS_HASH.sort
  st = tmp.first[0]
  nd = tmp.last[0]
  self.each_member(st..nd) do |elm|
    unless @@TRANS_HASH[elm].nil?
      @bits |= 1 << @@TRANS_HASH[elm]
      @entropy = elm if elm > @entropy
    end
  end   
end
add_parse_chars() click to toggle source
# File lib/setfu.rb, line 485
def add_parse_chars
  return BitSet.parse_chars | self
end
add_parse_chars!() click to toggle source
# File lib/setfu.rb, line 479
def add_parse_chars!
  # add! [0..47, 58..64, 91..96, 123..126]
  add! BitSet.parse_chars
  self
end
add_primes(n=100) click to toggle source
# File lib/setfu.rb, line 1421
def add_primes(n=100)
  self.add(Prime.take(n))
end
add_primes!(n=100) click to toggle source
# File lib/setfu.rb, line 1418
def add_primes!(n=100)
  self.add!(Prime.take(n))
end
add_uppercase_chars() click to toggle source
# File lib/setfu.rb, line 503
def add_uppercase_chars
  return BitSet.uppercase_chars | self
end
add_uppercase_chars!() click to toggle source
# File lib/setfu.rb, line 498
def add_uppercase_chars!
  add! BitSet.uppercase_chars
  self
end
add_uppercase_utf() click to toggle source
# File lib/setfu.rb, line 1676
def add_uppercase_utf
  return BitSet.uppercase_utf_chars | self
end
add_uppercase_utf!() click to toggle source
# File lib/setfu.rb, line 1680
def add_uppercase_utf!
  add! BitSet.uppercase_utf_chars
  self
end
coerce(other) click to toggle source

this only works on integer … String, Array, Range does not implement: &, |, ^

# File lib/setfu.rb, line 656
def coerce(other)
  #puts "TESTING ... coerce called!"
  return [self, other]   # does not seem to get called ...
end
count() click to toggle source
# File lib/setfu.rb, line 916
def count
  cnt = 0
  each_member do |toss|
    cnt += 1
  end 
  cnt    
end
dec(n=1) click to toggle source
# File lib/setfu.rb, line 625
def dec(n=1)
  return dup.dec!(n)
end
dec!(n=1) click to toggle source
# File lib/setfu.rb, line 615
def dec!(n=1)
  raise "illegal negative parameter in #inc" if n < 0
  @bits >>= n
  self
end
double() click to toggle source
# File lib/setfu.rb, line 170
def double
  dup.double!
end
double!() click to toggle source
# File lib/setfu.rb, line 165
def double!
  @bits |= @bits << @entropy
  @entropy <<= 1
  self    
end
dup() click to toggle source
# File lib/setfu.rb, line 661
def dup
  rtn = BitSet.new
  rtn.replace(self)
  return rtn
end
each(*prms) { |chr_mode ? chr(UTF_8) : pos| ... } click to toggle source
# File lib/setfu.rb, line 879
def each(*prms)
  return Enumerator.enumerate_yields(self, :each, *prms) unless block_given?
  bits = @bits
  pos = 0
  stop = nil
  chr_mode = false
  prms.each do |prm|
    if prm.respond_to? :first
      a = prm.first.ord
      b = prm.last.ord
      a,b = b,a if a>b
      pos = a
      bits >>= pos
      stop = b
    else
      chr_mode = !prm
    end
  end
  while bits > 0
    if ((bits & 1) == 1)
      yield chr_mode ? pos.chr(Encoding::UTF_8) : pos
    end
    pos += 1
    unless stop.nil?
      break if pos > stop
    end
    bits >>= 1
  end  
  self
end
Also aliased as: each_member
each_member(*prms)
Alias for: each
empty?() click to toggle source
# File lib/setfu.rb, line 823
def empty?
  @bits == 0
end
entropy=(ent) click to toggle source

# can't do this … already using operators for something else

include Comparable
def <=>(other)
  @bits <=> other.to_bset.to_i
end
# File lib/setfu.rb, line 423
def entropy=(ent)  # entropy only gets bigger, just like the universe!
  @entropy = ent unless @entropy > ent
end
entropy_2n!() click to toggle source
# File lib/setfu.rb, line 1308
def entropy_2n!   # set entropy to the next greater power of 2**n
  @entropy = 1 << @bits.bit_length.bit_length
end
eql?(item) click to toggle source
# File lib/setfu.rb, line 744
def eql?(item)
  self.==(item)
end
even() click to toggle source
# File lib/setfu.rb, line 1354
def even
  t = @@even_bits
  s = @@shifts
  while @bits > t
    t |= t << s
    s <<= 1
  end
  rtn = self.dup
  rtn.set_bits!(t & @bits)
  return rtn
end
even!() click to toggle source
# File lib/setfu.rb, line 1379
def even!
  t1 = @@odd_bits
  t2 = @@even_bits
  s = @@shifts
  while @bits > t2
    t1 |= t1 << s
    t2 |= t2 << s
    s <<= 1
  end
  rtn = self.dup
  rtn.set_bits!(t1 & @bits)
  self.set_bits!(t2 & @bits)
  return rtn
end
even?() click to toggle source
# File lib/setfu.rb, line 1404
def even?
  return false if empty?
  t = @@even_bits
  s = @@shifts
  while @bits > t
    t |= t << s
    s <<= 1
  end
  tst = t & @bits
  return tst == @bits
end
first(p=true) click to toggle source
# File lib/setfu.rb, line 1314
def first(p=true)
  rtn = @bits.lsb_bit_position
  return p ? rtn : rtn.chr(Encoding::UTF_8)
end
Also aliased as: min
first!(p=true) click to toggle source
# File lib/setfu.rb, line 1322
def first!(p=true)
  rtn = @bits.lsb_bit_position
  replace(self ^ [rtn]) unless rtn.nil?
  return p ? rtn : rtn.chr(Encoding::UTF_8)
end
inc(n=1) click to toggle source
# File lib/setfu.rb, line 621
def inc(n=1)
  return dup.inc!(n)
end
inc!(n=1) click to toggle source
# File lib/setfu.rb, line 608
def inc!(n=1)
  raise "illegal negative parameter in #inc" if n < 0
  @entropy += n
  @bits <<= n
  self
end
include?(items) click to toggle source
# File lib/setfu.rb, line 827
def include?(items)
  return false if items.nil?   # sets never include nil
  return false if @bits == 0   # empty sets include nothing including other empty sets
  if(items.type_of? BitSet)
    tmp = @bits & items.to_i
    return false if tmp==0
    return (tmp) == items.to_i
  elsif(items.type_of? Range)
    ran = items.reorder.simplify
    return(include?(ran.to_a)) unless ran.simple?
    f=ran.first.ord
    l=ran.last.ord
    # f,l = l,f if f>l
    t = (l-f)+1
    t = (1 << t)-1
    t = t << f
    return (@bits & t) == t
  elsif(items.respond_to? :each_char)
    return false if items.empty?
    items.each_char do |item|
      t = 1 << item.ord
      return false if 0 == (t & @bits)
    end
  elsif(items.respond_to? :each)
    return false if items.empty?
    items.each do |item|
      return false if false==include?(item)
    end
  else #assume number
    t = 1 << items.abs
    return false if 0 == (t & @bits)
  end
  return true
end
last(p=true) click to toggle source
# File lib/setfu.rb, line 1318
def last(p=true)
  rtn = @bits.msb_bit_position
  return p ? rtn : rtn.chr(Encoding::UTF_8)
end
Also aliased as: max
last!(p=true) click to toggle source
# File lib/setfu.rb, line 1327
def last!(p=true)
  rtn =  @bits.msb_bit_position
  replace(self ^ [rtn]) unless rtn.nil?
  return p ? rtn : rtn.chr(Encoding::UTF_8)
end
max(p=true)
Alias for: last
max_run() click to toggle source
# File lib/setfu.rb, line 560
def max_run # max_run << returns maximum number of consecutive numbers
  return 0 if @bits==0
  mx = 1
  bits = @bits
  loop do
    bits <<= 1
    bits &= @bits
    break if 0 == bits
    mx += 1
  end
  return mx
end
min(p=true)
Alias for: first
mode() click to toggle source
# File lib/setfu.rb, line 587
def mode
  return @mode
end
neighbor(nvars, dir) click to toggle source
# File lib/setfu.rb, line 95
def neighbor(nvars, dir)
  raise "too many neighbors for #{nvars} variables" if dir >= nvars
  raise "dir must be positive" if dir.negative?
  rtn = dup

  if 1==nvars      # two squares
    rtn[dir]=!self[dir]
  elsif 2==nvars   # a 2x2 box
    if 0==dir
      rtn[0]=!self[0]
    else
      rtn[1]=!self[1]
    end
  end
  # now programmatically do the remaining pattern
  if nvars.even?
    if dir.even?   # up if dir==0 and nvars==4  ... left if dir==2 and nvars==4
      rtn[dir]=self[dir+1]
      rtn[dir+1]=!self[dir]
    else          # down if dir ==1 and nvars==4 ... right if dir==3 and nvars==4
      rtn[dir-1]=!self[dir]  # modified on dec 21, 2019  9:34AM
      rtn[dir]=self[dir-1]
    end
  else # odd    .......... compare with neighbor5    dir [0,1,2,3,4]
    if dir==(nvars-1)   # dir==4
      rtn[dir]=!self[dir]
    elsif dir.even?          # 0,2 validated
      rtn[dir]=self[dir+1]
      rtn[dir+1]=!self[dir]
    else                     # 1,3 validated
      rtn[dir-1]=!self[dir]
      rtn[dir]=self[dir-1]
    end
  end
  return rtn
end
odd() click to toggle source
# File lib/setfu.rb, line 1343
def odd
  t = @@odd_bits
  s = @@shifts
  while @bits > t
    t |= t << s
    s <<= 1
  end
  rtn = self.dup
  rtn.set_bits!(t & @bits)
  return rtn
end
odd!() click to toggle source
# File lib/setfu.rb, line 1365
def odd!
  t1 = @@odd_bits
  t2 = @@even_bits
  s = @@shifts
  while @bits > t2
    t1 |= t1 << s
    t2 |= t2 << s
    s <<= 1
  end
  rtn = self.dup
  rtn.set_bits!(t2 & @bits)
  self.set_bits!(t1 & @bits)
  return rtn
end
odd?() click to toggle source
# File lib/setfu.rb, line 1393
def odd?
  return false if empty?
  t = @@odd_bits
  s = @@shifts
  while @bits > t
    t |= t << s
    s <<= 1
  end
  tst = t & @bits
  return tst == @bits
end
rand(elm_count, format = :bset) click to toggle source

:array :array_chars :string :set

# File lib/setfu.rb, line 1024
def rand(elm_count, format = :bset)
  ary = self.to_a
  ary.shuffle!
  ary = ary[0..(elm_count-1)]
  case format
    when :array
      return ary
    when :array_chars
      rtn = []
      ary.each do |elm|
        rtn.push elm.chr(Encoding::UTF_8)
      end
      return rtn
    when :string
      rtn = []
      ary.each do |elm|
        rtn.push elm.chr(Encoding::UTF_8)
      end
      return rtn.join ""
    else # :bset
      return ary.to_bset
  end
end
rand!(elm_count, format = :bset) click to toggle source
# File lib/setfu.rb, line 1048
def rand!(elm_count, format = :bset)
  ary = self.to_a
  rna = ary.shuffle[0..(elm_count-1)]
  replace rna.to_bset
  case format
    when :array
      return (ary - rna).shuffle
    when :array_chars
      src = (ary - rna).shuffle
      rtn = []
      src.each do |elm|
        rtn.push elm.chr(Encoding::UTF_8)
      end
      return rtn
    when :string
      src = (ary - rna).shuffle
      rtn = []
      src.each do |elm|
        rtn.push elm.chr(Encoding::UTF_8)
      end
      return rtn.join ""
    else # :bset
      return (ary - rna).to_bset
  end
end
recalculate_entropy!() click to toggle source
# File lib/setfu.rb, line 629
def recalculate_entropy!
  @entropy = 0
  bits = @bits
  num = 1 << 8192
  while(bits > num)
    @entropy += 8192
    bits >>= 8192
  end
  num = 1 << 256
  while(bits > num)
    @entropy += 256
    bits >>= 256
  end
  num = 1 << 16
  while(bits > num)
    @entropy += 16
    bits >>= 16
  end
  while(bits > 0)
    @entropy += 1
    bits >>= 1
  end
  #@entropy += 1
  @entropy
end
replace(ent) click to toggle source
# File lib/setfu.rb, line 471
def replace(ent)
  ent = ent.to_bset
  @mode = ent.mode
  @entropy = ent.entropy
  @bits = ent.to_i
  self  
end
reverse_each(*prms) { |pop| ... } click to toggle source
# File lib/setfu.rb, line 862
def reverse_each(*prms)  # do a benchmark and see which is faster, reverse_each or each
  return Enumerator.enumerate_yields(self, :reverse_each, *prms) unless block_given?
  int_mode = true
  set = self.dup
  prms.each do |prm|
    if prm.respond_to? :first
      set &= prm
    else
      int_mode = prm  
    end
  end
  ary = set.to_a(int_mode)
  while !ary.empty?
    yield ary.pop
  end
end
runs() click to toggle source
01100010011111111100010101001101   ... test

01100010011111111100010101001101 … left shift 001000000011111111000000000001000 … and with left shift

01100010011111111100010101001101   ... test
00110001001111111110001010100110    ... right shift
00100000001111111100000000000100    ... and with right shift

001000000011111111000000000001000 … AND with left shift

00100000001111111100000000000100    ... AND with right shift

001100000011111111100000000001100 … OR the two ands

01100010011111111100010101001101   ... test original
01100000011111111100000000001100   ... BINGO ... original with the OR  gives us the runs only
00000010000000000000010101000001   ... BINGO ... original XOR with OR gives us the singles!
# File lib/setfu.rb, line 540
def runs # runs    << creates a set of touching elements
  an_l = (@bits << 1) & @bits
  an_r = (@bits >> 1) & @bits
  or_lr = an_l | an_r
  rtn = BitSet.new
  rtn.set_bits!(or_lr & @bits)
  rtn.entropy=self.entropy
  return rtn
end
runs?(cnt=2) click to toggle source
# File lib/setfu.rb, line 573
def runs?(cnt=2)
  bits = @bits
  (cnt-1).times do
    bits <<= 1
    bits &= @bits
    return false if 0 == bits
  end
  return true
end
set_all!() click to toggle source
# File lib/setfu.rb, line 190
def set_all!  # set all possible bits   ... make sure this does not already exist ... if it does, then use the proper name
  bits = (2 ** entropy) - 1
  set_bits! bits
end
set_bits!(bits) click to toggle source
# File lib/setfu.rb, line 977
def set_bits!(bits)
  raise "negative numbers are not allowed" if bits.to_i < 0
  @bits = bits.to_i
end
set_case(mode=:mode_equal) click to toggle source
# File lib/setfu.rb, line 748
def set_case(mode=:mode_equal)
  @mode = mode
  self
end
singles() click to toggle source
# File lib/setfu.rb, line 550
def singles # singles << creates a set of non-touching elements
  an_l = (@bits << 1) & @bits
  an_r = (@bits >> 1) & @bits
  or_lr = an_l | an_r
  rtn = BitSet.new
  rtn.set_bits!(or_lr ^ @bits)
  rtn.entropy=self.entropy
  return rtn
end
size() click to toggle source
# File lib/setfu.rb, line 604
def size
  count
end
split() click to toggle source
# File lib/setfu.rb, line 1540
def split
  ary = self.to_a
  len = ary.length
  lh = len >> 1
  a = ary[0..(lh-1)].to_bset
  b = ary[lh..len].to_bset
  return [a,b]
end
split!() click to toggle source
# File lib/setfu.rb, line 1548
def split!
  both = self.split
  rtn = both.last
  self.replace both.first
  return rtn
end
swap(pos1,pos2) click to toggle source
# File lib/setfu.rb, line 83
def swap(pos1,pos2)
  bs = dup
  bs[pos1],bs[pos2] = self[pos2], self[pos1]
  bs
end
swap!(pos1,pos2) click to toggle source
# File lib/setfu.rb, line 79
def swap!(pos1,pos2)
  self[pos1],self[pos2] = self[pos2], self[pos1]
  self
end
to_a(int = true) click to toggle source
# File lib/setfu.rb, line 932
def to_a(int = true)
  rtn = []
  each_member do |num|
    rtn.push int ? num : num.chr(Encoding::UTF_8)
  end
  rtn
end
to_bset() click to toggle source
# File lib/setfu.rb, line 583
def to_bset
  return self
end
to_i() click to toggle source
# File lib/setfu.rb, line 912
def to_i
  return @bits
end
to_ra(int=true, th=3) click to toggle source
# File lib/setfu.rb, line 940
def to_ra(int=true, th=3)
  raise "Threshold too low" unless th >= 2
  rtn = []
  cnt = 0
  last  = -100
  flag  = false
  th -= 1
  each_member do |num|
    # byebug unless int
    rtn.push int ? num : num.chr(Encoding::UTF_8)
    if ((last+1)==num)
      # byebug if cnt.nil?
      cnt += 1
      flag = cnt >= th
    elsif flag
      save = rtn.pop
      tmp = rtn.pop(cnt+1)
      range = (tmp.first)..(tmp.last)
      rtn.push range
      rtn.push save
      cnt = 0
      last = -100
      flag = false
    else
      cnt = 0  
    end
    last = num
  end
  #byebug
  if flag # convert final range
    tmp = rtn.pop(cnt+1)
    range = (tmp.first)..(tmp.last)
    rtn.push range
  end
  rtn
end
to_s() click to toggle source
# File lib/setfu.rb, line 924
def to_s
  rtn = ""
  each_member do |ch|
    rtn += ch.chr(Encoding::UTF_8)
  end
  rtn
end
untag() click to toggle source
# File lib/setfu.rb, line 365
def untag
  BitSet.new | self
end
untag!() click to toggle source
# File lib/setfu.rb, line 368
def untag!
  remove_instance_variable :@bo_setfu_tag rescue :never_mind
  remove_instance_variable :@bo_setfu_count rescue :never_mind
end
zap!() click to toggle source
# File lib/setfu.rb, line 598
def zap!
  @bits = 0
  @entropy = 0
  self
end
|(item) click to toggle source
# File lib/setfu.rb, line 678
def |(item)
  rtn = self.dup
  if(item.type_of? BitSet)
    rtn.set_bits!(rtn.to_i | item.to_i)
    self.entropy=item.entropy
  else
    rtn = BitSet.new(item)
    rtn.set_bits!(@bits | rtn.to_i)
  end
  rtn
end