30:Tef6,ints = (randomise,Uint32Array.from({length:2**10},()=>((0+(Math.random()/*Math.random()*/))*2**10)|0)) /*[403,29,175,363,597,204,41,5,372,52,461,16,224,536,330,307,406,57,749,400,438,162,393,78,512,125,103,169,142,102,602,3,14,102,72,158,458,460,8,31,255,165,336,591,399,470,0,61,296,58,336,72,439,21,103,30,99,195,96,402,193,543,33,1,211,150,226,769,227,340,986,19,547,202,179,504,610,30,185,30,52,17,111,190,22,45,420,47,349,116,115,155,241,100,398,735,261,134,700,383,523,172,7,309,669,261,44,154,516,110,297,162,732,106,45,315,22,16,199,201,700,364,302,56,392,261,437,425,184,2,493,117,299,54,240,165,275,101,356,130,153,172,12,14,116,184,9,405,47,59,487,57,98,60,635,215,497,365,213,306,721,259,113,184,569,641,327,16,112,18,525,752,178,275,21,19,196,113,7,71,9,510,419,306,980,133,362,90,272,689,94,109,235,215,638,16,27,29,475,326,713,21,540,25,406,89,21,298,184,81,516,613,634,602,25,223,481,148,73,222,21,310,137,105,73,278,40,112,254,147,11,343,71,308,101,388,350,688,47,95,340,23,149,555,101,40,115,494,322,444,12,595,112,216,94,94,186,797,196,182,22,162,321,79,122,7,39,416,35,312,159,49,129,126,291,99,491,193,290,82,117,158,843,93,85,251,16,23,2,155,903,7,45,41,512,472,169,24,289,696,2,238,342,457,28,90,124,21,20,153,333,41,334,242,136,579,346,106,511,408,282,16,170,29,157,132,442,42,229,293,487,57,87,117,456,274,359,188,714,147,238,183,30,54,111,41,177,234,340,46,35,427,245,21,220,136,702,81,87,580,674,1,466,263,93,183,106,123,192,244,120,143,44,338,614,89,9,695,101,908,706,356,7,556,70,83,21,600,398,550,299,10,18,10,210,541,146,235,321,6,31,131,94,135,11,40,599,71,695,537,608,789,14,106,188,354,112,43,11,495,175,35,33,98,0,150,155,411,170,176,26,677,718,47,9,816,443,794,632,659,203,60,141,402,704,464,146,163,225,316,7,763,170,73,15,60,311,96,202,26,22,349,269,134,12,784,374,137,752,17,220,366,117,45,13,164,104,141,235,654,648,199,239,528,257,4,718,284,342,378,421,58,20,94,116,41,160,173,309,71,339,0,325,58,195,711,333,236,17,17,360,214,502,220,38,187,521,93,753,410,31,143,404,47,201,55,487,14,218,363,381,159,24,121,55,106,235,491,140,388,77,103,459,336,96,316,1,3,453,118,4,347,588,58,510,176,119,165,685,147,518,266,14,412,183,89,13,103,179,47,479,497,498,321,433,280,41,1,567,105,695,59,591,134,169,366,736,105,50,265,313,522,621,11,491,418,270,136,32,133,595,325,486,75,15,250,533,808,676,109,606,666,149,251,13,474,398,790,401,737,387,240,496,490,446,400,384,284,173,292,27,406,64,18,378,21,696,187,194,563,196,7,24,9,78,65,576,365,28,43,208,45,1,61,530,22,3,236,145,73,14,286,59,199,608,4,296,699,225,34,40,72,22,29,257,5,127,99,252,779,126,36,211,17,677,360,135,275,57,268,48,549,18,12,32,75,191,62,419,52,45,753,231,13,48,185,2,223,28,35,118,165,306,23,974,463,183,93,41,9,45,51,344,6,458,322,355,425,261,529,172,475,201,235,83,0,107,7,474,242,123,757,434,393,162,113,711,25,695,570,263,148,247,144,0,109,70,215,270,185,785,88,0,32,312,42,11,646,637,535,66,253,418,428,214,44,952,571,78,79,342,477,446,355,257,115,92,262,11,116,75,604,167,376,109,43,434,480,1,131,447,22,179,51,702,93,243,386,735,606,290,85,412,347,218,89,242,956,162,407,105,65,387,495,233,543,167,230,341,180,493,279,68,396,20,35,184,345,84,6,5,88,142,28,338,99,242,686,389,45,233,699,51,0,28,273,174,23,439,170,79,454,697,730,10,705,206,230,165,431,35,317,71,273,538,71,409,318,329,546,717,138,414,191,83,81,119,32,271,0,243,92,455,65,149,203,363,60,274,96,158,15,175,278,333,531,218,102,115,737,877,54,349,103,390,234,313,105,861,191,8,225,379,87,86,365,263,135,0,120,118,214,287,127,446,13,282,331,27,360,474,62,190,469,21,50,92,192,531,136,129,99,724,495,149,137,461,20,436,2,55,191,246,311,472,369,414,75,258,40,531,283,623,27,193,0,186,407,192,432,52,305,535,78,43,55,39,523,18,176,515,281,735,111,72,685,270,93,190,200,449,16,246,571,27,96,132,575,154,23,433,475,115,524,18,105,212,265,48,100,203,547,375,694]*/31:T2ab5,QuickSet = class QuickSet { // NOTE THAT THIS IS A PROTOTYPING CLASS // NOT ALL METHODS CORRESPOND WITH GITHUB #view; #bits; constructor({ mode = "minsum" || "winsum", clip = 0 , span = 512 , // integer range min - max slot = 0 , high = 128 , // frequency slots + range freq = 1 , // minimum item cut frequency fifo = false } = {}) { if (span > 2**28) throw Error('Expected integers outside memory range'); if (high > (2**32)-1) throw Error('Expected frequency outside memory range'); if (slot > 64) throw Error('Rank slots performance degradation > 64'); if (span < slot) slot = span; this.constructor.prototype.sum = fifo ? new Function('return function ' +this[mode].toString().replaceAll('#','').replace('val>this.tmin','val>=this.tmin')).call() : this[mode] let [ Rank , mult ] = this.expects( span - 1 ), m = 2**(mult*8)-0; let [ Pool , byte ] = this.expects( high - 1 ), b = 2**(byte*8)-1; const data = new ArrayBuffer(byte*( span + 1 )); // range+1 to make inclusive // this.constructor.prototype.default = { Rank, Pool, mode , mult, byte }; // this.view = new Float64Array(data); this.rank = new Rank(slot); this.stat = new Pool(slot); this.#bits = new Pool(data); this.bits = this.#bits; this.span = span = Math.min(span,m); // clip integers above range extent (inclusive) this.clip = clip = Math.max(clip,0); // clip integers under range extent this.high = high = Math.min(high,b); // skip integers more frequent than (exclusive) this.freq = freq = Math.max(freq,0); // skip integers less frequent than this.slot = slot; // ranked integer slots this.last = slot - 1 ; // last item const this.tmin = freq //?? 0; // keeps track of min in window this.tmax = 0; // keeps track of max in window this.prev = -1; // WIP this.insRate = 0; this.upsRate = 0; this.all = 0; this.many = 0; // -> insertion rate feature this.tops = 0; // -> insertion rate feature this.temp = []; } invalid(input) { input >>>= 1; return (input ^ 0) !== input } minsum(uint, val = 1) { let invalid = this.invalid // range guard if( uint < this.clip || uint > this.span || invalid(uint) || invalid(val)) return var old = this.#bits[uint]; //let val = 1 + (this.#bits[uint]++) // => unweighted val = old + val; // count guard if( val > this.high ) { return } this.#bits[uint] = val; // this.all++ let rank = this.rank , stat = this.stat; if ( val>this.tmin && val > this.freq ) { var slot = this.slot; var last = this.last; //let idx = rank.indexOf(uint); // -> slower for (var idx = 0; idx < slot; ++idx) { if(rank[idx] == uint) { break } else if ( idx == last ) { idx = -1; break } } if (idx >= 0) { // this.tops++ stat[idx] = val; } else { // this.many++ var low = this.tmin; //var old = this.prev+1 // <-- FIFO = true //var pos; // <-- FIFO = true for (var ins = 0; ins < slot; ++ins) { //if(stat[pos = (ins + old) % slot] <= low ) { this.prev = ins = pos ; break } // <-- FIFO = true if(stat[ins] <= low ) { break } // <-- regular } rank[ins] = uint; stat[ins] = val; //if((this.tmin = lowest(stat)) < this.freq ) { this.tmin = this.freq } // => Math.max(lowest(stat),this.freq) this.tmin = this.lowest(stat) // TO DO: autotuning in case freq settings == 0 } if(val > this.tmax) this.tmax = val; //this.insRate = this.many/this.all; //this.upsRate = this.tops/this.all; // this.temp.push([this.insRate,this.upsRate]); } //return this } locsum() { // idea: update #bits location(s!) with position in rank array // and switch back when uint leaves the ranking -> turned out slightly complex with little speedup } winsum(uint,val = 1) { // range guard if( !Number.isInteger(uint) || uint < this.clip || uint > this.span || !Number.isInteger(val)) return var old = this.#bits[uint]; // val = 1 + (this.#bits[uint]++); // => unweighted val = old + val; // count guard if( val > this.high ) { return } this.#bits[uint] = val; let rank = this.rank , stat = this.stat ; if ( val>this.tmin && val > this.freq ) { var slot = this.slot; var idx, ins; for (let i = 0; i < slot; ++i) { if(idx >= 0 && ins >= 0 ) break if(idx == undefined && rank[i] == uint) idx = i; if(ins == undefined && stat[i] <= val) ins = i; } if(ins == undefined) return if ( idx >= 0 ) { if ( ins > idx ) return // TO DO: overwrite buffer when restarting count to prevent having to .fill(0) rank.copyWithin(ins+1,ins,idx); stat.copyWithin(ins+1,ins,idx); rank[ins] = uint; stat[ins] = val; } else { rank.copyWithin(ins+1,ins); stat.copyWithin(ins+1,ins); rank[ins] = uint; stat[ins] = val; this.tmin = stat[this.last] ?? 0 // min always last // Math.max(this.freq,stat[this.last]) // TO DO: autotuning in case freq settings == 0 } this.tmax = stat[0] ?? 0 // max is always first } } unique(...data) { if (typeof data[0] == "object" && data[0].length) { data = data[0] } let span = 8*Math.ceil(data.length * 0.125); for (var i = 0; i < span -7; i = i + 8) { this.add(data[i]); this.add(data[i+1]); this.add(data[i+2]); this.add(data[i+3]); this.add(data[i+4]); this.add(data[i+5]); this.add(data[i+6]); this.add(data[i+7]); } return this } batch(...data) { let vals, step; if ( typeof data[0] == "object" && data[0].length && typeof data[1] == "object" && data[1].length && data[2] == undefined ) { vals = data[1]; data = data[0]; step = vals.length; } else if (typeof data[0] == "object" && data[0].length && data[1] == undefined) { data = data[0]; } let span = data.length; if (vals) { for (var i = 0; i < span; i = i + 1) { let uint = data[i]; if (uint == undefined || uint < this.clip || uint > this.span) continue; this.sum(uint, vals[i % step]); } } else { for (var i = 0; i < span; i = i + 1) { let uint = data[i]; if (uint == undefined || uint < this.clip || uint > this.span) continue; this.sum(uint); } } return this } clear(slot) { this.#bits.fill(0); if (slot === true) { this.rank.fill(0); this.stat.fill(0) } else if (slot > 0) { this.slot = Math.max(slot,64); this.last = slot - 1; this.rank = new this.default.Rank(slot); this.stat = new this.default.Pool(slot); } this.tmin = this.freq; this.tmax = 0; } resize(slot) { if(slot > 0 && slot <= 64) { let rank = new this.default.Rank(slot); let stat = new this.default.Pool(slot); let span = Math.min(this.slot,slot); let prev = this.rank; let last = this.stat; for (let i = 0; i < span; ++i) { rank[i] = prev; stat[i] = last; } this.rank = rank; this.stat = stat; this.slot = slot; } else { throw new Error("Set window size between 0 an 64 inclusive.") } } add(uint, val = 1) { if ( uint < this.clip || uint > this.span || !Number.isInteger(uint) || !Number.isInteger(val)) return; if ( val > this.high) return; // prevent overflow this.bits[uint] = val; } get(uint) { return this.#bits[uint] } has(uint) { if (uint < this.clip || uint > this.span) return false return !!this.#bits[uint] } put(uint, val = 1) { // 'unsafe' add if (uint < this.clip || uint > this.span) return //this this.#bits[uint] = val } sum () { // placeholder } keys(iter) { let bits = this.#bits; let span = iter ?? this.#bits.length; let exit = new Uint32Array(this.span); let last = 0; for (let i = 0; i < span; ++i) { let key = bits[i] if (key) exit[last++] = i } return exit.subarray(0,last) } values(iter) { let bits = this.#bits; let span = iter ?? this.#bits.length; let exit = new Uint16Array(this.span); let last = 0; for (let i = 0; i < span; ++i) { let val = bits[i] if (val) exit[last++] = val } return exit.subarray(0,last) } delete(uint) { if (uint < this.clip || uint > this.span) return //this this.#bits[uint] = 0 } derank(uint) { if (uint < this.clip || uint > this.span) return //this this.#bits[uint] = 0; this.tmin = 0; let slot = this.slot; let rank = this.rank; let stat = this.stat; for (var idx = -1; idx < slot; ++idx) { if (rank[idx] == uint) { rank[idx] = 0; stat[idx] = 0; break } } if(idx >= 0 && this.default.mode == 'winsum') { let last = this.last; rank.copyWithin(idx,idx+1); stat.copyWithin(idx,idx+1); rank[last] = 0; stat[last] = 0; this.tmin = stat[last-1]; } } lowest(arr,min = Infinity) { let len = arr.length; for (let i = 0; i < len; ++i) { let val = arr[i] if(val < min) min = val } return min } sorted(iter) { let bits = this.#bits; let span = iter ?? this.#bits.length; let size = 0; for (var i = 0; i < span; i = i+1) { size = size + bits[i]; } let sort = new this.default.Rank(size); let last = 0; for (var i = 0; i < span; i = i+1) { let freq = bits[i]; if (freq===0) continue for (let j = 0; j < freq; j = j+1) { sort[last++] = i } } return sort } entries(iter) { let bits = this.#bits; let span = iter ?? this.#bits.length; let exit = new Array(this.span); let last = 0; for (let i = 0; i < span; ++i) { let val = bits[i] if (val > this.freq) exit[last++] = [i,val] } return exit.slice(0,last) } expects(int) { switch(true) { case int < (2** 8) : return [Uint8Array,1]; case int < (2**16) : return [Uint16Array,2]; case int < (2**32) : return [Uint32Array,4]; default : throw Error('Expected count out of range') } } default() { // placeholder } }32:T130a,FastSet = class { // previos bitwise implementation #HAS_DELS = 0; #MAX_BITS = 8; #DIV_BITS = 1/this.#MAX_BITS; #BIT_CLIP = 3; // 3 for 8 bit, 4 for 16 bit, 5 for 32 bit clear() { this.data.fill(0); //this.freq.fill(0); this.size = 0; } intersect(B) { let i = Math.min(this.span, B.span) let exit = [] while (--i) exit[i] = (this.data[i] & B.data[i]) return exit } constructor({ high = 1024, clip = 0 , bits = 8, history = false } = {}) { let span = Math.ceil(this.#DIV_BITS*high) this.data = new Uint8Array(span) // change type based on #MAX_BITS // this.nums = new Uint8Array(high); // this.freq = bits == 8 ? new Uint8ClampedArray(high) : bits == 16 ? new Uint16Array(high) : new Uint32Array(high) ; // change type on max expected count /*Object.defineProperties(this, { data: { value: new Uint8Array(Math.ceil(this.#DIV_BITS*high)),enumerable:true}, nums: { value: new Uint8Array(high)}, freq: { value: new Uint16Array(high)}, vals: { value: ()=>this.values.call(this),enumerable:false} })*/ if(history) this.hist = [] // this.proc = history ? [] : undefined; this.high = high; this.size = 0; // size counts all elements, including duplicates -> constructing an array 'overshoots' true set size this.span = span; this.clip = clip; } add(uint) { if(uint < this.clip || uint >= this.high) return // this let byte = 1 << (uint % this.#MAX_BITS); let index = uint >> 3//this.#BIT_CLIP //(uint * this.#DIV_BITS)|0; //if(this.data[index] & byte) return // this this.data[index] |= byte; //this.nums[uint] = 1 // swap '1' to 'uint' param when using sparse Array in constructor // this.freq[uint] = 1 // ++this.size; if(this.hist) this.#save(uint) //return this } has(uint) { if(uint < this.clip || uint >= this.high ) return false let byte = 1 << (uint % this.#MAX_BITS); let index = uint >> this.#BIT_CLIP;//(uint * this.#DIV_BITS)|0; return (this.data[index] & byte) !== 0 } sum(uint) { if(uint < this.clip || uint >= this.high) return // this let byte = 1 << (uint % this.#MAX_BITS); let index = uint >> this.#BIT_CLIP;//(uint * this.#DIV_BITS)|0; if(this.data[index] & byte) { this.freq[uint]++// 1; } else { this.data[index] |= byte; // this.nums[uint] = 1 // swap '1' for 'uint' param when using sparse Array in constructor this.freq[uint] = 0 //++this.size; } // if(this.hist) this.#save(uint) // return this } keys() { // commented methods for sparse Arrays // this.nums.length = this.high; // if(this.#HAS_DELS) return Object.values(this.nums).filter(Boolean) // return Object.values(this.nums) // let nums = this.nums; let span = this.freq.length; let exit = new Uint32Array(this.high/*size*/); let last = -1; for (let i = 0; i < span; ++i) { //let key = nums[i] if (this.has(i)) exit[++last] = i } return exit.subarray(0,last+1) } values() { // commented methods for sparse Arrays // this.freq.length = this.high; // if(this.#HAS_DELS) return Object.values(this.freq).filter(Boolean) // return Object.values(this.freq) //let nums = this.nums; let freq = this.freq; let span = this.freq.length; let exit = new Uint16Array(this.high/*size*/); // must return at least same type as freq array let last = -1; for (let i = 0; i < span; ++i) { //let key = nums[i] if (this.has(i)) exit[++last] = freq[i]+1; } return exit.subarray(0,last+1) } delete(uint) { if(uint < this.clip || uint >= this.high) return let byte = 1 << (uint % this.#MAX_BITS); let index = uint >> this.#BIT_CLIP; //(uint * this.#DIV_BITS)|0; if ((this.data[index] & byte) !== 0) { this.data[index] ^= byte this.freq[uint] = 0; --this.size; // this.#HAS_DELS = 1; if(this.hist) this.#save(-uint) } } entries() { //let nums = this.nums; let freq = this.freq; let span = this.freq.length; let exit = new Array(this.high /*size*/); let last = -1; for (let i = 0; i < span; ++i) { //let key = nums[i] if (this.has(i)) exit[++last] = [i,freq[i]+1] } return exit.slice(0,last+1) /*let keys = this.keys(); let vals = this.values(); let span = keys.length; let exit = Array(span); for (let i = 0; i < span; ++i) { exit[i] = [keys[i],vals[i]]; } return exit*/ } #save(uint) { this.hist.push(uint) // this.proc.push(0); } }33:[] 2e:{"title":"Fast Sorted Set","cells":[{"id":0,"value":"# Fast Sorted Set\n## TypedArray backed integer set operations","pinned":false,"hidden":false,"mode":"md"},{"id":7,"value":"___","pinned":false,"hidden":false,"mode":"md"},{"id":13530,"value":"Full version and source code available here: \n- https://www.npmjs.com/package/@suptxt/quickset\n- https://github.com/dleeftink/quickset","pinned":false,"hidden":false,"mode":"md"},{"id":13526,"value":"___","pinned":false,"hidden":false,"mode":"md"},{"id":11292,"value":"real = Array.from({length:4000},(_,i)=>\n Uint32Array.from({length:(-16+ ((1/((i+1)**0.5))* 1024)|1) }, //zipf like\n (_,i)=> (Math.random()*(2**8)|0)))","pinned":false,"hidden":false,"mode":"ojs"},{"id":13874,"value":"viewof randomise = Inputs.button(\"Randomise\")","pinned":false,"hidden":false,"mode":"ojs"},{"id":218,"value":"$30","pinned":false,"hidden":false,"mode":"ojs"},{"id":6456,"value":"viewof step = Inputs.range([0,2**10],{step:1,value:1024})","pinned":false,"hidden":false,"mode":"ojs"},{"id":6347,"value":"span = Math.min(ints.length,step)","pinned":false,"hidden":false,"mode":"ojs"},{"id":14431,"value":"data = { \n \n //let init = ints.slice(0)\n \n let t1 = performance.now()\n let set = new QS({span:2**10,high:32,slot:4,freq:1,mode:\"minsum\",fifo:false });\n //let span = ints.length;\n \n let iter = 10000;\n let temp = Array(iter); \n\n for (let n = 0; n < iter; ++n) {\n //let ints = real[n]\n //let span = ints.length;\n set.clear(true);\n\n // unrolling only works when multiples of two\n for (let i = 0; i < span; i = i + 2) {\n\n //let key = ints[i] //+ ( n % 255);\n set.sum(ints[i])\n set.sum(ints[i+1]);\n \n }\n \n \n //temp[n] = set.unique(ints).keys()//set.rank.slice(0)\n \n }\n\n //set = set.entries()//.sort((a,b)=>b[1]-a[1])\n return {\n t:performance.now()-t1,\n set,//temp\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":14957,"value":"ints2 = (randomise,Uint32Array.from({length:2**17.5},()=>((0+(Math.random()*Math.random()))*2**17.5)|0))","pinned":true,"hidden":false,"mode":"ojs"},{"id":14988,"value":"viewof step2 = Inputs.range([0,ints2.length],{step:1,value:ints2.length})","pinned":false,"hidden":false,"mode":"ojs"},{"id":14976,"value":"temp = {\n let span = ints2.length;\n let set = new QuickSet({\n span,\n freq:0,\n slot: 8,\n // fifo:true,\n mode:\"winsum\"\n })\n for (let i = 0; i < step2; ++i) {\n set.sum(ints2[i])\n }\n \n return [...[...set.rank].map((d,i)=>[d,set.stat[i]]),set.prev]\n \n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":13854,"value":"___\n\n### Implementation","pinned":false,"hidden":false,"mode":"md"},{"id":2364,"value":"$31","pinned":true,"hidden":false,"mode":"ojs"},{"id":13,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":13205,"value":"___","pinned":false,"hidden":false,"mode":"md"},{"id":13835,"value":"### Utils","pinned":false,"hidden":false,"mode":"md"},{"id":7218,"value":"// trying out a copyWithin alternative\n\nfunction shift(arr,to = 0,start = 0,end) {\n \n if(!end) end = arr.length\n\n let val;\n let i = end\n \n while(--i) {\n\n if(i<= start) break\n val = arr[i-to+start] \n \n if(val) arr[i] = val \n }\n\n //return arr\n \n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":2909,"value":"fastLen = (input) =>\n (input < 10) ? 1 : \n (input < 100) ? 2 : \n (input < 1000) ? 3 : \n (input < 10000) ? 4 : \n (input < 100000) ? 5 : \n (input < 1000000) ? 6 : \n (input < 10000000) ? 7 : \n (input < 100000000) ? 8 : \n (input < 1000000000) ? 9 : \n (input < 10000000000) ? 10 : \n (input < 100000000000) ? 11 : \n (input < 1000000000000) ? 12 : \n (input < 10000000000000) ? 13 : \n (input < 100000000000000) ? 14 : \n (input < 1000000000000000) ? 15 : 16","pinned":false,"hidden":false,"mode":"ojs"},{"id":13429,"value":"rewrite = (func, rgx, rep) => new Function('return function ' +func.toString().replace(rgx,rep)).call();","pinned":true,"hidden":false,"mode":"ojs"},{"id":9785,"value":"function getRightBit(n) {\n return Math.log2(n & -n) + 1\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":9762,"value":"function hash(x) {\n x = ((x >> 16) ^ x) * 0x45d9f3b;\n x = ((x >> 16) ^ x) * 0x45d9f3b;\n x = (x >> 16) ^ x;\n return x;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":13845,"value":"___\n\n### Playground","pinned":false,"hidden":false,"mode":"md"},{"id":2192,"value":"setOps = {\n let Abuf = new ArrayBuffer(128,{maxByteLength:256});\n let Abit = new Uint8Array(Abuf);\n let Aset = new Float64Array(Abuf);\n let Ahis = new Uint32Array(128)\n let Alen = 0\n\n let a = 1; Abit[a] = 230; Ahis[++Alen] = a;\n a = 0; Abit[a] = 1; Ahis[++Alen] = a;\n\n let Bbuf = new ArrayBuffer(128,{maxByteLength:256});\n let Bbit = new Uint8Array(Bbuf)\n let Bset = new Float64Array(Bbuf);\n let Bhis = new Uint32Array(128);\n let Blen = 0\n \n let b = 1; Bbit[b] = 25; Bhis[++Blen] = b;\n b = 0; Bbit[b] = 1; Bhis[++Blen] = b;\n // b = 9; Bbit[b] = 1; Bhis[++Blen] = b;\n\n let iter = Math.max(Alen,Blen);\n let out = 0\n for (let i = 0; i < iter; ++i) {\n let num = Ahis[i];\n //out += (Aset[num] | Bset[num]) == Bset[num]\n Aset[num] |= Bset[num]\n \n }\n\n //Abuf.resize(0); Abuf.resize(128);\n //Bbuf.resize(0); Bbuf.resize(128);\n \n \n return [Abit,Bbit,Aset,Bset,Alen,Blen]\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":13200,"value":"QS = (await import('https://cdn.skypack.dev/@suptxt/quickset@0.4.6?min')).default","pinned":true,"hidden":false,"mode":"ojs"},{"id":13717,"value":"{\n let t1 = performance.now()\n let set = new QS({\n span:2**10,\n slot:8,\n freq:3,\n //lifo:true\n })\n let span = 10000\n let temp = Array(span)\n let turn = 0;\n for (var i = 0; i < span; ++i) {\n set.clear(true);\n for (var j = 0; j<1024; ++j) {\n var uint = ints[j];\n var val = set.get(uint);\n if(val==3) break;\n set.put(uint,val+1);\n }\n turn = j\n\n for (/*var j = 0*/; j<1024; ++j) {\n var uint = ints[j];\n set.sum(uint);\n }\n temp[i] = set.top()\n }\n \n return {\n t: performance.now()-t1,\n set,turn,temp\n }\n\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":15482,"value":"{\n let t1 = performance.now()\n\n let out = new QS({span:1, high:(2**32)-1,freq:0})\n\n out.put(0,(2**32)-1)\n \n out = out.entries()\n \n return {\n t: performance.now()-t1,\n out\n }\n}","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W33","stdlib":"1","titling":"auto"}