我需要一个javascript函数，它将两个坐标映射为0到1之间的伪随机值

其他要求：

• 函数的输入是两个数字，不一定是整数

• 速度是主要关注点；它应该尽可能快

• 不必是安全的，只要它的输出看起来足够随机

示例：

getValue(0,0) -> 0.326458921
getValue(100,30) -> 0.598713621
getValue(5.12687, 600.471536) -> 0.21458796

编辑

---

澄清一下：输出值应该是确定性的，但看起来是随机的。

不知道这是否符合您的需要，这只是我自发的想法（使用Java的String.hashCode（）的JavaScript实现，取自此网站：）

String.prototype.hashCode=函数（）{
var散列=0；
如果（this.length==0）返回哈希；
对于（i=0；ihash=（（hash您可以编写一个hash函数：

function hash(x, y) {
    // You cast the int parts and decimal parts of your entries as 16-bits signed integers.
    var xi = x & 0xFFFF;
    var xf = (((x-xi) * (1 << 16)) & 0xFFFF);
    var yi = y & 0xFFFF;
    var yf = (((y-yi) * (1 << 16)) & 0xFFFF);

    // You hash theses numbers
    var r1 = ((39769 * xi) & 0xFFFF);
    r1 = ((r1 + xf) * 23747) & 0xFFFF;
    r1 = ((r1 + yi) * 19073) & 0xFFFF;
    r1 = ((r1 + yf) * 25609) & 0xFFFF;

    var r2 = ((25609 * xf) & 0xFFFF);
    r2 = ((r2 + yf) * 39769) & 0xFFFF;
    r2 = ((r2 + xi) * 23747) & 0xFFFF;
    r2 = ((r2 + yi) * 19073) & 0xFFFF;

    // And returns a floating number between 0 and 1.
    return ((r1&0xFF)/(1<<24)) + ((r2&0xFFFF)/(1<<16));
}

最后一种方法使用WebGL
TypedArray
，它允许您访问条目的位，并有一种更好的散列方式。但是，根据我的经验，这确实较慢（在我的计算机上，第一种方法每秒调用8亿次，第二种方法仅调用200万次-关于信息，经典的随机函数是每秒调用2亿次），WebGL可能无法在所有浏览器上使用。
无符号整数散列（整数键）{
unsigned int hash(int key) {
    key +=~(key << 15);
    key ^=(key >> 10);
    key +=(key << 3);
    key ^=(key >> 6);
    key +=~(key << 11);
    key ^=(key >> 16);
    return key;
}

unsigned int localseed = hash(x^hash(y^baseSeed));

键+=~（键>10）；
键+=（键>6）；
键+=~（键>16）；
返回键；
}
unsigned int localseed=hash（x^hash（y^baseSeed））；

这使用了一个baseSeed值，但这是可选的。基本上是从x/y坐标创建一个散列。
澄清一下；你是在寻找散列函数吗？我想是的。但我希望它输出一个均匀分布在0和1之间的值。你尝试了什么，你在哪里卡住了？我们不会只为你编码！@user1542912，听起来像是你想要的不仅是确定性算法，而且每个输入集都有一个唯一的结果。是的-我不认为“随机”这个词在这里有位置：-）在我看来不是很随机
hash（0,0）//0.1536 hash（0,1）//0.1537 hash（0,2）//0.1538 hash（0,3）//0.1539
不应该是随机的。OP修改了要求，说它应该是确定性的。我是说伪随机的。从技术上讲，这也是确定性的，对吗？@user1542912是的，你的意思是
（0,0）
应该总是给出相同的结果，但是
（0,1）
将给出与
0,0
或
0,2
非常不同的结果，即“随机查找”，对吗？没错。正如你所指出的，这段代码似乎没有达到这个目的。谢谢你的回答！你能给我指一个解释这种算法的好资源吗？数字39769，23747…从哪里来？至少当输出量化到0-255整数范围（用于输出颜色）时是这样的，它似乎有一个很短很明显的模式：：(
var arrayBuffer = new ArrayBuffer(8);
var dataView = new DataView(arrayBuffer);

function hash(x, y) {
    dataView.setFloat32(0, x);
    dataView.setFloat32(4, y);

    var xi = dataView.getUint16(0);
    var xf = dataView.getUint16(2);
    var yi = dataView.getUint16(4);
    var yf = dataView.getUint16(6);

    // You hash theses numbers
    var r1 = ((39769 * xi) & 0xFFFF);
    r1 = ((r1 + xf) * 23747) & 0xFFFF;
    r1 = ((r1 + yi) * 19073) & 0xFFFF;
    r1 = ((r1 + yf) * 25609) & 0xFFFF;

    var r2 = ((25609 * xf) & 0xFFFF);
    r2 = ((r2 + yf) * 39769) & 0xFFFF;
    r2 = ((r2 + xi) * 23747) & 0xFFFF;
    r2 = ((r2 + yi) * 19073) & 0xFFFF;

    // And returns a floating number between 0 and 1.
    dataView.setUint16(0, r1);
    dataView.setUint16(2, r2);
    return Math.abs(dataView.getFloat32(0) % 1);
}

unsigned int hash(int key) {
    key +=~(key << 15);
    key ^=(key >> 10);
    key +=(key << 3);
    key ^=(key >> 6);
    key +=~(key << 11);
    key ^=(key >> 16);
    return key;
}

unsigned int localseed = hash(x^hash(y^baseSeed));