Module: Ob

Defined in:
lib/ob.rb

Overview

++ ob

Class Method Summary collapse

Class Method Details

.F(j, arg) ⇒ Object

A pseudorandom function for j in (0..3)



8
9
10
11
 
# File 'lib/ob.rb', line 8

def self.F(j, arg)
  raku = [0xb76d5eed, 0xee281300, 0x85bcae01, 0x4b387af7]
  Muk.muk(raku[j], arg)
end

.Fe(r, a, b, k, f, m) ⇒ Object 



17
18
19
20
 
# File 'lib/ob.rb', line 17

def self.Fe(r, a, b, k, f, m)
  c = fe(r, a, b, f, m)
  c < k ? c : fe(r, a, b, f, c)
end

.fe(r, a, b, f, m) ⇒ Object 



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
 
# File 'lib/ob.rb', line 22

def self.fe(r, a, b, f, m)
  loop_fn = lambda do |j, ell, arr|
    if j > r
      if r.odd?
        a * arr + ell
      else
        arr == a ? a * arr + ell : a * ell + arr
      end
    else
      eff = f.call(j - 1, arr) # Assuming f is a Proc/lambda

      tmp = if j.odd?
              (ell + eff) % a
            else
              (ell + eff) % b
            end

      loop_fn.call(j + 1, arr, tmp)
    end
  end

  left = m % a
  right = m / a

  loop_fn.call(1, left, right)
end

.fein(arg) ⇒ Object 



98
99
100
 
# File 'lib/ob.rb', line 98

def self.fein(arg)
  fein_loop(arg)
end

.fein_loop(pyn) ⇒ Object 



85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/ob.rb', line 85

def self.fein_loop(pyn)
  lo = pyn & 0xffffffff
  hi = pyn & 0xffffffff00000000

  if (pyn >= 0x10000) && (pyn <= 0xffffffff)
    0x10000 + feis(pyn - 0x10000)
  elsif (pyn >= 0x100000000) && (pyn <= 0xffffffffffffffff)
    hi | fein_loop(lo)
  else
    pyn
  end
end

.feis(arg) ⇒ Object 



13
14
15
 
# File 'lib/ob.rb', line 13

def self.feis(arg)
  Fe(4, 65_535, 65_536, 0xffffffff, method(:F), arg)
end

.fen(r, a, b, f, m) ⇒ Object

TODO: FIXME



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
 
# File 'lib/ob.rb', line 59

def self.fen(r, a, b, f, m)
  # Inner recursive function using Ruby way of doing recursion
  loop_fn = lambda do |j, ell, arr|
    return a * arr + ell if j < 1

    eff = f.call(j - 1, ell) # Assuming f is a Proc/lambda

    # Same comment about deviation from B&R (2002)
    tmp = if j.odd?
            (arr + a - (eff % a)) % a
          else
            (arr + b - (eff % b)) % b
          end

    loop_fn.call(j - 1, tmp, ell)
  end

  ahh = r.odd? ? m / a : m % a
  ale = r.odd? ? m % a : m / a

  left = ale == a ? ahh : ale
  right = ale == a ? ale : ahh

  loop_fn.call(r, left, right)
end

.Fen(r, a, b, k, f, m) ⇒ Object 



53
54
55
56
 
# File 'lib/ob.rb', line 53

def self.Fen(r, a, b, k, f, m)
  c = fen(r, a, b, f, m)
  c < k ? c : fen(r, a, b, f, c)
end

.fynd(arg) ⇒ Object 



115
116
117
 
# File 'lib/ob.rb', line 115

def self.fynd(arg)
  fynd_loop(arg)
end

.fynd_loop(cry) ⇒ Object 



102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/ob.rb', line 102

def self.fynd_loop(cry)
  lo = cry & 0xffffffff
  hi = cry & 0xffffffff00000000

  if (cry >= 0x10000) && (cry <= 0xffffffff)
    0x10000 + tail(cry - 0x10000)
  elsif (cry >= 0x100000000) && (cry <= 0xffffffffffffffff)
    hi | fynd_loop(lo)
  else
    cry
  end
end

.tail(arg) ⇒ Object 



49
50
51
 
# File 'lib/ob.rb', line 49

def self.tail(arg)
  Fen(4, 65_535, 65_536, 0xffffffff, method(:F), arg)
end