Algorithm 基于坐标生成可重复的伪随机数

我需要基于一组坐标生成可重复的伪随机数，这样，对于给定的种子，我将始终为特定坐标生成相同的值

我想我会用这样的东西做种子：

/* 64bit seed value*/
struct seed_cord {
    uint16 seed;
    uint16 coord_x_int;
    uint16 coord_y_int;
    uint8  coord_x_frac;
    uint8  coord_y_frac;
}

其中，

coord\u x\u int

是坐标的整数部分，分数部分由

coord\u x\u frac/0xFF

给出<代码>种子是一个随机预先确定的值

但我必须承认，试图理解PRNG的所有复杂之处有点难以承受。对于我正在尝试的东西，什么是好的发电机

我在一个快速groovy脚本中使用此方案测试了Java的PRNG，结果如下：

显然，这不是一个像样的随机性

我使用的脚本是：

import java.awt.image.BufferedImage
import javax.imageio.ImageIO

short shortSeed = new Random().next(16) as short

def image = new BufferedImage(512, 512, BufferedImage.TYPE_BYTE_GRAY)
def raster = image.getRaster()

//x
(0..1).each{ x ->
(0..255).each{ xFrac ->
//y
(0..1).each{ y ->
(0..255).each{ yFrac ->

long seed = (shortSeed as long) << 48 |
            (x as long)         << 32 |
            (y as long)         << 16 |
            (xFrac as long)     <<  8 |
            (yFrac as long)

def value = new Random(seed).next(8)
raster.setSample( (x? xFrac+256 : xFrac), (y? yFrac+256 : yFrac), 0 , value)

}}}}

ImageIO.write(image, "PNG", new File("randomCoord.png"))

