Есть ли эффективный простой способ сравнить два списка с одинаковой длиной с 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}]

Есть лучшие трюки, чтобы сделать это делать?

EDIT: Большое спасибо за всех вас.

Вот еще один вопрос:

Как найти максимальный список (если есть) из N списков?

Any efficient easy way to find the maximum list among N lists with the same length using Mathematica?

Answer 1

Способ 1: Я предпочитаю этот метод.

NonNegative[Min[a - b]] 

Метод 2: Это просто для удовольствия. Как отметил Леонид, для данных, которые я использовал, дается немного несправедливое преимущество. Если один делает попарных сравнений, и возвращать значение False и перерыв, когда это необходимо, то цикл может быть более эффективным (хотя я обычно избегают петель в ММА):

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] 

должен делать эту работу.

EDIT: С другой стороны, это

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 раз уродливый тоже.

EDIT 2: Поскольку у Дэвида нет компилятора 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 

Так скомпилированный метод намного быстрее (обратите внимание, что второй метод Давида и скомпилированный метод здесь тот же самый алгоритм, и единственным отличием является накладные расходы).

Все это на аккумуляторе, поэтому возможны случайные колебания, но я думаю, что они являются репрезентативными.

EDIT 3: Если, как ruebenko предложил в комментарии, я заменяю Part с Compile`GetElement, как этот

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] 

со списками с symoblic записей

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}] 

Использование в качестве

listCompare[GreaterEqual,na,nb] 

дает True. С символическими записями

listCompare[GreaterEqual,a,b] 

дает логически эквивалентное выражение a1 <= b1 && a2 <= b2 && a3 <= b3.

Answer 5

При работе с упакованными массивами и цифровым компаратором, таким как >=, было бы сложно обыграть метод Дэвида №1.

Однако для более сложных тестов, которые не могут быть преобразованы в простую арифметику, требуется другой метод.

Хороший общий метод, особенно для неупакованных списков, является использование Inner:

Inner[test, a, b, And] 

Это не делает все сравнения впереди времени и, следовательно, может быть гораздо более эффективным в некоторых случаях, чем, например, And @@ MapThread[test, {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 

False 

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

1 >= 1 
2 >= 3 
3 >= 3 
4 >= 4 
5 >= 5 

False 

Если массивы упакованы и особенно, если вероятность того, что возвращение False высока, то петля такая так как метод Давида №2 - хороший вариант. Это может быть лучше написано:

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

1 >= 1 
2 >= 3 

False