Python/hashes/chaos_machine.py at master · manmita/Python · GitHub

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
"""example of simple chaos machine"""

# Chaos Machine (K, t, m)
K= [0.33, 0.44, 0.55, 0.44, 0.33]
t=3
m=5

# Buffer Space (with Parameters Space)
buffer_space: list[float] = []
params_space: list[float] = []

# Machine Time
machine_time=0


defpush(seed):
globalbuffer_space, params_space, machine_time, K, m, t

# Choosing Dynamical Systems (All)
forkey, valueinenumerate(buffer_space):
# Evolution Parameter
e=float(seed/value)

# Control Theory: Orbit Change
value= (buffer_space[(key+1) %m] +e) %1

# Control Theory: Trajectory Change
r= (params_space[key] +e) %1+3

# Modification (Transition Function) - Jumps
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] =r# Saving to Parameters Space

# Logistic Map
assertmax(buffer_space) <1
assertmax(params_space) <4

# Machine Time
machine_time+=1


defpull():
globalbuffer_space, params_space, machine_time, K, m, t

# PRNG (Xorshift by George Marsaglia)
defxorshift(x, y):
x^=y>>13
y^=x<<17
x^=y>>5
returnx

# Choosing Dynamical Systems (Increment)
key=machine_time%m

# Evolution (Time Length)
for_inrange(t):
# Variables (Position + Parameters)
r=params_space[key]
value=buffer_space[key]

# Modification (Transition Function) - Flow
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] = (machine_time*0.01+r*1.01) %1+3

# Choosing Chaotic Data
x=int(buffer_space[(key+2) %m] * (10**10))
y=int(buffer_space[(key-2) %m] * (10**10))

# Machine Time
machine_time+=1

returnxorshift(x, y) %0xFFFFFFFF


defreset():
globalbuffer_space, params_space, machine_time, K, m, t

buffer_space=K
params_space= [0] *m
machine_time=0


if__name__=="__main__":
# Initialization
reset()

# Pushing Data (Input)
importrandom

message=random.sample(range(0xFFFFFFFF), 100)
forchunkinmessage:
push(chunk)

# for controlling
inp=""

# Pulling Data (Output)
whileinpin ("e", "E"):
print(f"{format(pull(), '#04x')}")
print(buffer_space)
print(params_space)
inp=input("(e)exit? ").strip()
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
"""example of simple chaos machine"""

# Chaos Machine (K, t, m)
K= [0.33, 0.44, 0.55, 0.44, 0.33]
t=3
m=5

# Buffer Space (with Parameters Space)
buffer_space: list[float] = []
params_space: list[float] = []

# Machine Time
machine_time=0


defpush(seed):
globalbuffer_space, params_space, machine_time, K, m, t

# Choosing Dynamical Systems (All)
forkey, valueinenumerate(buffer_space):
# Evolution Parameter
e=float(seed/value)

# Control Theory: Orbit Change
value= (buffer_space[(key+1) %m] +e) %1

# Control Theory: Trajectory Change
r= (params_space[key] +e) %1+3

# Modification (Transition Function) - Jumps
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] =r# Saving to Parameters Space

# Logistic Map
assertmax(buffer_space) <1
assertmax(params_space) <4

# Machine Time
machine_time+=1


defpull():
globalbuffer_space, params_space, machine_time, K, m, t

# PRNG (Xorshift by George Marsaglia)
defxorshift(x, y):
x^=y>>13
y^=x<<17
x^=y>>5
returnx

# Choosing Dynamical Systems (Increment)
key=machine_time%m

# Evolution (Time Length)
for_inrange(t):
# Variables (Position + Parameters)
r=params_space[key]
value=buffer_space[key]

# Modification (Transition Function) - Flow
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] = (machine_time*0.01+r*1.01) %1+3

# Choosing Chaotic Data
x=int(buffer_space[(key+2) %m] * (10**10))
y=int(buffer_space[(key-2) %m] * (10**10))

# Machine Time
machine_time+=1

returnxorshift(x, y) %0xFFFFFFFF


defreset():
globalbuffer_space, params_space, machine_time, K, m, t

buffer_space=K
params_space= [0] *m
machine_time=0


if__name__=="__main__":
# Initialization
reset()

# Pushing Data (Input)
importrandom

message=random.sample(range(0xFFFFFFFF), 100)
forchunkinmessage:
push(chunk)

# for controlling
inp=""

# Pulling Data (Output)
whileinpin ("e", "E"):
print(f"{format(pull(), '#04x')}")
print(buffer_space)
print(params_space)
inp=input("(e)exit? ").strip()
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
"""example of simple chaos machine"""

