标签: non-deterministic

我有以下功能:

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO    
ALTER FUNCTION [dbo].[IP4toBIGINT](
    @ip4 varchar(15)
) 
RETURNS bigint
WITH SCHEMABINDING
AS
BEGIN
    -- oc3 oc2 oc1 oc0
    -- 255.255.255.255
    -- Declared as BIGINTs to avoid overflows when multiplying later on     DECLARE @oct0 bigint, @oct1 bigint, @oct2 bigint, @oct3 bigint;
    DECLARE @Result bigint;

    SET @oct3 = CAST(PARSENAME(@ip4, 4) as tinyint);
    SET @oct2 = CAST(PARSENAME(@ip4, 3) as tinyint);
    SET @oct1 = CAST(PARSENAME(@ip4, 2) as tinyint);
    SET @oct0 = CAST(PARSENAME(@ip4, 1) as tinyint);

    -- …

我想在Haskell中构建一个不确定的状态monad.这将允许我使用构建状态生成搜索空间中的所有元素以修剪不良位置.假设我有以下(伪)代码:

primitives :: [State Int Element] 
primitives = [... list of primitive stateful elements ...]                                                                                                                      
combine :: Element -> Element -> State Int Element                                                                                                            
expand :: Depth -> [State Int Element]                                                                                                                        
expand 0 = primitives                                                                                                                                         
expand d = do                                                                                                                                                 
  ... do something to the state ...                                                                                                                           
  left <- expand (d-1)                                                                                                                                        
  right <- expand (d-1)                                                                                                                                       
  let out = combine left right                                                                                                                                
  guard ( ... some check on out ... )                                                                                                                         
  return out        

这里有几件事情是行不通的:我需要了解的最基本的事情是如何做一些陈述,然后将其传递给每个expand分支.我已经尝试了一些类型函数的方法,State Int [ State Int Element] …

我想构建一个计算,其中上下文是引导当前(形成一个树)的所有路径的历史,并且该函数是以过去状态为条件的当前状态.函数本身是非确定性的,因此一个过去的状态可能导致几个未来状态,因此树分支.将这个计算的结果表示为树是有意义的,但有没有办法用列表monad简洁地表达它？或者其他一些我不知道的结构？

我正在尝试编写一个函数,如果元组中的任何两个值相同,它将Nothing成为Just Int元组.对于五个值的元组,这就是我所拥有的.显然,还有改进的余地:

nothingIfMatch :: Maybe (Int, Int, Int, Int, Int) -> Maybe (Int, Int, Int, Int, Int)
nothingIfMatch Nothing = Nothing
nothingIfMatch (Just (a, b, c, d, e))
    | a == b = Nothing
    | a == c = Nothing
    | a == d = Nothing
    | a == e = Nothing
    | b == c = Nothing
    | b == d = Nothing
    | b == e = Nothing
    | c == d = Nothing …

我在这里结束了:我有一个单线程的C++程序.这里有一些经验数据和背景信息,我试图突出最重要的关键词;

• 我正在谈论的整个部分没有任何系统调用,除了标准C++库可能执行的内存(de-)分配调用(std::set涉及到).这是一个纯粹的逻辑算法.
• 这种行为应该是确定性的,取决于输入,我不会改变.
• 如果错误表现出来,那么程序就会陷入无限循环,它似乎开始分配超出任何界限的内存.
• 该bug并没有表现出来预见的,我可以在命令行中运行的程序,有时(可能是30%-50%)的错误表现,否则,一切顺利,运行正常,据我可以告诉.
• 一旦我不直接从提示符运行程序,但在gdb或valgrind中,错误消失了,程序永远不会死.
• 现在是最好的部分:我将问题追溯到(模板化的)非虚拟成员函数调用.就在呼叫之前,我打印一个消息std::cout,这我可以看到在终端.所述第一线在函数内部也有一个调试消息,这是从未示出.

我再也看不到任何合理的解释了.也许你可以想出如何继续下去.

编辑:重要的代码行,我更改了行号,以便我们可以参考它们并省略不相关的部分,所以并非所有内容似乎都是最有意义的.

a.cpp

 10     std::set<Array const*>* symbols;
 11     std::set<Array const*> allSymbols;
 12     symbols = &allSymbols;
 //  ... allSymbols are populated with std::inserter
 15     std::cout << "eval; cd = " << &cd << ", cg = " << &cd.cg << std::endl;
 16 …

考虑以下Haskell代码:

import Control.Monad.State

test :: Int -> [(Int, Int)]
test = runStateT $ do
    a <- lift [1..10]
    modify (+a)
    return a

main = print . test $ 10

这会产生以下输出:

[(1,11),(2,12),(3,13),(4,14),(5,15),(6,16),(7,17),(8,18),(9,19),(10,20)]

但是我想生成以下输出:

[(1,11),(2,13),(3,16),(4,20),(5,25),(6,31),(7,38),(8,46),(9,55),(10,65)]

使用像JavaScript这样的不纯语言很容易做到这一点:

function test(state) {
    var result = [];

    for (var a = 1; a <= 10; a++) {
        result.push([a, state += a]);
    }

    return result;
}

你如何在Haskell做同样的事情？

我使用这段代码希望实现确定性：

from sklearn.ensemble import RandomForestRegressor
np.random.seed(0)
import random
random.seed(0)

rf = RandomForestRegressor(n_estimators=1000, criterion='mse', min_samples_leaf=4)

但我的结果并不是确定性的。这是为什么？我该如何解决这个问题？

Python 2

集合是无序值的集合.如果我通过set literal构造一个集合,例如

s = {'a', 'b', 'c'}

然后打印它,我得到了一些乱序的元素.但是,似乎在Python 2.7中,上面的示例总是产生相同的顺序:

print(s)  # set(['a', 'c', 'b']) in Python 2.7

Python 2.7如何决定这种排序？即使的哈希值'a','b'而'c'不是产生的顺序.

Python 3

在Python 3.x(包括dict按键排序的3.6 )中,生成的顺序似乎是随机的,但在给定的Python进程中总是相同的.也就是说,只要我不重启Python解释器,反复重建set literal就会导致相同的顺序.

要检查多个Python进程的排序,请考虑bash代码

(for _ in {1..50}; do python3 -c "s = {'a', 'b', 'c'}; print(s)"; done) | sort -u

这将(通常)显示3种元素可以排列的6种不同方式.python3用python(2)切换,我们只看到排序['a', 'c', 'b'].是什么决定了Python 3的排序？

我发现hash在Python 2中,对象的值是确定性的,而在Python 3中是随机的(虽然在Python过程中是常量).我确信这是完整解释的关键.

编辑

正如deceze在他的评论中写道,我想知道Python是否明确地做了一些事情来实现这种随机化,或者它是否"免费"发生.

我随机排序了一个IEnumerable.我继续打印出相同的元素,并获得不同的结果.

string[] collection = {"Zero", "One", "Two", "Three", "Four"};
var random = new Random();
var enumerableCollection = collection.OrderBy(e => random.NextDouble());

Console.WriteLine(enumerableCollection.ElementAt(0));
Console.WriteLine(enumerableCollection.ElementAt(0));
Console.WriteLine(enumerableCollection.ElementAt(0));
Console.WriteLine(enumerableCollection.ElementAt(0));
Console.WriteLine(enumerableCollection.ElementAt(0));

每次写入都会给出不同的随机元素.为什么订单没有保留？

在.NET Fiddle上看到它