导入java.awt.image.buffereImage
导入javax.imageio.imageio
short shortSeed=new Random（）
def image=new BufferedImage（512，512，BufferedImage.TYPE\u BYTE\u GRAY）
def raster=image.getRaster（）
//x
（0..1）。每个{x->
（0..255）。每个{xFrac->
//y
（0..1）。每个{y->
（0..255）。每个{yFrac->
long seed=（shortSeed as long）大多数语言都有一个（或两个）PRNG包，可以使用特定的种子初始化生成器。PRNG通常也可以作为更大的加密包的一部分找到；它们往往比在通用库中找到的要强一些。
大多数语言都有一个（或两个）PRNG包这使您可以使用特定的种子初始化生成器。PRNG通常也可以作为更大的加密包的一部分找到；它们往往比在通用库中找到的更强大。
如果您真的只看512x512，那么您感兴趣的是呃…218像素

通过良好的OLEMD5（128位输出），有足够的空间容纳这类人群

如果你需要的是一个整数的输出，你可以取它的最低32位。实际上，任何一种输出空间至少和int一样大的哈希算法都可以

现在，如果你有妄想症，你可以做各种有趣的事情。首先对你的坐标进行散列，然后将结果输入一个安全的随机数生成器（java.security.SecureRandom）。然后用盐将其散列1000次，这是你的生日连在一起（x+y）次

开玩笑的是，随机数生成器不一定会根据种子的微小变化产生大范围变化的结果。它们的设计目的是在开始重复之前生成一个真正的、超级重复的长数字链，同时使这些链在数字空间中均匀分布

另一方面，SecureRandom被设计成具有额外的特性，即种子混乱。
如果你真的只看512x512，那么这就是你感兴趣的218像素

通过良好的OLEMD5（128位输出），有足够的空间容纳这类人群

如果你需要的是一个整数的输出，你可以取它的最低32位。实际上，任何一种输出空间至少和int一样大的哈希算法都可以

现在，如果你有妄想症，你可以做各种有趣的事情。首先对你的坐标进行散列，然后将结果输入一个安全的随机数生成器（java.security.SecureRandom）。然后用盐将其散列1000次，这是你的生日连在一起（x+y）次

开玩笑的是，随机数生成器不一定会根据种子的微小变化产生大范围变化的结果。它们的设计目的是在开始重复之前生成一个真正的、超级重复的长数字链，同时使这些链在数字空间中均匀分布

另一方面，SecureRandom被设计为具有种子混乱的附加功能。
我会使用我创建的程序，然后修改它以拾取坐标：

REM $DYNAMIC
COMMON SHARED n%, rbuf%, sz%, sw%, p1$
DECLARE SUB initialize ()
DECLARE SUB filbuf ()
DECLARE SUB setup ()
DECLARE FUNCTION Drnd# ()
DECLARE SUB core ()
DECLARE SUB modify ()
DIM SHARED pad1(340) AS STRING * 1
DIM SHARED trnsltr(66) AS STRING * 1 ' translates a 0-67 value into a pad character
DIM SHARED trnslt(255) AS INTEGER  'translates a pad value to 0-67 value -1 if error
DIM SHARED moders(26) AS INTEGER 'modding function prim number array
DIM SHARED moders2(26) AS INTEGER 'modding function prim number array
DIM SHARED ranbuf(1 TO 42) AS DOUBLE 'random number buffer if this is full and rbuf %>0
REM then this buffer is used to get new random values
REM rbuf% holds the index of the next random number to be used
REM subroutine setup loads the prime number table
REM from the data statements to be used
REM as modifiers in two different ways (or more)
REM subroutine initialize primes the pad array with initial values
REM transfering the values from a string into an array then
REM makes the first initial scrambling of this array
REM initializing pad user input phase:
CLS
INPUT "full name of file to be encrypted"; nam1$
INPUT "full name of output file"; nam2$
INPUT "enter password"; p2$
rbuf% = 0
n% = 0: sw% = 0
p3$ = STRING$(341, "Y")
p1$ = "Tfwd+-$wiHEbeMN<wjUHEgwBEGwyIEGWYrg3uehrnnqbwurt+>Hdgefrywre"
p1$ = p2$ + p1$ + p3$
PRINT "hit any key to continue any time after a display and after the graphic display"
p1$ = LEFT$(p1$, 341)
sz% = LEN(p1$)
CALL setup
CALL initialize
CLS
ibfr$ = STRING$(512, 32)
postn& = 1
OPEN nam1$ FOR BINARY AS #1
OPEN nam2$ FOR BINARY AS #2
g& = LOF(1)
max& = g&
sbtrct% = 512
WHILE g& > 0
LOCATE 1, 1
PRINT INT(1000 * ((max& - g&) / max&)) / 10; "% done";
IF g& < 512 THEN
ibfr$ = STRING$(g&, 32)
sbtrct% = g&
END IF
GET #1, postn&, ibfr$
FOR ste% = 1 TO LEN(ibfr$)
geh% = INT(Drnd# * 256)
MID$(ibfr$, ste%, 1) = CHR$(geh% XOR ASC(MID$(ibfr$, ste%, 1)))
NEXT ste%
PUT #2, postn&, ibfr$
postn& = postn& + sbtrct%
g& = g& - sbtrct%
WEND
CLOSE #2
CLOSE #1
PRINT "hit any key to exit"
i$ = ""
WHILE i$ = "": i$ = INKEY$: WEND
SYSTEM
END
DATA 3,5,7,9,11,13,17,19
DATA 23,29,33,37,43,47
DATA 53,59,67,71,73,79,83
DATA 89,91,97,101,107,109
DATA 43,45,60,62,36

REM $STATIC
SUB core
REM shuffling algorythinm
FOR a% = 0 TO 339
m% = (a% + 340) MOD 341: bez% = trnslt(ASC(pad1(340)))
IF n% MOD 3 = 0 THEN pad1(340) = trnsltr((2 * trnslt(ASC(pad1(a%))) + 67 -   trnslt(ASC(pad1(m%)))) MOD 67)
IF n% MOD 3 = 1 THEN pad1(340) = trnsltr((2 * (67 - trnslt(ASC(pad1(a%)))) + 67 - trnslt(ASC(pad1(m%)))) MOD 67)
IF n% MOD 3 = 2 THEN pad1(340) = trnsltr(((2 * trnslt(ASC(pad1(a%))) + 67 - trnslt(ASC(pad1(m%)))) + moders(n% MOD 27)) MOD 67)
pad1(a% + 1) = pad1(m%): n% = (n% + 1) MOD 32767
pad1(a%) = trnsltr((bez% + trnslt(ASC(pad1(m%)))) MOD 67)
NEXT a%
sw% = (sw% + 1) MOD 32767
END SUB

FUNCTION Drnd#
IF rbuf% = 0 THEN
CALL core
CALL filbuf
IF sw% = 32767 THEN CALL modify
END IF
IF rbuf% > 0 THEN yut# = ranbuf(rbuf%)
rbuf% = rbuf% - 1
Drnd# = yut#
END FUNCTION

SUB filbuf
q% = 42: temp# = 0
WHILE q% > 0
FOR p% = 1 TO 42
k% = (p% - 1) * 8
FOR e% = k% TO k% + 7
temp# = temp# * 67: hug# = ABS(trnslt(ASC(pad1(e%)))): temp# = temp# + hug#
NEXT e%
IF temp# / (67 ^ 8) >= 0 AND q% < 43 THEN
ranbuf(q%) = temp# / (67 ^ 8): q% = q% - 1
END IF
temp# = 0
NEXT p%
WEND
rbuf% = 42
END SUB

SUB initialize
FOR a% = 0 TO 340
pad1(a%) = MID$(p1$, a% + 1, 1)
NEXT a%
FOR a% = 0 TO 340
LOCATE 1, 1
IF a% MOD 26 = 0 THEN PRINT INT((340 - a%) / 26)
sum% = 0
FOR b% = 0 TO 340
qn% = INT(Drnd# * 81)
op% = INT(qn% / 3)
qn% = qn% MOD 3
IF qn% = 0 THEN sum% = sum% + trnslt(ASC(pad1(b%)))
IF qn% = 1 THEN sum% = sum% + (67 + 66 - trnslt(ASC(pad1(b%)))) MOD 67
IF qn% = 2 THEN sum% = sum% + trnslt(ASC(pad1(b%))) + moders(op%)
NEXT b%
pad1(a%) = trnsltr(sum% MOD 67)
NEXT a%
n% = n% + 1
END SUB

SUB modify
REM modifier shuffling routine
q% = 26
temp# = 0
WHILE q% > -1
FOR p% = 1 TO 27
k% = (p% - 1) * 4 + 3
FOR e% = k% TO k% + 3
temp# = temp# * 67
hug# = ABS(trnslt(ASC(pad1(e%))))
temp# = temp# + hug#
NEXT e%
IF (temp# / (67 ^ 4)) >= 0 AND q% > -1 THEN
SWAP moders(q%), moders(INT(27 * (temp# / (67 ^ 4))))
q% = q% - 1
END IF
temp# = 0
NEXT p%
WEND
END SUB

SUB setup
FOR a% = 0 TO 26
READ moders(a%)
moders2(a%) = moders(a%)
NEXT a%
REM setting up tables and modder functions
FOR a% = 0 TO 25
trnsltr(a%) = CHR$(a% + 97)
trnsltr(a% + 26) = CHR$(a% + 65)
NEXT a%
FOR a% = 52 TO 61
trnsltr(a%) = CHR$(a% - 4)
NEXT a%
FOR a% = 62 TO 66
READ b%
trnsltr(a%) = CHR$(b%)
NEXT a%
FOR a% = 0 TO 255
trnslt(a%) = -1
NEXT a%
FOR a% = 0 TO 66
trnslt(ASC(trnsltr(a%))) = a%
NEXT a%
RESTORE
END SUB

REM$DYNAMIC
公用共享n%、rbuf%、sz%、sw%、p1$
声明子初始化（）
声明子filbuf（）
声明子设置（）
声明函数Drnd#（）
声明子核心（）
声明子修改（）
DIM共享pad1（340）作为字符串*1
DIM SHARED trnsltr（66）作为字符串*1'将0-67值转换为填充字符
DIM SHARED trnslt（255）为整数“如果错误，则将焊盘值转换为0-67值-1
DIM共享模式（26）作为整型函数原数数组
DIM共享MODES2（26）作为整型函数原数数组
如果已满且rbuf%>0，则将DIM共享ranbuf（1到42）作为双随机数缓冲区
REM然后使用此缓冲区获取新的随机值
REM rbuf%保存下一个要使用的随机数的索引
REM子程序设置加载素数表
从要使用的数据语句中删除REM
REM以两种不同方式（或更多方式）作为修饰符
REM子例程initialize使用初始值初始化pad数组
REM将值从字符串传输到数组，然后
REM对该数组进行第一次初始置乱
REM初始化pad用户输入阶段：
CLS
输入“要加密的文件的全名”；nam1$
输入“输出文件的全名”；nam2$
输入“输入密码”；p2$
rbuf%=0
n%=0:sw%=0
p3$=字符串$（341，“Y”）
p1$=“Tfwd+-$wiHEbeMNHdgefrywre”
p1$=p2$+p1$+p3$
打印“在显示和图形显示后的任何时间按任意键继续”
p1$=左$（p1$，341）
sz%=LEN（p1$）
呼叫设置
调用初始化
CLS
ibfr$=字符串$（512,32）
postn&=1
将二进制文件的nam1$打开为#1
将二进制代码的nam2$打开为#2
g&=LOF（1）
最大值&=g&
sbtrct%=512
而g&>0
找到1，1
打印INT（1000*（（最大值和-g&）/max&）/10；%done）；
如果g&<512那么
ibfr$=STRING$（g&，32）
sbtrct%=g&
如果结束
获取#1、postn和ibfr$
对于ste%=1至LEN（ibfr$）
geh%=INT（Drnd#*256）
MID$（ibfr$，ste%，1）=CHR$（geh%XOR ASC（MID$（ibfr$，ste%，1）））
下一个ste%
PUT#2，postn和ibfr$
postn&=pos