LlFrand - 版本历史

2020年5月25日 (一) 09:32 Mkx

2020-05-25T09:32:43Z

2020年5月18日 (一) 02:08 Mkx

2020-05-18T02:08:36Z

Mkx：创建页面，内容为“{{LSL Header|ml=*}}{{LSLC|Keywords}}{{LSLC|Flow Control}}{{LSLC|}} {{函数详情 |函数名 = Function: float llFrand( float mag ); |参数= 参数：float mag…”

2020-04-13T13:20:57Z

创建页面，内容为“{{LSL Header|ml=*}}{{LSLC|Keywords}}{{LSLC|Flow Control}}{{LSLC|}} {{函数详情 |函数名 = Function: float llFrand( float mag ); |参数= 参数：float mag…”

新页面

{{LSL Header|ml=*}}{{LSLC|Keywords}}{{LSLC|Flow Control}}{{LSLC|}}

{{函数详情
|函数名 = Function: float llFrand( float mag );
|参数= 参数：float mag – Any valid float value
|返回值= 返回值：Returns a float that is pseudo random in the range [0.0, mag) or (mag, 0.0].[1]

|注意事项=The random number generator is not a source of entropy.

The sequence of random numbers are shared across the entire simulator process, and not independently seeded. Therefore, the pseudo random number generation is not suitable for any application which requires completely predictable or completely unpredictable results.

It should be remembered that when passing llFrand an integer as the mag, it will be implicitly typecast to a float.

Many integers outside the range [-224, +224] can not be represented in a float (this is an inherent limitation of the float type); for example, outside that range no odd integers will appear. For that reason, when converting the resulting float to integer, it is impossible to generate more than 224+1 uniformly distributed values, and it's also impossible to generate more than 9*223+1 or about 75 million different integers in total. Two llFrand calls may be needed to obtain the desired integer range; see examples below.

|示例=
<pre>
// *near* 50:50 chance of "Heads" vs. "Tails"
integer coin_toss()
{
if (llFrand(1.0) < 0.5) return TRUE;
return FALSE;
}

// Sometimes it is useful to get a random integer over a given range. This is
// a surprisingly tricky and emotive subject and has caused endless discussion
// on the scripting groups. The primary cause of probability errors when
// employing llFrand is to have a varying bin size on the edges of the range.
//
// As the bracket notation indicates, [0.0, mag), the function is inclusive of
// the 0.0 and exclusive of the entered value. Because an LSL floating point
// number is only a subset of real numbers and does not have infinite
// granularity, this schema will work for any float greater than float
// t = 1.175494351e-38; at which value the function will return only zero. At a
// float beyond this, a math error occurs.

// Random integer generator:
// Contributed by Mephistopheles Thalheimer,
// original function posted by Hg Beeks

// Returns a pseudo-random integer in the range of min to max inclusive.

// Rationale:
// Expands the range by 1.0 to ensure equal bin spacing on ends relative to
// the middle of the range and then uses an integer cast to round towards
// zero.

// Caveats:
// This function is not range checked and will fail if max < min

integer random_integer(integer min, integer max)
{
return min + (integer)(llFrand(max - min + 1));
}

say(string message)
{
llSay(0, message);
}

default
{
touch_start(integer total_number)
{
// *near* 50:50 chance of "Heads" vs. "Tails"
if (coin_toss()) say("Heads");
else say("Tails");

integer n1 = random_integer(2, 8); // Return a random number between 2 and 8
say("I chose a " + (string)n1);

}
}
</pre>

<pre>
// Example for generating an uniformly distributed integer with more than
// 16 million possible values; in particular, this code will generate
// 500,000,000 possible values, ranging from 0 to 499,999,999 inclusive.
//
// The method consists of not using llFrand() on a number larger than 16,777,216
// (2^24) but to divide the range into two numbers that are both less than that,
// using a scheme of the form (integer)llFrand(a)*b + (integer)llFrand(b), where
// a*b gives the desired range.
//
// For prime ranges, or ranges with a prime factor greater than 2^24, a rejection
// scheme should be used (use this method to generate a number slightly above the
// target range, and reject it and generate a new one if it exceeds the maximum).

default
{
state_entry()
{
integer rand = (integer)llFrand(500)*1000000 + (integer)llFrand(1000000);
llOwnerSay("Here's a random number between 0 and 499,999,999 inclusive: " + (string)rand);
}
}
</pre>

The following code produces the most possibilities for random negative integers (suitable for use as channel numbers for example)
<pre>
integer rand = 0x80000000 | (integer)llFrand(65536) | ((integer)llFrand(65536) << 16);
</pre>

<pre>
// Simple integer random number tester
// Contributed by Mephistopheles Thalheimer

// This is a random number tester designed to give a quick visual explanation
// and proof of why some random integer functions just do not work. In general,
// with any random number generator, if you can see a pattern emerging, then
// chances are, the function is not random.

// The test case given "silly_random_integer( .. )" shows the type of pitfalls
// that can happen. Superficially, it would seem like a good candidate. I
// thought so, and in fact mooted it in a discussion, however, a bit of thought
// reveals that the first and last bin are only collecting rounded results from
// half the float space as the rest of the integers. They are therefore
// under-represented in output, and the generator is flawed.

integer random_integer(integer min, integer max)
{
return min + (integer)llFrand(max - min + 1);
}

integer silly_random_integer(integer min, integer max)
{
return min + (integer)(llRound(llFrand(max - min))); // Looks good, but does not work
}

say(string message)
{
llSay(0, message);
}

// Simple integer random number tester
// Contributed by Mephistopheles Thalheimer

list bins;

integer MIN = 2; // The minimum integer you want
integer MAX = 5; // The maximum integer you want

integer NUMBER_OF_TRIES = 10000; // The bigger the better.. but slower

default
{
state_entry()
{
say("Bin tester ready.");
bins = [];
}

touch_start(integer total_number)
{

say("Started, be patient");

integer i;
integer r;

integer range = MAX - MIN;

for (i = 0; i <= range; ++i)
{
bins += [ 0 ];
}

integer v;
integer out_of_range;

for (i = 0; i < NUMBER_OF_TRIES; ++i)
{
// Replace the next line with the function you are testing
r = silly_random_integer(MIN, MAX);

// Note the output on the next line has about 0.5 expected hits on the first and last bin
// r = random_integer(MIN, MAX);

if (r > MAX || r < MIN)
{
out_of_range++;
}
else
{
v = llList2Integer(bins, r - MIN);
bins = llListReplaceList(bins, [++v], r - MIN, r - MIN);
}
}

for (i = 0; i <= range; ++i)
{
say("Bin #" + (string)(i + MIN) + " = " + (string)llList2Integer(bins, i));
}

say("Number out of range = " + (string)out_of_range);
}
}
</pre>

<pre>
//Exponential distribution
//
// Contributed by Pat Perth on October 5th 2013
// No rights reserved
//
// Return an exponentially distributed random number with expected value 'mean_value'
//
// Reference: Wikipedia article "Exponential distribution", in particular the section
// entitled "Generating exponential variates" at
//
// http://en.wikipedia.org/wiki/Exponential_distribution (visited on October 5th 2013)
//
// The exponential distribution is often an appropriate way to simulate waiting times
// of the sort "It takes about x seconds for <something> to happen." For
// example, if you want to trigger a rain shower "about every seven days", use
//
// time_between_rain = random_exponential(7.0 * 24.0 * 60.0 * 60.0) ;
//
// in an llSleep(...) or llSetTimerEvent(...) call.
//
// Please notice the negative sign in the return value.

float random_exponential(float mean_value)
{
return -mean_value * llLog(llFrand(1.0));
}
</pre>
|相关函数=
[[llListRandomize]]
}}

@@ 第26行： / 第26行： @@
+}
-//  Sometimes it is useful to get a random integer over a given range.  This is
+//  有时在给定的范围内得到一个随机整数是有用的。这是一个令人惊讶的棘手和情绪化的话题，并引起了无休止的讨论关于脚本编制组。在使用llFrand时，概率错误的主要原因是在范围的边缘有一个不同的箱子大小。
 //
-//  As the bracket notation indicates, [0.0, mag), the function is inclusive of
+//  正如括号符号所示，[0.0,mag)，该函数包含0.0，不包含输入的值。因为LSL浮点数只是实数的一个子集，并且没有无限的粒度，所以这个模式适用于任何大于float t = 1.175494351e-38的浮点数;在这个值上，函数将只返回0。当浮点数超过这个值时，就会出现数学错误。
 //  Random integer generator:
@@ 第42行： / 第34行： @@
 //      original function posted by Hg Beeks
-//  Returns a pseudo-random integer in the range of min to max inclusive.
+//  返回一个最小到最大范围内的伪随机整数。
-//  Rationale:
+//  基本原理:
-//      Expands the range by 1.0 to ensure equal bin spacing on ends relative to
+//      将范围扩展1.0，以确保两端相对于范围中部的间距相等，然后使用整数强制转换向零进行四舍五入。
-//  Caveats:
+//  注意:
-//      This function is not range checked and will fail if max < min
+//      此函数未检查范围，如果最大值<最小值，则会失败
 integer random_integer(integer min, integer max)
@@ 第78行： / 第68行： @@
 <pre>
-// Example for generating an uniformly distributed integer with more than
+// 生成具有大于1600万可能值的均匀分布整数的例子;特别是，这段代码将生成500,000,000个可能的值，范围从0到499,999,999(包括499,999,999)。
 //
-// The method consists of not using llFrand() on a number larger than 16,777,216
+// 该方法不针对大于16,777,216(2^24)的数使用llFrand()，而是使用(integer)llFrand(a)*b + (integer)llFrand(b)的格式将该范围划分为两个都小于该值的数，其中a*b给出了所需的范围。
 //
-// For prime ranges, or ranges with a prime factor greater than 2^24, a rejection
+// 对于质数范围，或者质数因子大于2^24的范围，应该使用拒绝方案(使用此方法生成略高于目标范围的数字，并拒绝它，如果它超过最大值，则生成一个新的数字)。
 default
@@ 第101行： / 第84行： @@
 </pre>
-The following code produces the most possibilities for random negative integers (suitable for use as channel numbers for example)
+下面的代码为随机负整数提供了最大的可能性(例如，适合用作通道号）
 <pre>
 integer rand = 0x80000000 | (integer)llFrand(65536) | ((integer)llFrand(65536) << 16);
@@ 第110行： / 第93行： @@
 // Contributed by Mephistopheles Thalheimer
-// This is a random number tester designed to give a quick visual explanation
+// 这是一个随机数测试器，旨在快速直观地解释和证明为什么一些随机整数函数不起作用。一般来说，对于任何随机数生成器，如果你能看到一个模式出现，那么很有可能，这个函数不是随机的。
-//  The test case given "silly_random_integer( .. )" shows the type of pitfalls
+//  给出的测试用例“silly_random_integer(..)”显示可能发生的陷阱类型。从表面上看，它似乎是一个不错的候选人。我认为是这样的，事实上在讨论中也提出过这个问题，但是，稍微考虑一下就会发现，第一个和最后一个bin只从浮动空间的一半收集四舍五入的结果，其余的是整数。因此，y在输出中表示不足，并且发生器有缺陷。
@@ 第204行： / 第179行： @@
 <pre>
-//Exponential distribution
+//指数分布
 //
 // Contributed by Pat Perth on October 5th 2013
 // No rights reserved
 //
-// Return an exponentially distributed random number with expected value 'mean_value'
+// 返回一个期望值为mean_value的指数分布随机数
 //
 // Reference: Wikipedia article "Exponential distribution", in particular the section
@@ 第216行： / 第191行： @@
 // http://en.wikipedia.org/wiki/Exponential_distribution (visited on October 5th 2013)
 //
-// The exponential distribution is often an appropriate way to simulate waiting times
+// 指数分布通常是模拟等待时间的一种合适方法类似于“x秒后< >发生”。例如，如果您想“大约每7天”触发一次阵雨，使用time_between_rain = random_exponent (7.0 * 24.0 * 60.0 * 60.0);在llSleep(…)或llSetTimerEvent(…)调用中。
 //
-//  time_between_rain = random_exponential(7.0 * 24.0 * 60.0 * 60.0) ;
+// 请注意返回值中的负号
 float random_exponential(float mean_value)

@@ 第4行： / 第4行： @@
 {{函数详情
 |函数名 = Function: float llFrand( float mag );
-|参数= 参数：float mag – Any valid float value
+|参数= 参数：float mag – 任何有效的浮点值
-|返回值= 返回值：Returns a float that is pseudo random in the range [0.0, mag) or (mag, 0.0].[1]
+|返回值= 返回值：返回一个在[0.0，mag]或（mag，0.0].[1]范围内的伪随机浮点数
-|注意事项=The random number generator is not a source of entropy.
+|注意事项=随机数生成器不是熵的来源。
- The sequence of random numbers are shared across the entire simulator process, and not independently seeded. Therefore, the pseudo random number generation is not suitable for any application which requires completely predictable or completely unpredictable results.
+  随机数序列在整个模拟器过程中是共享的，而不是独立的种子。因此，伪随机数的产生不适合任何需要完全可预测或完全不可预测结果的应用。
-It should be remembered that when passing llFrand an integer as the mag, it will be implicitly typecast to a float.
+应该记住，当把一个整数作为mag传递给llFrand时，它将被隐式地类型转换为一个float。
-Many integers outside the range [-224, +224] can not be represented in a float (this is an inherent limitation of the float type); for example, outside that range no odd integers will appear. For that reason, when converting the resulting float to integer, it is impossible to generate more than 224+1 uniformly distributed values, and it's also impossible to generate more than 9*223+1 or about 75 million different integers in total. Two llFrand calls may be needed to obtain the desired integer range; see examples below.
+范围[-224，+224]之外的许多整数不能用浮点表示（这是浮点类型的固有限制）；例如，在该范围之外不会出现奇数整数。因此，当将得到的浮点数转换为整数时，不可能生成大于224+1的均匀分布值，也不可能生成大于9*223+1或总计约7500万个不同的整数。可能需要两个llFrand调用来获得所需的整数范围；请参见下面的示例