标签: non-deterministic

如果将表的列设置为其公式调用函数的计算列,则更改该基础函数将变得很痛苦.每次更改时,您必须找到每个引用该函数的公式的列,删除引用,保存表,更改函数,添加所有内容,然后重新保存.即使很小的变化也是噩梦.

您能否告诉SQL Server您不关心公式引用函数并继续更改基础函数？

其他详细信息:计算列不会被FK约束持久化或引用,因为它是非确定性的.该功能考虑了当前时间.它正在处理记录是否过期的问题.

通常,据说多线程程序是非确定性的,这意味着如果它崩溃,则几乎不可能重新创建导致该条件的错误.一个人真的不知道接下来会运行什么线程,以及它什么时候会再次被抢占.

当然这与操作系统线程调度算法有关,而且事实上人们不知道接下来要运行什么线程,以及它将有效运行多长时间.程序执行顺序也起到了作用,等等......

但是如果你有用于线程调度的算法怎么办？如果你知道什么线程正在运行,那么多线程程序是否会变成"确定性",就像在,你将能够重现崩溃？

首先,我已经阅读了有关Prolog削减使用的所有其他帖子,并且肯定会看到与使用它们相关的问题.但是,对我来说仍然有些不清楚,我想一劳永逸地解决这个问题.

在下面的简单示例中,我们递归遍历列表并检查每个第2个元素是否等于1.执行此操作时,递归过程可能会在以下任一基本情况中结束:空列表或具有单个元素的列表仍然存在.

base([]).
base([_]).
base([_,H|T]) :- H =:= 1, base(T).

执行时:

?- time(base([1])).
   % 0 inferences, 0.000 CPU in 0.000 seconds (74% CPU, 0 Lips)
   true ;
   % 2 inferences, 0.000 CPU in 0.000 seconds (83% CPU, 99502 Lips)
   false.

?- time(base([3,1,3])).
   % 2 inferences, 0.000 CPU in 0.000 seconds (79% CPU, 304044 Lips)
   true ;
   % 2 inferences, 0.000 CPU in 0.000 seconds (84% CPU, 122632 Lips)
   false.

在这种情况下,我总是在第二个基本情况下使用显式切割运算符(即代表列表中剩下一个元素的那个),如下所示,以取消冗余选择点.

base([]).
base([_]) :- !.
base([_,H|T]) :- H =:= 1, base(T). …

情况:使用许多条件在C++或C#中进行条件检查:

if (condition1 && condition2 && condition3)
{
    // Do something
}

我一直认为不能保证执行这些检查的顺序.所以它不一定是条件1然后是条件2,而不是条件3.我在C++的时代学到了它.我想我被告知或在某处阅读.

直到知道我总是编写安全代码来解决在以下情况下可能的空指针:

if ((object != null) && (object.SomeFunc() != value))
{
    // A bad way of checking (or so I thought)
}

所以我在写:

if (object != null)
{
    if (object.SomeFunc() != value)
    {
        // A much better and safer way
    }
}

因为我不确定首先运行非空检查,然后才会调用实例方法来执行第二次检查.

现在,我们最伟大的社区头脑告诉我,执行这些检查的顺序保证以从左到右的顺序运行.

我很惊讶.对C++和C#语言来说真的如此吗？

有没有人听过我之前听过的版本？

根据确定性和非确定性函数的 MSDN SQL BOL(联机丛书)页面,可以" 以确定的方式 " 使用非确定性函数

以下函数并不总是确定性的,但可以在确定性方式指定时在计算列的索引视图或索引中使用.

非确定性函数的含义可以以确定的方式使用吗？
有人可以说明如何做到这一点？并在那里你会怎么做呢？

我有一个功能,包括:

SELECT @pString = CAST(@pString AS VARCHAR(255)) COLLATE SQL_Latin1_General_Cp1251_CS_AS

例如,这可用于删除法语中的重音; 例如:

UPPER(CAST('Éléctricité' AS VARCHAR(255)) COLLATE SQL_Latin1_General_Cp1251_CS_AS)

给ELECTRICITE.

但是使用COLLATE使得函数不确定,因此我不能将它用作列中的计算持久值.

Q1.是否有另一种(快速简便的)方法来删除这样的重音,具有确定性功能？

Q2.(奖金问题)我这样做计算持久列的原因是搜索.例如,用户可以将客户的姓氏输入为"Gagne"或"Gagné"或"GAGNE"或"GAGNÉ",应用程序将使用持久计算列找到它.有一个更好的方法吗？

编辑:使用SQL Server 2012和SQL-Azure.

