TypeScript Uint64.random方法代碼示例

    fragmentShaderTest({isPresent: 'uint', outLow: 'uint', outHigh: 'uint'}, tester => {
      let {gl, builder} = tester;
      let shaderManager = new HashMapShaderManager('h');
      shaderManager.defineShader(builder);
      builder.addUniform('highp uvec2', 'inputValue');
      builder.setFragmentMain(`
uint64_t key = unpackUint64leFromUint32(inputValue);
uint64_t value;
isPresent = uint(h_get(key, value));
outLow = value.value[0];
outHigh = value.value[1];
`);
      tester.build();
      let {shader} = tester;
      shader.bind();
      let hashTable = new HashMapUint64();
      let gpuHashTable = tester.registerDisposer(GPUHashTable.get(gl, hashTable));
      let testValues = new Array<Uint64>();
      while (testValues.length < COUNT) {
        let x = Uint64.random();
        if (hashTable.has(x)) {
          continue;
        }
        testValues.push(x);
        hashTable.set(x, Uint64.random());
      }
      let notPresentValues = new Array<Uint64>();
      notPresentValues.push(new Uint64(hashTable.emptyLow, hashTable.emptyHigh));
      while (notPresentValues.length < COUNT) {
        let x = Uint64.random();
        if (hashTable.has(x)) {
          continue;
        }
        notPresentValues.push(x);
      }
      function checkPresent(x: Uint64) {
        gl.uniform2ui(shader.uniform('inputValue'), x.low, x.high);
        shaderManager.enable(gl, shader, gpuHashTable);
        tester.execute();
        const {values} = tester;
        let expectedValue = new Uint64();
        let expectedHas = hashTable.get(x, expectedValue);
        const has = values.isPresent === 1;
        expect(has).toBe(expectedHas, `x=${x}`);
        if (has) {
          expect(values.outLow).toBe(expectedValue.low, `x=${x}, low`);
          expect(values.outHigh).toBe(expectedValue.high, `x=${x}, high`);
        }
      }
      testValues.forEach((x, i) => {
        expect(hashTable.has(x)).toBe(true, `cpu: i = ${i}, x = ${x}`);
        checkPresent(x);
      });
      notPresentValues.forEach(x => {
        checkPresent(x);
      });
    });

  it('HashSetUint64', () => {
    let ht = new HashSetUint64();
    let set = new Set<string>();

    function compareViaIterate() {
      let htValues = new Set<string>();
      for (let v of ht) {
        let s = v.toString();
        expect(htValues.has(s)).toBe(false, `Duplicate key in hash table: ${s}`);
        expect(set.has(s)).toBe(true, `Unexpected key ${s} in hash table`);
        htValues.add(s);
      }
      for (let s of set) {
        expect(htValues.has(s)).toBe(true, `Hash table is missing key ${s}`);
      }
    }

    function compareViaHas() {
      for (let s of set) {
        let k = Uint64.parseString(s);
        expect(ht.has(k)).toBe(true, `Hash table is missing key ${s}`);
      }
    }

    function compare() {
      compareViaIterate();
      compareViaHas();
    }
    let numInsertions = 100;

    function testInsert(k: Uint64) {
      let s = '' + k;
      set.add(s);
      expect(ht.has(k)).toBe(false, `Unexpected positive has result for ${[k.low, k.high]}`);
      ht.add(k);
      compare();
    }

    let empty0 = new Uint64(ht.emptyLow, ht.emptyHigh);
    testInsert(empty0);

    for (let i = 0; i < numInsertions; ++i) {
      let k: Uint64;
      let s: string;
      while (true) {
        k = Uint64.random();
        s = k.toString();
        if (!set.has(s)) {
          break;
        }
      }
      testInsert(k);
    }

    let empty1 = new Uint64(ht.emptyLow, ht.emptyHigh);
    testInsert(empty1);

  });

    fragmentShaderTest(3 * 2, tester => {
      let {gl, builder} = tester;
      let hashTableShaderManager = new HashSetShaderManager('h');
      hashTableShaderManager.defineShader(builder);
      builder.addUniform('vec4', 'inputValue', 2);
      let s = `
uint64_t x;
x.low = inputValue[0];
x.high = inputValue[1];
`;
      {
        let outputNumber = 0;
        for (let alt = 0; alt < 3; ++alt) {
          for (let i = 0; i < 2; ++i) {
            builder.addOutputBuffer('vec4', `v4f_fragData${outputNumber}`, outputNumber);
            s += `
v4f_fragData${outputNumber++} = packFloatIntoVec4(h_computeHash_${alt}_${i}(x));
`;
          }
        }
      }
      builder.setFragmentMain(s);
      tester.build();
      let {shader} = tester;
      shader.bind();

      let hashTable = new HashSetUint64();
      let gpuHashTable = tester.registerDisposer(GPUHashTable.get(gl, hashTable));
      for (let i = 0; i < COUNT; ++i) {
        let x = Uint64.random();
        let temp = new Uint32Array(2);
        temp[0] = x.low;
        temp[1] = x.high;
        let inputValue = encodeBytesToFloat32(temp);
        gl.uniform4fv(shader.uniform('inputValue'), inputValue);
        hashTableShaderManager.enable(gl, shader, gpuHashTable);
        tester.execute();
        let outputNumber = 0;
        for (let alt = 0; alt < 3; ++alt) {
          let output0 = tester.readFloat(outputNumber++);
          let output1 = tester.readFloat(outputNumber++);
          let hashes = hashTable.hashFunctions[alt];
          let {width, height} = hashTable;
          let expected0 = ((hashes[0].compute(x.low, x.high) % width) + 0.25) / width;
          let expected1 = ((hashes[1].compute(x.low, x.high) % height) + 0.5) / height;
          expect(expected0).toBeCloseTo(output0, 1e-6, `x = ${[x.low, x.high]}, alt = ${alt}`);
          expect(expected1).toBeCloseTo(output1, 1e-6);
        }
      }

    });

    fragmentShaderTest(3, tester => {
      const shaderManager = new SegmentColorShaderManager('getColor');
      let {gl, builder} = tester;
      shaderManager.defineShader(builder);
      builder.addUniform('highp vec4', 'inputValue', 2);
      const colorHash = SegmentColorHash.getDefault();
      builder.addOutputBuffer('vec4', 'v4f_fragData0', 0);
      builder.addOutputBuffer('vec4', 'v4f_fragData1', 1);
      builder.addOutputBuffer('vec4', 'v4f_fragData2', 2);
      builder.setFragmentMain(`
uint64_t x;
x.low = inputValue[0];
x.high = inputValue[1];

highp vec3 color = getColor(x);
v4f_fragData0 = packFloatIntoVec4(color.x);
v4f_fragData1 = packFloatIntoVec4(color.y);
v4f_fragData2 = packFloatIntoVec4(color.z);
`);
      tester.build();
      let {shader} = tester;
      shader.bind();
      shaderManager.enable(gl, shader, colorHash);

      function testValue(x: Uint64) {
        let temp = new Uint32Array(2);
        temp[0] = x.low;
        temp[1] = x.high;
        let inputValue = encodeBytesToFloat32(temp);
        gl.uniform4fv(shader.uniform('inputValue'), inputValue);
        tester.execute();

        let actual = new Float32Array(3);
        for (let i = 0; i < 3; ++i) {
          actual[i] = tester.readFloat(i);
        }

        let expected = new Float32Array(3);
        colorHash.compute(expected, x);

        expect(actual).toEqual(expected, `x = ${x}`);
      }

      testValue(Uint64.parseString('0'));
      testValue(Uint64.parseString('8'));
      const COUNT = 100;
      for (let iter = 0; iter < COUNT; ++iter) {
        let x = Uint64.random();
        testValue(x);
      }
    });

 it('toString parseString round trip', () => {
   function check(x: Uint64, base: number) {
     let s = x.toString(base);
     let y = Uint64.parseString(s, base);
     expect(y.low).toBe(x.low);
     expect(y.high).toBe(x.high);
   }
   const count = 100;
   for (let base = 2; base <= 36; ++base) {
     for (let i = 0; i < count; ++i) {
       check(Uint64.random(), base);
     }
   }
 });

    fragmentShaderTest({outR: 'float', outG: 'float', outB: 'float'}, tester => {
      const shaderManager = new SegmentColorShaderManager('getColor');
      let {gl, builder} = tester;
      shaderManager.defineShader(builder);
      builder.addUniform('highp uvec2', 'inputValue');
      const colorHash = SegmentColorHash.getDefault();
      builder.addFragmentCode(glsl_unpackUint64leFromUint32);
      builder.setFragmentMain(`
uint64_t x = unpackUint64leFromUint32(inputValue);

highp vec3 color = getColor(x);
outR = color.r;
outG = color.g;
outB = color.b;
`);
      tester.build();
      let {shader} = tester;
      shader.bind();
      shaderManager.enable(gl, shader, colorHash);

      function testValue(x: Uint64) {
        gl.uniform2ui(shader.uniform('inputValue'), x.low, x.high);
        tester.execute();

        let actual = new Float32Array(3);
        for (let i = 0; i < 3; ++i) {
          actual[i] = tester.readFloat(i);
        }

        let expected = new Float32Array(3);
        colorHash.compute(expected, x);
        const {values} = tester;
        expect(values.outR).toBeCloseTo(expected[0]);
        expect(values.outG).toBeCloseTo(expected[1]);
        expect(values.outB).toBeCloseTo(expected[2]);
      }

      testValue(Uint64.parseString('0'));
      testValue(Uint64.parseString('8'));
      const COUNT = 100;
      for (let iter = 0; iter < COUNT; ++iter) {
        let x = Uint64.random();
        testValue(x);
      }
    });

  it('toString parseString round trip', () => {
    function check(x: Uint64, base: number) {
      let s = x.toString(base);
      let y = Uint64.parseString(s, base);
      expect(y.low).toBe(x.low, `s=${s}, x.low=${x.low}, x.high=${x.high}, y.low=${y.low}, y.high=${y.high}, base=${base}`);
      expect(y.high).toBe(x.high, `s=${s}, x.low=${x.low}, x.high=${x.high}, y.low=${y.low}, y.high=${y.high}, base=${base}`);
    }
    const count = 100;
    {
      const u = new Uint64(264762631, 2836123747);
      expect(u.toString(13)).toEqual('153c9125c642b111b8');
      check(u, 13);
    }

    for (let base = 2; base <= 36; ++base) {
      for (let i = 0; i < count; ++i) {
        check(Uint64.random(), base);
      }
    }
  });

    fragmentShaderTest(6, tester => {
      let {gl, builder} = tester;
      let hashTableShaderManager = new HashTableShaderManager('h');
      hashTableShaderManager.defineShader(builder);
      builder.addUniform('vec4', 'inputValue', 2);
      builder.addFragmentCode(glsl_exactDot);
      {
        let alt = 0, i = 0;
        let bIndex = alt * 4 + 2 * i;
        let aIndex = alt * 4 + 2 * i;
        let {aName, bName, numAlternatives} = hashTableShaderManager;

        let s = `
uint64_t x;
x.low = inputValue[0];
x.high = inputValue[1];

x.low *= 255.0;
x.high *= 255.0;
float modulus = ${bName}[${numAlternatives * 4 + i}];
float scalar = ${bName}[${numAlternatives * 4 + 3 + i}];
vec4 a0 = ${aName}[${aIndex}];
vec4 a1 = ${aName}[${aIndex + 1}];
float b = ${bName}[${bIndex}];
float c = ${bName}[${bIndex + 1}];

  float dotResult0 = exactDot(a0, x.low) + exactDot(a1, x.high);
  float dotResult = imod(dotResult0, modulus);
  float dotResult2 = imod(dotResult * dotResult, modulus);
  float y = imod(dotResult2 * c, modulus);
  float modResult = imod(dotResult + y + b, modulus);

gl_FragData[4] = packFloatIntoVec4(dotResult0);
gl_FragData[0] = packFloatIntoVec4(dotResult);
gl_FragData[1] = packFloatIntoVec4(dotResult2);
gl_FragData[5] = packFloatIntoVec4(dotResult * dotResult);
gl_FragData[2] = packFloatIntoVec4(y);
gl_FragData[3] = packFloatIntoVec4(modResult);
`;

        builder.setFragmentMain(s);
      }

      tester.build();
      let {shader} = tester;
      shader.bind();

      for (let k = 0; k < 20; ++k) {
        let hashTable = new HashTable();
        let gpuHashTable = tester.registerDisposer(GPUHashTable.get(gl, hashTable));

        for (let i = 0; i < COUNT; ++i) {
          let x = Uint64.random();
          let temp = new Uint32Array(2);
          temp[0] = x.low;
          temp[1] = x.high;
          let inputValue = encodeBytesToFloat32(temp);
          gl.uniform4fv(shader.uniform('inputValue'), inputValue);
          hashTableShaderManager.enable(gl, shader, gpuHashTable);
          tester.execute();
          let alt = 0;
          let i = 0;

          let dotResult0 = tester.readFloat(4);
          let dotResult = tester.readFloat(0);
          let dotResult2 = tester.readFloat(1);
          let dotResultSquared = tester.readFloat(5);
          let y = tester.readFloat(2);
          let modResult = tester.readFloat(3);
          let modulus = PRIME_MODULUS;

          let h = hashTable.hashFunctions[alt][i];
          let expectedDotResult0 = h.computeDotProduct(x.low, x.high);
          let expectedDotResult = expectedDotResult0 % modulus;
          let expectedDotResultSquared = expectedDotResult * expectedDotResult;
          let expectedDotResult2 = (expectedDotResult * expectedDotResult) % modulus;
          let expectedY = (expectedDotResult2 * h.c) % modulus;
          let expectedModResult = (dotResult + y + h.b + 0.25) % modulus;
          expect(dotResult0).toEqual(expectedDotResult0);
          expect(dotResult).toEqual(expectedDotResult);
          expect(dotResultSquared).toEqual(expectedDotResultSquared);
          expect((dotResult2 + modulus) % modulus)
              .toEqual(expectedDotResult2, `dotResult=${dotResult}`);
          expect((y + modulus) % modulus).toEqual(expectedY);
          expect(modResult).toEqual(expectedModResult);
        }

        gpuHashTable.dispose();
      }
    });