# Chaos Machine (K, t, m)
K= [0.33, 0.44, 0.55, 0.44, 0.33]
t=3
m=5

# Buffer Space (with Parameters Space)
buffer_space: list[float] = []
params_space: list[float] = []

# Machine Time
machine_time=0


defpush(seed):
globalbuffer_space, params_space, machine_time, K, m, t

# Choosing Dynamical Systems (All)
forkey, valueinenumerate(buffer_space):
# Evolution Parameter
e=float(seed/value)

# Control Theory: Orbit Change
value= (buffer_space[(key+1) %m] +e) %1

# Control Theory: Trajectory Change
r= (params_space[key] +e) %1+3

# Modification (Transition Function) - Jumps
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] =r# Saving to Parameters Space

# Logistic Map
assertmax(buffer_space) <1
assertmax(params_space) <4

# Machine Time
machine_time+=1


defpull():
globalbuffer_space, params_space, machine_time, K, m, t

# PRNG (Xorshift by George Marsaglia)
defxorshift(x, y):
x^=y>>13
y^=x<<17
x^=y>>5
returnx

# Choosing Dynamical Systems (Increment)
key=machine_time%m

# Evolution (Time Length)
for_inrange(t):
# Variables (Position + Parameters)
r=params_space[key]
value=buffer_space[key]

# Modification (Transition Function) - Flow
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] = (machine_time*0.01+r*1.01) %1+3

# Choosing Chaotic Data
x=int(buffer_space[(key+2) %m] * (10**10))
y=int(buffer_space[(key-2) %m] * (10**10))

# Machine Time
machine_time+=1

returnxorshift(x, y) %0xFFFFFFFF


defreset():
globalbuffer_space, params_space, machine_time, K, m, t

buffer_space=K
params_space= [0] *m
machine_time=0


if__name__=="__main__":
# Initialization
reset()

# Pushing Data (Input)
importrandom

message=random.sample(range(0xFFFFFFFF), 100)
forchunkinmessage:
push(chunk)

# for controlling
inp=""

# Pulling Data (Output)
whileinpin ("e", "E"):
print(f"{format(pull(), '#04x')}")
print(buffer_space)
print(params_space)
inp=input("(e)exit? ").strip()
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
"""example of simple chaos machine"""

# Chaos Machine (K, t, m)
K= [0.33, 0.44, 0.55, 0.44, 0.33]
t=3
m=5

# Buffer Space (with Parameters Space)
buffer_space: list[float] = []
params_space: list[float] = []

# Machine Time
machine_time=0


defpush(seed):
globalbuffer_space, params_space, machine_time, K, m, t

# Choosing Dynamical Systems (All)
forkey, valueinenumerate(buffer_space):
# Evolution Parameter
e=float(seed/value)

# Control Theory: Orbit Change
value= (buffer_space[(key+1) %m] +e) %1

# Control Theory: Trajectory Change
r= (params_space[key] +e) %1+3

# Modification (Transition Function) - Jumps
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] =r# Saving to Parameters Space

# Logistic Map
assertmax(buffer_space) <1
assertmax(params_space) <4

# Machine Time
machine_time+=1


defpull():
globalbuffer_space, params_space, machine_time, K, m, t

# PRNG (Xorshift by George Marsaglia)
defxorshift(x, y):
x^=y>>13
y^=x<<17
x^=y>>5
returnx

# Choosing Dynamical Systems (Increment)
key=machine_time%m

# Evolution (Time Length)
for_inrange(t):
# Variables (Position + Parameters)
r=params_space[key]
value=buffer_space[key]

# Modification (Transition Function) - Flow
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] = (machine_time*0.01+r*1.01) %1+3

# Choosing Chaotic Data
x=int(buffer_space[(key+2) %m] * (10**10))
y=int(buffer_space[(key-2) %m] * (10**10))

# Machine Time
machine_time+=1

returnxorshift(x, y) %0xFFFFFFFF


defreset():
globalbuffer_space, params_space, machine_time, K, m, t

buffer_space=K
params_space= [0] *m
machine_time=0


if__name__=="__main__":
# Initialization
reset()

# Pushing Data (Input)
importrandom

message=random.sample(range(0xFFFFFFFF), 100)
forchunkinmessage:
push(chunk)

# for controlling
inp=""

# Pulling Data (Output)
whileinpin ("e", "E"):
print(f"{format(pull(), '#04x')}")
print(buffer_space)
print(params_space)
inp=input("(e)exit? ").strip()
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
"""example of simple chaos machine"""

