braid-text 0.0.27 → 0.0.28

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.js CHANGED
@@ -252,12 +252,10 @@ braid_text.get = async (key, options) => {
252
252
  body: "",
253
253
  })
254
254
 
255
- updates = OpLog_get_patches(resource.doc.toBytes(), resource.doc.getOpsSince([]))
255
+ updates = dt_get_patches(resource.doc)
256
256
  } else {
257
257
  // Then start the subscription from the parents in options
258
- let local_version = OpLog_remote_to_local(resource.doc, options.parents || options.version)
259
-
260
- updates = OpLog_get_patches(resource.doc.getPatchSince(local_version), resource.doc.getOpsSince(local_version))
258
+ updates = dt_get_patches(resource.doc, options.parents || options.version)
261
259
  }
262
260
 
263
261
  for (let u of updates) {
@@ -343,8 +341,7 @@ braid_text.put = async (key, options) => {
343
341
  if (!options.validate_already_seen_versions) return
344
342
 
345
343
  // if we have seen it already, make sure it's the same as before
346
- let local_version = OpLog_remote_to_local(resource.doc, og_parents)
347
- let updates = OpLog_get_patches(resource.doc.getPatchSince(local_version), resource.doc.getOpsSince(local_version))
344
+ let updates = dt_get_patches(resource.doc, og_parents)
348
345
 
349
346
  let seen = {}
350
347
  for (let u of updates) {
@@ -415,7 +412,7 @@ braid_text.put = async (key, options) => {
415
412
  for (let p of patches) {
416
413
  // delete
417
414
  for (let i = p.range[0]; i < p.range[1]; i++) {
418
- bytes.push(OpLog_create_bytes(v, ps, p.range[1] - 1 + offset, null))
415
+ bytes.push(dt_create_bytes(v, ps, p.range[1] - 1 + offset, null))
419
416
  offset--
420
417
  ps = [v]
421
418
  v = decode_version(v)
@@ -424,7 +421,7 @@ braid_text.put = async (key, options) => {
424
421
  // insert
425
422
  for (let i = 0; i < p.content?.length ?? 0; i++) {
426
423
  let c = p.content[i]
427
- bytes.push(OpLog_create_bytes(v, ps, p.range[1] + offset, c))
424
+ bytes.push(dt_create_bytes(v, ps, p.range[1] + offset, c))
428
425
  offset++
429
426
  ps = [v]
430
427
  v = decode_version(v)
@@ -764,31 +761,30 @@ async function file_sync(key, process_delta, get_init) {
764
761
  //////////////////////////////////////////////////////////////////
765
762
  //////////////////////////////////////////////////////////////////
766
763
 
767
- function dt_get(doc, version) {
764
+ function dt_get(doc, version, agent = null) {
765
+ let bytes = doc.toBytes()
766
+ dt_get.last_doc = doc = Doc.fromBytes(bytes, agent)
767
+
768
+ let [_agents, versions, parentss] = dt_parse([...bytes])
769
+
768
770
  let frontier = {}
769
- version.forEach((x) => (frontier[x] = true))
771
+ version.forEach((x) => frontier[x] = true)
770
772
 
771
773
  let local_version = []
772
- let [agents, versions, parentss] = parseDT([...doc.toBytes()])
773
- for (let i = 0; i < versions.length; i++) {
774
- if (frontier[versions[i].join("-")]) {
775
- local_version.push(i)
776
- }
777
- }
778
- local_version = new Uint32Array(local_version)
774
+ for (let i = 0; i < versions.length; i++)
775
+ if (frontier[versions[i].join("-")]) local_version.push(i)
776
+ dt_get.last_local_version = local_version = new Uint32Array(local_version)
779
777
 
780
778
  let after_versions = {}
781
- let [_, after_versions_array, __] = parseDT([...doc.getPatchSince(local_version)])
779
+ let [_, after_versions_array, __] = dt_parse([...doc.getPatchSince(local_version)])
782
780
  for (let v of after_versions_array) after_versions[v.join("-")] = true
783
781
 
784
- let new_doc = new Doc()
782
+ let new_doc = new Doc(agent)
785
783
  let op_runs = doc.getOpsSince([])
784
+
786
785
  let i = 0
787
786
  op_runs.forEach((op_run) => {
788
- let parents = parentss[i].map((x) => x.join("-"))
789
- let start = op_run.start
790
- let end = start + 1
791
- let content = op_run.content?.[0]
787
+ if (op_run.content) op_run.content = [...op_run.content]
792
788
 
793
789
  let len = op_run.end - op_run.start
794
790
  let base_i = i
@@ -804,38 +800,48 @@ function dt_get(doc, version) {
804
800
  ) {
805
801
  for (; i < I; i++) {
806
802
  let version = versions[i].join("-")
807
- if (!after_versions[version]) {
808
- new_doc.mergeBytes(
809
- OpLog_create_bytes(
810
- version,
811
- parentss[i].map((x) => x.join("-")),
812
- content ? start + (i - base_i) : start,
813
- content?.[0]
814
- )
803
+ if (!after_versions[version]) new_doc.mergeBytes(
804
+ dt_create_bytes(
805
+ version,
806
+ parentss[i].map((x) => x.join("-")),
807
+ op_run.fwd ?
808
+ (op_run.content ?
809
+ op_run.start + (i - base_i) :
810
+ op_run.start) :
811
+ op_run.end - 1 - (i - base_i),
812
+ op_run.content?.[i - base_i]
815
813
  )
816
- }
817
- if (op_run.content) content = content.slice(1)
814
+ )
818
815
  }
819
- content = ""
820
816
  }
821
- if (op_run.content) content += op_run.content[j]
822
817
  }
823
818
  })
824
819
  return new_doc
825
820
  }
826
821
 
827
- function defrag_dt(doc) {
828
- let fresh_doc = new Doc("server")
829
- fresh_doc.mergeBytes(doc.toBytes())
830
- return fresh_doc
831
- }
822
+ function dt_get_patches(doc, version = null) {
823
+ let bytes = doc.toBytes()
824
+ doc = Doc.fromBytes(bytes)
825
+
826
+ let [_agents, versions, parentss] = dt_parse([...bytes])
827
+
828
+ let op_runs = []
829
+ if (version) {
830
+ let frontier = {}
831
+ version.forEach((x) => frontier[x] = true)
832
+ let local_version = []
833
+ for (let i = 0; i < versions.length; i++)
834
+ if (frontier[versions[i].join("-")]) local_version.push(i)
835
+ let after_bytes = doc.getPatchSince(new Uint32Array(local_version))
832
836
 
833
- function OpLog_get_patches(bytes, op_runs) {
834
- // console.log(`op_runs = `, op_runs);
837
+ ;[_agents, versions, parentss] = dt_parse([...after_bytes])
835
838
 
836
- let [agents, versions, parentss] = parseDT([...bytes])
839
+ let before_doc = dt_get(doc, version)
840
+ let before_doc_frontier = before_doc.getLocalVersion()
837
841
 
838
- // console.log(JSON.stringify({agents, versions, parentss}, null, 4))
842
+ before_doc.mergeBytes(after_bytes)
843
+ op_runs = before_doc.getOpsSince(before_doc_frontier)
844
+ } else op_runs = doc.getOpsSince([])
839
845
 
840
846
  let i = 0
841
847
  let patches = []
@@ -845,11 +851,11 @@ function OpLog_get_patches(bytes, op_runs) {
845
851
  let start = op_run.start
846
852
  let end = start + 1
847
853
  if (op_run.content) op_run.content = [...op_run.content]
848
- let content = op_run.content?.[0]
849
854
  let len = op_run.end - op_run.start
850
855
  for (let j = 1; j <= len; j++) {
851
856
  let I = i + j
852
857
  if (
858
+ (!op_run.content && op_run.fwd) ||
853
859
  j == len ||
854
860
  parentss[I].length != 1 ||
855
861
  parentss[I][0][0] != versions[I - 1][0] ||
@@ -857,30 +863,38 @@ function OpLog_get_patches(bytes, op_runs) {
857
863
  versions[I][0] != versions[I - 1][0] ||
858
864
  versions[I][1] != versions[I - 1][1] + 1
859
865
  ) {
866
+ let s = op_run.fwd ?
867
+ (op_run.content ?
868
+ start :
869
+ op_run.start) :
870
+ (op_run.start + (op_run.end - end))
871
+ let e = op_run.fwd ?
872
+ (op_run.content ?
873
+ end :
874
+ op_run.start + (end - start)) :
875
+ (op_run.end - (start - op_run.start))
860
876
  patches.push({
861
877
  version,
862
878
  parents,
863
879
  unit: "text",
864
- range: content ? `[${start}:${start}]` : `[${start}:${end}]`,
865
- content: content ?? "",
866
- start,
867
- end,
880
+ range: op_run.content ? `[${s}:${s}]` : `[${s}:${e}]`,
881
+ content: op_run.content?.slice(start - op_run.start, end - op_run.start).join("") ?? "",
882
+ start: s,
883
+ end: e,
868
884
  })
869
885
  if (j == len) break
870
886
  version = versions[I].join("-")
871
887
  parents = parentss[I].map((x) => x.join("-")).sort()
872
888
  start = op_run.start + j
873
- content = ""
874
889
  }
875
890
  end++
876
- if (op_run.content) content += op_run.content[j]
877
891
  }
878
892
  i += len
879
893
  })
880
894
  return patches
881
895
  }
882
896
 
883
- function parseDT(byte_array) {
897
+ function dt_parse(byte_array) {
884
898
  if (new TextDecoder().decode(new Uint8Array(byte_array.splice(0, 8))) !== "DMNDTYPS") throw new Error("dt parse error, expected DMNDTYPS")
885
899
 
886
900
  if (byte_array.shift() != 0) throw new Error("dt parse error, expected version 0")
@@ -975,8 +989,7 @@ function parseDT(byte_array) {
975
989
  return [agents, versions, parentss]
976
990
  }
977
991
 
978
- function OpLog_create_bytes(version, parents, pos, ins) {
979
- // console.log(`args = ${JSON.stringify({ version, parents, pos, ins }, null, 4)}`)
992
+ function dt_create_bytes(version, parents, pos, ins) {
980
993
 
981
994
  function write_varint(bytes, value) {
982
995
  while (value >= 0x80) {
@@ -1122,6 +1135,10 @@ function OpLog_create_bytes(version, parents, pos, ins) {
1122
1135
  return bytes
1123
1136
  }
1124
1137
 
1138
+ function defrag_dt(doc) {
1139
+ return Doc.fromBytes(doc.toBytes(), 'server')
1140
+ }
1141
+
1125
1142
  function OpLog_remote_to_local(doc, frontier) {
1126
1143
  let map = Object.fromEntries(frontier.map((x) => [x, true]))
1127
1144
 
@@ -1499,4 +1516,9 @@ function validate_patch(x) {
1499
1516
  braid_text.encode_filename = encode_filename
1500
1517
  braid_text.decode_filename = decode_filename
1501
1518
 
1519
+ braid_text.dt_get = dt_get
1520
+ braid_text.dt_get_patches = dt_get_patches
1521
+ braid_text.dt_parse = dt_parse
1522
+ braid_text.dt_create_bytes = dt_create_bytes
1523
+
1502
1524
  module.exports = braid_text
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "braid-text",
3
- "version": "0.0.27",
3
+ "version": "0.0.28",
4
4
  "description": "Library for collaborative text over http using braid.",
5
5
  "author": "Braid Working Group",
6
6
  "repository": "braid-org/braidjs",
package/server-demo.js CHANGED
@@ -64,7 +64,7 @@ var server = require("http").createServer(async (req, res) => {
64
64
  // }
65
65
 
66
66
  // Create some initial text for new documents
67
- if (await braid_text.get(req.url) === undefined) {
67
+ if (!(await braid_text.get(req.url, {})).version.length) {
68
68
  await braid_text.put(req.url, {body: 'This is a fresh blank document, ready for you to edit.' })
69
69
  }
70
70
 
package/test.js ADDED
@@ -0,0 +1,460 @@
1
+
2
+ let { Doc } = require("diamond-types-node")
3
+ let {dt_get, dt_get_patches, dt_parse, dt_create_bytes} = require('./index.js')
4
+
5
+ async function main() {
6
+ let best_seed = 0
7
+ let best_n = Infinity
8
+ let base = Math.floor(Math.random() * 10000000)
9
+
10
+ let og_log = console.log
11
+ console.log = () => {}
12
+ for (let t = 0; t < 50000; t++) {
13
+ let seed = base + t
14
+ // for (let t = 0; t < 1; t++) {
15
+ // let seed = 7271846
16
+
17
+ og_log(`t = ${t}, seed = ${seed}, best_n = ${best_n} @ ${best_seed}`)
18
+ Math.randomSeed(seed)
19
+
20
+ let n = Math.floor(Math.random() * 15)
21
+ console.log(`n = ${n}`)
22
+
23
+ try {
24
+ // 1. create a bunch of edits to a dt
25
+ let doc = new Doc('server')
26
+
27
+ for (let i = 0; i < n; i++) {
28
+ make_random_edit(doc)
29
+ }
30
+
31
+ // 2. let x = the resulting string
32
+ let x = doc.get()
33
+ console.log('x = ' + x)
34
+
35
+ // // 3. use the code for sending these edits over the wire to create a new dt
36
+ let updates = dt_get_patches(doc)
37
+ console.log(updates)
38
+
39
+ let new_doc = new Doc('server')
40
+ apply_updates(new_doc, updates)
41
+ let y = new_doc.get()
42
+ console.log('y = ' + y)
43
+
44
+ // 4. is the resulting string == x?
45
+ console.log(x == y)
46
+ if (x != y && n < best_n) {
47
+ best_n = n
48
+ best_seed = seed
49
+ }
50
+
51
+ // 5. test dt_get
52
+ let z = dt_get(doc, doc.getRemoteVersion().map(x => x.join('-'))).get()
53
+ console.log('z = ' + z)
54
+ console.log(x == z)
55
+ if (x != z && n < best_n) {
56
+ best_n = n
57
+ best_seed = seed
58
+ }
59
+
60
+ // 6. test dt_get_patches(doc, version)
61
+ if (true) {
62
+ let [_agents, versions, _parentss] = dt_parse([...doc.toBytes()])
63
+ let v = []
64
+ for (let i = 0; i < versions.length; i++)
65
+ if (Math.random() > 0.5) v.push(versions[i].join('-'))
66
+
67
+ console.log(`v:${v}`)
68
+
69
+ let temp_doc = dt_get(doc, v)
70
+ console.log(`temp_doc1:${temp_doc.get()}`)
71
+
72
+ let updates = dt_get_patches(doc, v)
73
+ console.log(`updates:`, updates)
74
+
75
+ apply_updates(temp_doc, updates)
76
+ console.log(`temp_doc2:${temp_doc.get()}`)
77
+ if (temp_doc.get() != doc.get() && n < best_n) {
78
+ best_n = n
79
+ best_seed = seed
80
+ }
81
+ }
82
+ } catch (e) {
83
+ if (n < best_n) {
84
+ best_n = n
85
+ best_seed = seed
86
+ }
87
+ }
88
+ }
89
+ og_log(`best_seed = ${best_seed}, best_n = ${best_n}`)
90
+ }
91
+
92
+ function make_random_edit(doc) {
93
+ let [agents, versions, _parentss] = dt_parse([...doc.toBytes()])
94
+
95
+ let agent = (agents.length && Math.random() > 0.5) ?
96
+ agents[Math.floor(Math.random() * agents.length)] :
97
+ Math.random().toString(36).slice(2)
98
+
99
+ let include_versions = []
100
+ let base_seq = -1
101
+ for (let i = 0; i < versions.length; i++) {
102
+ let [a, seq] = versions[i]
103
+ if (a == agent || Math.random() > 0.5) {
104
+ include_versions.push(a + '-' + seq)
105
+ if (a == agent && seq > base_seq) base_seq = seq
106
+ }
107
+ }
108
+ base_seq++
109
+
110
+ console.log({agents, versions, include_versions})
111
+
112
+ let parent_doc = dt_get(doc, include_versions)
113
+
114
+ let parents = parent_doc.getRemoteVersion().map(x => x.join('-'))
115
+
116
+ let len = parent_doc.len()
117
+ console.log(`len = ${len}`)
118
+
119
+ if (len && Math.random() > 0.5) {
120
+ // delete
121
+ let start = Math.floor(Math.random() * len)
122
+ let del_len = Math.floor(Math.random() * (len - start - 1)) + 1
123
+
124
+ for (let i = 0; i < del_len; i++) {
125
+ let v = `${agent}-${base_seq++}`
126
+ let args = [v, parents, start + del_len - 1 - i, null]
127
+ console.log(args)
128
+ doc.mergeBytes(dt_create_bytes(...args))
129
+ parents = [v]
130
+ }
131
+ } else {
132
+ // insert
133
+ let start = Math.floor(Math.random() * (len + 1))
134
+ let ins_len = Math.floor(Math.random() * 10) + 1
135
+
136
+ for (let i = 0; i < ins_len; i++) {
137
+ let v = `${agent}-${base_seq++}`
138
+ let args = [v, parents, start++, getRandomCharacter()]
139
+ console.log(args)
140
+ doc.mergeBytes(dt_create_bytes(...args))
141
+ parents = [v]
142
+ }
143
+ }
144
+
145
+ // work here
146
+ console.log(`doc => ${doc.get()}`)
147
+ }
148
+
149
+ function apply_updates(doc, updates) {
150
+ for (let u of updates) {
151
+ u.range = u.range.match(/\d+/g).map((x) => parseInt(x))
152
+ u.content = [...u.content]
153
+
154
+ let v = u.version
155
+ let ps = u.parents
156
+
157
+ console.log('UPDATE:', u)
158
+
159
+ // delete
160
+ for (let i = u.range[1] - 1; i >= u.range[0]; i--) {
161
+
162
+ // work here
163
+ let args = [v, ps, i, null]
164
+ console.log(`args`, args)
165
+
166
+ doc.mergeBytes(dt_create_bytes(...args))
167
+ ps = [v]
168
+ v = decode_version(v)
169
+ v = `${v[0]}-${v[1] + 1}`
170
+ }
171
+ // insert
172
+ for (let i = 0; i < u.content?.length ?? 0; i++) {
173
+ let c = u.content[i]
174
+
175
+ // work here
176
+ let args = [v, ps, u.range[0] + i, c]
177
+ console.log(`args`, args)
178
+
179
+ doc.mergeBytes(dt_create_bytes(...args))
180
+ ps = [v]
181
+ v = decode_version(v)
182
+ v = `${v[0]}-${v[1] + 1}`
183
+ }
184
+ }
185
+ }
186
+
187
+ //////////////////////////////////////////////////////////////////
188
+ //////////////////////////////////////////////////////////////////
189
+ //////////////////////////////////////////////////////////////////
190
+
191
+ function getRandomCharacter() {
192
+ const characters = [
193
+ // ASCII characters
194
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
195
+ 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
196
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
197
+ 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
198
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
199
+ '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '_', '+', '=',
200
+
201
+ // Unicode characters (each is a single code point)
202
+ 'α', 'β', 'γ', 'δ', 'ε', 'ζ', 'η', 'θ', // Greek letters
203
+ '零', '一', '二', '三', '四', '五', '六', '七', // Chinese numerals
204
+ '☀', '☁', '☂', '☃', '☄', '★', '☆', '☇', // Miscellaneous symbols
205
+ '🌈', '🌞', '🌝', '🌚', '🌕', '🌖', '🌗', '🌘', // Emoji (may be multiple UTF-16 units)
206
+ 'Ω', 'π', '∑', '√', '∫', '∀', '∂', '∃', // Mathematical symbols
207
+ 'あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', // Japanese Hiragana
208
+ 'ا', 'ب', 'ت', 'ث', 'ج', 'ح', 'خ', 'د', // Arabic letters
209
+ ];
210
+
211
+ const randomIndex = Math.floor(Math.random() * characters.length);
212
+ return characters[randomIndex];
213
+ }
214
+
215
+ function decode_version(v) {
216
+ let m = v.match(/^(.*)-(\d+)$/s)
217
+ if (!m) throw new Error(`invalid actor-seq version: ${v}`)
218
+ return [m[1], parseInt(m[2])]
219
+ }
220
+
221
+ /////////
222
+
223
+ // the next two functions added by me
224
+
225
+ function create_rand(seed) {
226
+ if (typeof (seed) == 'string') {
227
+ var t = new MersenneTwister(0)
228
+ var a = []
229
+ for (var i = 0; i < seed.length; i++)
230
+ a[i] = seed.charCodeAt(i)
231
+ t.init_by_array(a, a.length)
232
+ } else if (typeof (seed) == 'number') {
233
+ var t = new MersenneTwister(seed)
234
+ } else {
235
+ var t = new MersenneTwister()
236
+ }
237
+ return () => t.random()
238
+ }
239
+
240
+ Math.randomSeed = function (seed) {
241
+ var r = create_rand(seed)
242
+ Math.random = () => r()
243
+ }
244
+
245
+ /* The following piece of code is an implementation of MersenneTwister object
246
+ taken from https://gist.github.com/banksean/300494, with one method
247
+ xor_array(array, size) added.
248
+ */
249
+
250
+ /*
251
+ I've wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace
252
+ so it's better encapsulated. Now you can have multiple random number generators
253
+ and they won't stomp all over eachother's state.
254
+
255
+ If you want to use this as a substitute for Math.random(), use the random()
256
+ method like so:
257
+
258
+ var m = new MersenneTwister();
259
+ var randomNumber = m.random();
260
+
261
+ You can also call the other genrand_{foo}() methods on the instance.
262
+
263
+ If you want to use a specific seed in order to get a repeatable random
264
+ sequence, pass an integer into the constructor:
265
+
266
+ var m = new MersenneTwister(123);
267
+
268
+ and that will always produce the same random sequence.
269
+
270
+ Sean McCullough (banksean@gmail.com)
271
+ */
272
+
273
+ /*
274
+ A C-program for MT19937, with initialization improved 2002/1/26.
275
+ Coded by Takuji Nishimura and Makoto Matsumoto.
276
+
277
+ Before using, initialize the state by using init_genrand(seed)
278
+ or init_by_array(init_key, key_length).
279
+
280
+ Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
281
+ All rights reserved.
282
+
283
+ Redistribution and use in source and binary forms, with or without
284
+ modification, are permitted provided that the following conditions
285
+ are met:
286
+
287
+ 1. Redistributions of source code must retain the above copyright
288
+ notice, this list of conditions and the following disclaimer.
289
+
290
+ 2. Redistributions in binary form must reproduce the above copyright
291
+ notice, this list of conditions and the following disclaimer in the
292
+ documentation and/or other materials provided with the distribution.
293
+
294
+ 3. The names of its contributors may not be used to endorse or promote
295
+ products derived from this software without specific prior written
296
+ permission.
297
+
298
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
299
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
300
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
301
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
302
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
303
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
304
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
305
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
306
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
307
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
308
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
309
+
310
+
311
+ Any feedback is very welcome.
312
+ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
313
+ email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
314
+ */
315
+
316
+ var MersenneTwister = function (seed) {
317
+ if (seed == undefined) {
318
+ seed = new Date().getTime();
319
+ }
320
+ /* Period parameters */
321
+ this.N = 624;
322
+ this.M = 397;
323
+ this.MATRIX_A = 0x9908b0df; /* constant vector a */
324
+ this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
325
+ this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
326
+
327
+ this.mt = new Array(this.N); /* the array for the state vector */
328
+ this.mti = this.N + 1; /* mti==N+1 means mt[N] is not initialized */
329
+
330
+ this.init_genrand(seed);
331
+ }
332
+
333
+ /* initializes mt[N] with a seed */
334
+ MersenneTwister.prototype.init_genrand = function (s) {
335
+ this.mt[0] = s >>> 0;
336
+ for (this.mti = 1; this.mti < this.N; this.mti++) {
337
+ var s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
338
+ this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253)
339
+ + this.mti;
340
+ /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
341
+ /* In the previous versions, MSBs of the seed affect */
342
+ /* only MSBs of the array mt[]. */
343
+ /* 2002/01/09 modified by Makoto Matsumoto */
344
+ this.mt[this.mti] >>>= 0;
345
+ /* for >32 bit machines */
346
+ }
347
+ }
348
+
349
+ /* initialize by an array with array-length */
350
+ /* init_key is the array for initializing keys */
351
+ /* key_length is its length */
352
+ /* slight change for C++, 2004/2/26 */
353
+ MersenneTwister.prototype.init_by_array = function (init_key, key_length) {
354
+ var i, j, k;
355
+ this.init_genrand(19650218);
356
+ i = 1; j = 0;
357
+ k = (this.N > key_length ? this.N : key_length);
358
+ for (; k; k--) {
359
+ var s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30)
360
+ this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + ((s & 0x0000ffff) * 1664525)))
361
+ + init_key[j] + j; /* non linear */
362
+ this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
363
+ i++; j++;
364
+ if (i >= this.N) { this.mt[0] = this.mt[this.N - 1]; i = 1; }
365
+ if (j >= key_length) j = 0;
366
+ }
367
+ for (k = this.N - 1; k; k--) {
368
+ var s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
369
+ this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941))
370
+ - i; /* non linear */
371
+ this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
372
+ i++;
373
+ if (i >= this.N) { this.mt[0] = this.mt[this.N - 1]; i = 1; }
374
+ }
375
+
376
+ this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
377
+ }
378
+
379
+ /* XORs the mt array with a given array xor_key of length key_length */
380
+ MersenneTwister.prototype.xor_array = function (xor_key, key_length) {
381
+ var i, j;
382
+ j = 0;
383
+ for (i = 0; i < this.N; i++) {
384
+ this.mt[i] ^= xor_key[j];
385
+ this.mt[i] >>>= 0;
386
+ j++;
387
+ if (j >= key_length) j = 0;
388
+ }
389
+ }
390
+
391
+ /* generates a random number on [0,0xffffffff]-interval */
392
+ MersenneTwister.prototype.genrand_int32 = function () {
393
+ var y;
394
+ var mag01 = new Array(0x0, this.MATRIX_A);
395
+ /* mag01[x] = x * MATRIX_A for x=0,1 */
396
+
397
+ if (this.mti >= this.N) { /* generate N words at one time */
398
+ var kk;
399
+
400
+ if (this.mti == this.N + 1) /* if init_genrand() has not been called, */
401
+ this.init_genrand(5489); /* a default initial seed is used */
402
+
403
+ for (kk = 0; kk < this.N - this.M; kk++) {
404
+ y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
405
+ this.mt[kk] = this.mt[kk + this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
406
+ }
407
+ for (; kk < this.N - 1; kk++) {
408
+ y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
409
+ this.mt[kk] = this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
410
+ }
411
+ y = (this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK);
412
+ this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];
413
+
414
+ this.mti = 0;
415
+ }
416
+
417
+ y = this.mt[this.mti++];
418
+
419
+ /* Tempering */
420
+ y ^= (y >>> 11);
421
+ y ^= (y << 7) & 0x9d2c5680;
422
+ y ^= (y << 15) & 0xefc60000;
423
+ y ^= (y >>> 18);
424
+
425
+ return y >>> 0;
426
+ }
427
+
428
+ /* generates a random number on [0,0x7fffffff]-interval */
429
+ MersenneTwister.prototype.genrand_int31 = function () {
430
+ return (this.genrand_int32() >>> 1);
431
+ }
432
+
433
+ /* generates a random number on [0,1]-real-interval */
434
+ MersenneTwister.prototype.genrand_real1 = function () {
435
+ return this.genrand_int32() * (1.0 / 4294967295.0);
436
+ /* divided by 2^32-1 */
437
+ }
438
+
439
+ /* generates a random number on [0,1)-real-interval */
440
+ MersenneTwister.prototype.random = function () {
441
+ return this.genrand_int32() * (1.0 / 4294967296.0);
442
+ /* divided by 2^32 */
443
+ }
444
+
445
+ /* generates a random number on (0,1)-real-interval */
446
+ MersenneTwister.prototype.genrand_real3 = function () {
447
+ return (this.genrand_int32() + 0.5) * (1.0 / 4294967296.0);
448
+ /* divided by 2^32 */
449
+ }
450
+
451
+ /* generates a random number on [0,1) with 53-bit resolution*/
452
+ MersenneTwister.prototype.genrand_res53 = function () {
453
+ var a = this.genrand_int32() >>> 5, b = this.genrand_int32() >>> 6;
454
+ return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
455
+ }
456
+
457
+ /* These real versions are due to Isaku Wada, 2002/01/09 added */
458
+
459
+ ////////////////////////////////////////////////////////////////////
460
+ main()