问题标签 [commutativity]

^首先，是的，我被困在使用 Visual Studio 2008 中，我相信这个错误是 Visual Studio 2008 特有的。

我正在尝试编写一个仿函数来比较我的结构的一个成员，这样我就可以upper_bound对vector按该成员排序的所述结构进行操作。这很难用语言来解释，所以这里有一个例子：

这在Visual Studio 2015上运行良好。但是 Visual Studio 2008 给了我错误：

错误 C2664：“bool comp::operator ()(const double,const Foo &)”：无法将参数 1 从“Foo”转换为“const double”

我怀疑在通过交换输入来测试函子的严格弱排序的实现中存在一些邪恶。是否有一种解决方法可以暂停对编译器的检查，或者我只需将我的仿函数更改为接收 2 Foos 并Foo在此处临时代表 2 ？

如果x是一个非整数，我得到这个结果：

而 ifx是一个整数：

奇怪的是，如果x是非整数，则乘法中的操作数顺序很重要，如果是整数则不重要x。有人可以解释这背后的理性是什么吗？什么时候x是字符串，为什么变量必须在运算符x之前*以避免引发错误？

The following two C# functions differ only in swapping the left/right order of arguments to the equals operator, ==. (The type of IsInitialized is bool). Using C# 7.1 and .NET 4.7.

But the IL code for the second one seems much more complex. For example, B is:

• 36 bytes longer (IL code);
• calls additional functions including newobj and initobj;
• declares four locals versus just one.

IL for function 'A'…</h4>

IL for function 'B'…</h4>

 

Questions

1. Is there any functional, semantic, or other substantial runtime difference between A and B? (We're only interested in correctness here, not performance)
2. If they are not functionally equivalent, what are the runtime conditions that can expose an observable difference?
3. If they are functional equivalents, what is B doing (that always ends up with the same result as A), and what triggered its spasm? Does B have branches that can never execute?
4. If the difference is explained by the difference between what appears on the left side of ==, (here, a property referencing expression versus a literal value), can you indicate a section of the C# spec that describes the details.
5. Is there a reliable rule-of-thumb that can be used to predict the bloated IL at coding-time, and thus avoid creating it?

      BONUS. How does the respective final JITted x86 or AMD64 code for each stack up?

[edit]

Additional notes based on feedback in the comments. First, a third variant was proposed, but it gives identical IL as A (for both Debug and Release builds). Sylistically, however, the C# for the new one does seem sleeker than A:

Here also is the Release IL for each function. Note that the asymmetry A/C vs. B is still evident with the Release IL, so the original question still stands.

Release IL for functions 'A', 'C'…</h4>

Release IL for function 'B'…</h4>

Lastly, a version using new C# 7 syntax was mentioned which seems to produce the cleanest IL of all:

Release IL for function 'D'…</h4>

假设您在 sympy 表达式中有许多非交换符号，例如

使表达式中的所有符号可交换的首选方法是什么，例如，sympy.simplify(allcommutative(expr)) = c * (a + b)？

在这个答案中指出，如果不替换符号，就无法在创建后更改符号的交换性，但也许有一种简单的方法可以像这样在块中更改表达式的所有符号？

我需要在python中实现一些Grassmann变量（即反通勤变量）。换句话说，我想要一些行为如下

我需要的另一个功能是能够对我的变量进行规范排序。当我输入时，>>> y*x当然也可以输出y*x。-x*y但是，我希望能够选择x应该出现在左侧的y（可能只有在调用函数之后simplify(y*x)）。

SymPy 或其他一些库是否有这种能力？如果不是，那么我自己实现这个的最好方法是什么（例如我应该自己创建一个符号库，扩展 SymPy 等）？

以下代码是用 javascript 编写的。

这个问题涉及尝试深入研究某种类别理论，也许哈斯克尔或更熟悉这个问题的数学方面的人可以帮助我？

我试图围绕这样一个想法，即仿函数是保留结构的类别之间的映射。更具体地说-根据我的理解-编程语言中的函子是内函子。这意味着编程语言中的函子是将类型和函数映射到编程语言中通常定义的更广泛的类型和函数类别中的子类别的态射。

据我所知，函子（或内函子）还必须遵守某些通过促进组合和同一性来保护结构的定律。

我发现几乎不可能创建一个我认为保留结构并遵守函子定律的函子。再加上我只是认真地用 javascript 编程，所以类型理论是我从未真正考虑过的东西（毕竟 JS 是无类型的）。

我做了一个简单的例子，它将整数提升到一个最小的上下文中，其中映射不适用于偶数。换句话说，你可以用你的作曲来映射，但一旦你达到偶数，节目就结束了。

这看起来有点像 Maybe：

但很明显，在某些情况下，这不会与应用于普通 JS 类别中的整数的组合互换。考虑一个简单地将整数加一的投影函数。

如果我将一个偶数提升到这个 noEvens 上下文中，然后添加一个，它会给我一个 null 的 noEvens。但是，如果我先将一个偶数加一，然后再提升结果，则会产生一个奇数的 noEvens。

根据我的理解，这两条路径都应该在函子定律下通勤。它们显然不会，因为通过每个上下文的相同映射在被提升后不会产生相同的结果“noEvens.of(value)”。

所以我想我的问题是，这是否意味着这不是函子？这种情况（类型或其他）是什么让它表现得很奇怪？

我想我只是感到困惑，因为似乎所有“noEvens”所做的都是将值提升到一个不存在偶数的新上下文（子类别，无论如何），但很明显某些途径不会通勤。

我发现将值“提升”到新的映射上下文中的想法非常直观，它为您提供了很多机会来处理条件，而无需实现大量冗余代码。但我不想假装我遵守某种形式化的“函子定律”系统。

我在分析这种情况时遗漏了什么类型系统和函子定律？

如果我在 SymPy 中使用函数并调用 diff 方法，那么交换属性就会被忽略。

我在这里做错了吗？我只希望输出总是在前面有 R ..

I have a function called f(x,y), which returns 1 when both x = -1 and y = 1, and 0 otherwise.

I want to apply it on every pair of the same column elements of a matrix. I want to know if I have to repeat it the other way? or does it work the same for f(y,x)? I mean does it return 1 if one of the elements is -1 and the other is 1 anyway or it has to be in order?

已解决：在遵循white-wolf的建议后，我有一个解决方案。如果您对我的解决方案感兴趣，请随时给我留言。

我正在尝试在 Agda 中为乘法交换性写一个证明：

我们有：

我在提交这个最终目标时遇到了麻烦。预期的类型是y + y * suc x ≡ y * suc (suc x)，我曾预计 usingrewrite会给我y * suc (suc x) ≡ y * suc (suc x)一个目标。然而：

期望与以前相同的目标：y + y * suc x ≡ y * suc (suc x).

我的理解是，rewrite对于 x = x, give ，将有效地将 RHS 替换为 LHS，y * suc x ≡ y * suc x然后使用 x = suc x give y * suc (suc x) ≡ y * suc (suc x)。我是否误解了rewrite工作原理还是犯了其他错误？

好的，我的标题不是很好，但可以通过示例轻松解释。

我有两个表达式 a 和 b。我想知道他们是否会给我同样的结果而不被评估。

我虽然像 + 或 * 这样的交换运算符可以推断出结果是相同的。

编辑：理解它的另一种方法是比较可以推断函数交换性的非常具体的表达式子集： Expr(:call, +, a, b) <=> Expr(:call, +, b, a)