# Chaos Machine (K, t, m)
K= [0.33, 0.44, 0.55, 0.44, 0.33]
t=3
m=5

# Buffer Space (with Parameters Space)
buffer_space: list[float] = []
params_space: list[float] = []

# Machine Time
machine_time=0


defpush(seed):
globalbuffer_space, params_space, machine_time, K, m, t

# Choosing Dynamical Systems (All)
forkey, valueinenumerate(buffer_space):
# Evolution Parameter
e=float(seed/value)

# Control Theory: Orbit Change
value= (buffer_space[(key+1) %m] +e) %1

# Control Theory: Trajectory Change
r= (params_space[key] +e) %1+3

# Modification (Transition Function) - Jumps
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] =r# Saving to Parameters Space

# Logistic Map
assertmax(buffer_space) <1
assertmax(params_space) <4

# Machine Time
machine_time+=1


defpull():
globalbuffer_space, params_space, machine_time, K, m, t

# PRNG (Xorshift by George Marsaglia)
defxorshift(x, y):
x^=y>>13
y^=x<<17
x^=y>>5
returnx

# Choosing Dynamical Systems (Increment)
key=machine_time%m

# Evolution (Time Length)
for_inrange(t):
# Variables (Position + Parameters)
r=params_space[key]
value=buffer_space[key]

# Modification (Transition Function) - Flow
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] = (machine_time*0.01+r*1.01) %1+3

# Choosing Chaotic Data
x=int(buffer_space[(key+2) %m] * (10**10))
y=int(buffer_space[(key-2) %m] * (10**10))

# Machine Time
machine_time+=1

returnxorshift(x, y) %0xFFFFFFFF


defreset():
globalbuffer_space, params_space, machine_time, K, m, t

buffer_space=K
params_space= [0] *m
machine_time=0


if__name__=="__main__":
# Initialization
reset()

# Pushing Data (Input)
importrandom

message=random.sample(range(0xFFFFFFFF), 100)
forchunkinmessage:
push(chunk)

# for controlling
inp=""

# Pulling Data (Output)
whileinpin ("e", "E"):
print(f"{format(pull(), '#04x')}")
print(buffer_space)
print(params_space)
inp=input("(e)exit? ").strip()
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
"""example of simple chaos machine"""

# Chaos Machine (K, t, m)
K= [0.33, 0.44, 0.55, 0.44, 0.33]
t=3
m=5

# Buffer Space (with Parameters Space)
buffer_space: list[float] = []
params_space: list[float] = []

# Machine Time
machine_time=0


defpush(seed):
globalbuffer_space, params_space, machine_time, K, m, t

# Choosing Dynamical Systems (All)
forkey, valueinenumerate(buffer_space):
# Evolution Parameter
e=float(seed/value)

# Control Theory: Orbit Change
value= (buffer_space[(key+1) %m] +e) %1

# Control Theory: Trajectory Change
r= (params_space[key] +e) %1+3

# Modification (Transition Function) - Jumps
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] =r# Saving to Parameters Space

# Logistic Map
assertmax(buffer_space) <1
assertmax(params_space) <4

# Machine Time
machine_time+=1


defpull():
globalbuffer_space, params_space, machine_time, K, m, t

# PRNG (Xorshift by George Marsaglia)
defxorshift(x, y):
x^=y>>13
y^=x<<17
x^=y>>5
returnx

# Choosing Dynamical Systems (Increment)
key=machine_time%m

# Evolution (Time Length)
for_inrange(t):
# Variables (Position + Parameters)
r=params_space[key]
value=buffer_space[key]

# Modification (Transition Function) - Flow
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] = (machine_time*0.01+r*1.01) %1+3

# Choosing Chaotic Data
x=int(buffer_space[(key+2) %m] * (10**10))
y=int(buffer_space[(key-2) %m] * (10**10))

# Machine Time
machine_time+=1

returnxorshift(x, y) %0xFFFFFFFF


defreset():
globalbuffer_space, params_space, machine_time, K, m, t

buffer_space=K
params_space= [0] *m
machine_time=0


if__name__=="__main__":
# Initialization
reset()

# Pushing Data (Input)
importrandom

message=random.sample(range(0xFFFFFFFF), 100)
forchunkinmessage:
push(chunk)

# for controlling
inp=""

# Pulling Data (Output)
whileinpin ("e", "E"):
print(f"{format(pull(), '#04x')}")
print(buffer_space)
print(params_space)
inp=input("(e)exit? ").strip()
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
"""example of simple chaos machine"""

