Возвращать ноль, когда список содержит негативы

Question

Как создать функцию списка, такую, что если какой-либо элемент списка является отрицательным, он равен нулю, в противном случае он следует рекурсивному отношению.

Математически это то, что я должен сделать, но я не уверен, как это сделать в Mathematica.

Спасибо.

Edit: чтобы быть совершенно точным, я пытаюсь реализовать рекурсивное отношение на странице 6 этого документа (уравнение 18): http://arxiv.org/PS_cache/nlin/pdf/0003/0003069v1.pdf

Однако, это довольно сложно и требует достаточного количества чтения, чтобы понять, поэтому я не хотел ставить это под вопрос!

Answer 1

Вот еще один подход:

g[l_List /; Min[g] >= 0] := (* recursion relation *)
g[l_List] := 0

Answer 2

Проверка того, удовлетворяет ли какой-либо элемент списка какому-либо условию, можно выполнить с помощью MemberQ . Чтобы проверить, содержит ли список lst какой-либо элемент меньше нуля,

lst = {1, 2, 0, -4};
MemberQ[lst, x_ /; x < 0]

Вторым аргументом здесь является условный паттерн .

Но да, знание того, что вы хотите сделать, помогло бы.

Answer 3

Вы можете определить функцию с помощью условного теста, чтобы, если все элементы были неотрицательными, использовалось рекурсивное отношение.

 f[l_List] /; And @@ NonNegative[l] := (* recursion relation *)

Тогда более общий случай применяется только в том случае, если не все элементы неотрицательны, то есть некоторые являются отрицательными или равны нулю.

 f[l_List] := 0

Еще более простой метод с использованием сопоставления с образцом

 fff[l:{__?NonNegative}]:= (* recursion relation *)

 fff[l_List]:= 0

---

EDIT

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

ff[l_list] /; And @@ NonNegative[l] := True

ff[l_List] := 0

версия Бретта

gg[l_List] /; Min[l] > 0 := True

gg[l_List] := False

Мое второе предложение

hh[l : {__?NonNegative}] := True

hh[l_List] := False

Вариант моего второго предложения, который сосредоточен на поиске негативов, а не на их поиске, если это имеет смысл.

jj[l : {___, _?Negative, ___}] := False

jj[l_List] := True

В этом случае должно быть только несколько негативов

testfg = RandomInteger[{-1, 1000}, 10000];

Случай с большим количеством негативов: некоторые сопоставители не должны сканировать весь список

testfg1 = RandomInteger[{-1, 4}, 10000];

Этот должен вернуть True

testfg2 = RandomInteger[{0, 4}, 10000];

Теперь для проверки:

ff[testfg] // Timing

{0.000016, 0}

ff[testfg1] // Timing

{0.000015, 0}

ff[testfg2] // Timing

{0.000024, 0}

Версия Бретта немного медленнее, но занимает второе место в целом

gg[testfg] // Timing

{0.000049, True}

gg[testfg1] // Timing

{0.000049, True}

gg[testfg2] // Timing

{0.00005, True}

hh[testfg] // Timing

{0.000271, False}

hh[testfg1] // Timing

{0.000234, False}

hh[testfg2] // Timing

{0.003809, True}

jj[testfg] // Timing

{0.002482, False}

Конечно, эта версия быстрая, если в ней много отрицательных чисел и нет необходимости проверять весь список.

jj[testfg1] // Timing

{0.0005, False}

Но это крайне неэффективно, если нет отрицательных чисел из-за обширности шаблона

jj[testfg2] // Timing

{0.678945, True}