有没有任何有效的简单方法可以使用 Mathematica 比较两个具有相同长度的列表？

Question

给定两个列表 A={a1,a2,a3,...an} 和 B={b1,b2,b3,...bn}，我会说A>=B当且仅当全部ai>=bi。

有两个列表的内置逻辑比较，A==B，但没有A>B。 我们是否需要像这样比较每个元素

And@@Table[A[[i]]>=B[[i]],{i,n}]

有更好的技巧吗？

编辑： 非常感谢大家。

这里还有一个问题：

如何在 N 个列表中找到最大列表（如果存在）？

使用 Mathematica 是否有有效简单的方法可以在 N 个相同长度的列表中找到最大列表？

Answer 1

方法1：我更喜欢这种方法。

NonNegative[Min[a - b]]

方法2：这只是为了好玩。正如 Leonid 指出的那样，对于我使用的数据来说，它被赋予了一些不公平的优势。
如果进行两两比较，并在适当的时候返回 False 和 Break，
那么循环可能会更有效（尽管我通常在 mma 中避免循环）：

result = True;
n = 1; While[n < 1001, If[a[[n]] < b[[n]], result = False; Break[]]; n++]; result

---

对 10^6 数字列表的一些计时比较：

a = Table[RandomInteger[100], {10^6}];
b = Table[RandomInteger[100], {10^6}];

(* OP's method *)
And @@ Table[a[[i]] >= b[[i]], {i, 10^6}] // Timing

(* acl's uncompiled method *)
And @@ Thread[a >= b] // Timing

(* Leonid's method *)
lessEqual[a, b] // Timing

(* David's method #1 *)
NonNegative[Min[a - b]] // Timing

---

编辑：我删除了方法 #2 的计时，因为它们可能会产生误导。方法#1 更适合作为通用方法。

Answer 2

例如，

And @@ Thread[A >= B]

应该做的工作。

编辑：另一方面，这

cmp = Compile[
  {
   {a, _Integer, 1},
   {b, _Integer, 1}
   },
  Module[
   {flag = True},
   Do[
    If[Not[a[[p]] >= b[[p]]], flag = False; Break[]],
    {p, 1, Length@a}];
   flag],
  CompilationTarget \[Rule] "C"
  ]

快了 20 倍。不过也丑了20倍。

编辑 2：由于 David 没有可用的 C 编译器，这里是所有计时结果，有两个差异。首先，他的第二种方法已被修复以比较所有元素。其次，我将 a 与其自身进行比较，这是最坏的情况（否则，我上面的第二种方法只需比较第一个元素之前的元素即可违反条件）。

(*OP's method*)
And @@ Table[a[[i]] >= b[[i]], {i, 10^6}] // Timing

(*acl's uncompiled method*)
And @@ Thread[a >= b] // Timing

(*Leonid's method*)
lessEqual[a, b] // Timing

(*David's method #1*)
NonNegative[Min[a - b]] // Timing

(*David's method #2*)
Timing[result = True;
 n = 1; While[n < Length[a], 
  If[a[[n]] < b[[n]], result = False; Break[]];
  n++]; result]

(*acl's compiled method*)
cmp[a, a] // Timing

所以编译的方法要快很多（注意David的第二种方法和这里编译的方法是同一个算法，唯一的区别是开销）。

所有这些都是使用电池供电，因此可能会有一些随机波动，但我认为它们具有代表性。

编辑3：如果，正如 ruebenko 在评论中建议的那样，我用 Compile`GetElement 替换 Part ，就像这样

cmp2 = Compile[{{a, _Integer, 1}, {b, _Integer, 1}}, 
  Module[{flag = True}, 
   Do[If[Not[Compile`GetElement[a, p] >= Compile`GetElement[b, p]], 
     flag = False; Break[]], {p, 1, Length@a}];
   flag], CompilationTarget -> "C"]

，那么 cmp2 的速度是原来的两倍作为cmp。

Answer 3

由于您在问题中提到效率是一个因素，您可能会发现这些函数很有用：

ClearAll[lessEqual, greaterEqual];
lessEqual[lst1_, lst2_] :=
   SparseArray[1 - UnitStep[lst2 - lst1]]["NonzeroPositions"] === {};

greaterEqual[lst1_, lst2_] :=
   SparseArray[1 - UnitStep[lst1 - lst2]]["NonzeroPositions"] === {};

这些函数将相当高效。 @David 的解决方案仍然快两到四倍，如果您想要极快的速度并且您的列表是数字（由整数或实数组成），您可能应该使用 C 编译（@acl 的解决方案以及类似的其他解决方案）运营商）。

您可以使用相同的技术（使用 Unitize 而不是 UnitStep 来实现 equal 和 unequal）来实现其他比较运算符（>、<、==、!=）。请记住 UnitStep[0]==1。

Answer 4

像 Greater、GreaterEqual、Equal、Less、LessEqual 这样的比较函数可以通过多种方式应用于列表（它们都是问题中方法的变体）。

对于两个列表：

 a={a1,a2,a3};
 b={b1,b2,b3};

以及两个带有数字条目的实例，

na={2,3,4}; nb={1,3,2}; 

您可以使用

And@@NonNegative[na-nb]

带有符号条目的列表

And@@NonNegative[na-nb]

给出

NonNegative[a1 - b1] && NonNegative[a2 - b2] && NonNegative[a3 - b3]

对于一般比较，可以创建一个通用比较函数，例如

listCompare[comp_ (_Greater | _GreaterEqual | _Equal | _Less | _LessEqual), 
         list1_List, list2_List] := And @@ MapThread[comp, {list1, list2}]

使用 as

listCompare[GreaterEqual,na,nb]

给出 True。对于符号条目，

listCompare[GreaterEqual,a,b]

给出逻辑上等价的表达式 a1 <= b1 && a2 <= b2 && a3 <= b3。

Answer 5

当使用压缩数组和数字比较器（例如 >=）时，很难击败 David 的方法 #1。

然而，对于无法转换为简单算术的更复杂的测试，需要另一种方法。

一个好的通用方法，特别是对于解包列表，是使用 Inner：

Inner[test, a, b, And]

这不会提前进行所有比较，因此在某些情况下比 And @ 更有效@MapThread[测试，{a，b}]。这说明了差异：

test = (Print[#, " >= ", #2]; # >= #2) &;

{a, b} = {{1, 2, 3, 4, 5}, {1, 3, 3, 4, 5}};

Inner[test, a, b, And]

<前><代码>1 >= 1
2>=3

错误的

And @@ MapThread[test, {a, b}]

<前><代码>1 >= 1
2>=3
3>=3
4>=4
5>=5

错误的

如果数组是打包的，特别是如果返回 False 的可能性很高，那么诸如 David 的方法 #2 之类的循环是一个不错的选择。可能这样写会更好：

Null === Do[If[a[[i]] ~test~ b[[i]], , Return@False], {i, Length@a}]

<前><代码>1 >= 1
2>=3

错误的