# Chaos Machine (K, t, m)
K= [0.33, 0.44, 0.55, 0.44, 0.33]
t=3
m=5

# Buffer Space (with Parameters Space)
buffer_space: list[float] = []
params_space: list[float] = []

# Machine Time
machine_time=0


defpush(seed):
globalbuffer_space, params_space, machine_time, K, m, t

# Choosing Dynamical Systems (All)
forkey, valueinenumerate(buffer_space):
# Evolution Parameter
e=float(seed/value)

# Control Theory: Orbit Change
value= (buffer_space[(key+1) %m] +e) %1

# Control Theory: Trajectory Change
r= (params_space[key] +e) %1+3

# Modification (Transition Function) - Jumps
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] =r# Saving to Parameters Space

# Logistic Map
assertmax(buffer_space) <1
assertmax(params_space) <4

# Machine Time
machine_time+=1


defpull():
globalbuffer_space, params_space, machine_time, K, m, t

# PRNG (Xorshift by George Marsaglia)
defxorshift(x, y):
x^=y>>13
y^=x<<17
x^=y>>5
returnx

# Choosing Dynamical Systems (Increment)
key=machine_time%m

# Evolution (Time Length)
for_inrange(t):
# Variables (Position + Parameters)
r=params_space[key]
value=buffer_space[key]

# Modification (Transition Function) - Flow
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] = (machine_time*0.01+r*1.01) %1+3

# Choosing Chaotic Data
x=int(buffer_space[(key+2) %m] * (10**10))
y=int(buffer_space[(key-2) %m] * (10**10))

# Machine Time
machine_time+=1

returnxorshift(x, y) %0xFFFFFFFF


defreset():
globalbuffer_space, params_space, machine_time, K, m, t

buffer_space=K
params_space= [0] *m
machine_time=0


if__name__=="__main__":
# Initialization
reset()

# Pushing Data (Input)
importrandom

message=random.sample(range(0xFFFFFFFF), 100)
forchunkinmessage:
push(chunk)

# for controlling
inp=""

# Pulling Data (Output)
whileinpin ("e", "E"):
print(f"{format(pull(), '#04x')}")
print(buffer_space)
print(params_space)
inp=input("(e)exit? ").strip()
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
"""example of simple chaos machine"""

# Chaos Machine (K, t, m)
K= [0.33, 0.44, 0.55, 0.44, 0.33]
t=3
m=5

# Buffer Space (with Parameters Space)
buffer_space: list[float] = []
params_space: list[float] = []

# Machine Time
machine_time=0


defpush(seed):
globalbuffer_space, params_space, machine_time, K, m, t

# Choosing Dynamical Systems (All)
forkey, valueinenumerate(buffer_space):
# Evolution Parameter
e=float(seed/value)

# Control Theory: Orbit Change
value= (buffer_space[(key+1) %m] +e) %1

# Control Theory: Trajectory Change
r= (params_space[key] +e) %1+3

# Modification (Transition Function) - Jumps
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] =r# Saving to Parameters Space

# Logistic Map
assertmax(buffer_space) <1
assertmax(params_space) <4

# Machine Time
machine_time+=1


defpull():
globalbuffer_space, params_space, machine_time, K, m, t

# PRNG (Xorshift by George Marsaglia)
defxorshift(x, y):
x^=y>>13
y^=x<<17
x^=y>>5
returnx

# Choosing Dynamical Systems (Increment)
key=machine_time%m

# Evolution (Time Length)
for_inrange(t):
# Variables (Position + Parameters)
r=params_space[key]
value=buffer_space[key]

# Modification (Transition Function) - Flow
buffer_space[key] =round(float(r*value* (1-value)), 10)
params_space[key] = (machine_time*0.01+r*1.01) %1+3

# Choosing Chaotic Data
x=int(buffer_space[(key+2) %m] * (10**10))
y=int(buffer_space[(key-2) %m] * (10**10))

# Machine Time
machine_time+=1

returnxorshift(x, y) %0xFFFFFFFF


defreset():
globalbuffer_space, params_space, machine_time, K, m, t

buffer_space=K
params_space= [0] *m
machine_time=0


if__name__=="__main__":
# Initialization
reset()

# Pushing Data (Input)
importrandom

message=random.sample(range(0xFFFFFFFF), 100)
forchunkinmessage:
push(chunk)

# for controlling
inp=""

# Pulling Data (Output)
whileinpin ("e", "E"):
print(f"{format(pull(), '#04x')}")
print(buffer_space)
print(params_space)
inp=input("(e)exit? ").strip()