我刚刚解决了如何使用List monad进行非确定性计算的问题.但是我相信我的算法会受益于广度优先搜索,而不是从List monad获得的深度优先搜索.

这是一个摘录,显示了我的算法的有趣部分.它是逻辑拼图Akari的解算器.

solve :: Game -> [Game]
solve game = do
        let ruleBasedSolverResult = applyRuleBasedSolversUntilSteady game
        guard $ consistant ruleBasedSolverResult
        if solved ruleBasedSolverResult
                then return ruleBasedSolverResult
                else speculate ruleBasedSolverResult

speculate :: Game -> [Game]
speculate game = do
        coord <- coords game
        guard $ lightableUnlit game coord
        let solutions = solve $ light game coord
        if null solutions
                then solve $ exclude game coord
                else solutions

基本上它应用一些基本的确定性规则来看看是否能解决它.如果没有,它会尝试将灯光放在不同的地方.如果光线在递归解决后使拼图不一致,则在光线所在的位置放置一个排除标记.如果在放置灯光时找到解决方案,则会将其添加到解决方案列表中.

这样做很好,但速度很慢,因为通常有一个明显的选择,哪个coord可以快速导致一个不一致的拼图,让你只用一(或两个)级别的搜索放置一个x,但如果它没有'在搜索到中途之前选择那个coord然后它会先咀嚼一堆无趣的东西.因此,广度优先搜索的想法.

我用谷歌搜索了"广泛的第一个非反感monad",我得到了一些难以理解的结果,如:

• Control.Monad.Omega对于我需要的东西来说这似乎有点过分,因为它似乎可以防止无限分歧的决定论,但对我来说并非如此,我并不完全理解它.

• Control.Monad.Weighted搜索Control.Monad.Omega 的文档建议在使用它作为Monad时使用它,但我认为加权对我的需求来说也有点矫枉过正.我可能只有2个权重,一个用于解决方案,一个用于没有解决方案的东西.

• Control.Monad.Level我不相信这会对我想要的东西起作用,因为只有树的叶子有值.

• Data.Tree我认为这可能是我想要使用的,但我不知道如何转换我的List monadic代码来使用它,虽然我觉得有一种美妙的方式. …

我意识到每次训练时我的模型最终会变得不同,即使我保持TensorFlow随机种子相同.

我证实了这一点:

• 初始化是确定性的; 在第一次更新之前,权重是相同的.
• 输入是确定性的.事实上,包括损失在内的各种正向计算在第一批中是相同的.
• 第一批的渐变是不同的.具体来说,我正在比较的输出tf.gradients(loss, train_variables).虽然loss并且train_variables具有相同的值,但是对于一些变量,梯度有时是不同的.差异非常显着(有时单个变量的梯度的绝对差值之和大于1).

我得出结论,这是导致非确定性的梯度计算.我看了一下这个问题,当用intra_op_parallelism_thread=1和运行CPU时问题仍然存在inter_op_parallelism_thread=1.

当前向传球不是时,后向传球如何是不确定的？我怎么能进一步调试呢？

我有以下代码:

import Control.Monad

coin :: MonadPlus m => m Int
coin = return 0 `mplus` return 1

如果我对coin :: Maybe Int解释器进行评估,它会受到影响Just 0.这是正常的,因为Maybe的实现是MonadPlus的实例.

如果我coin :: [Int]在解释器上进行评估,则打印出来[0, 1],因为mplus列表的实现是一个append.

但如果我评估coin,没有任何类型装饰器,它打印0.为什么？口译员"转换"什么类型coin来评估它？

此代码摘自:http://homes.sice.indiana.edu/ccshan/rational/S0956796811000189a.pdf

如果我通过将其分配给一些外部强引用而走私self了我会发生什么deinit？下面的代码显然格式不正确：

class C: CustomStringConvertible {
    let s = "abc"

    var description: String {
        return "C(id: \(ObjectIdentifier(self)), s: \(s))"
    }

    deinit {
        print("deinit")
        globalObject = self
    }
}

var globalObject: C!

do {
    let localObject = C()
    print("localObject: \(localObject)")
    print("end of `do`")
}

print("globalObject: \(globalObject!)")

您不能仅仅从a的中间“改变主意”来取消对象的初始化deinit。但有趣的是，此代码是不确定的，有时偶尔会成功完成，并打印：

localObject: C(id: ObjectIdentifier(0x00007f9063f00960), s: abc)
end of `do`
deinit
globalObject: C(id: ObjectIdentifier(0x00007f9063f00960), s: abc)

我正在使用Code Runner运行此程序，后者仅使用运行单个文件Swift脚本swiftc。因此，这里没有任何Playground拥有的意外参考。

不确定性从何而来？