# How to check is there any negative term in a large list?

I want to check if a data set of size $$10^{10}$$ contains any non-positive elements. Positive[Name of dataset] returns a list of True and False of length $$10^{10}$$. I want only a single True if all terms of that dataset are positive and False otherwise.

• VectorQ[list, Positive]? Mar 27, 2019 at 14:26
• Use Apply as in And @@ Positive[list] Mar 27, 2019 at 14:52
• How do you want to deal with terms that are exactly zero? Do you need all terms to be positive (use Positive), or do you need all terms to be zero or positive (use NonNegative)? Mar 27, 2019 at 15:01

Alternate solution:

list = RandomReal[1, 10^6];
Min[list] >= 0

• ...i.e. NonNegative[Min[list]]. Mar 27, 2019 at 16:08
• Very good solution! This avoids lists of Booleans and hence allows for vectorization. (Boolean arrays cannot be packed.) Mar 27, 2019 at 18:01
• This is about 100 times faster than any of the other solutions. Impressive! Mar 27, 2019 at 20:03
• Thank you very much.
– a b
Mar 28, 2019 at 8:40

Since you have a very large list, you should look at the timing

list = RandomReal[1, 10^6];

(And @@ Positive[list]) // AbsoluteTiming (* Hanlon *)

(* {0.050573, True} *)

VectorQ[list, Positive] // AbsoluteTiming (* J.M. *)

(* {0.261642, True} *)

(AnyTrue[list, Negative] // Not) // AbsoluteTiming (* Morbo *)

(* {0.324062, True} *)

And @@ (list /. {x_?Negative -> False,
x_?Positive -> True}) // AbsoluteTiming (* Alrubaie *)

(* {1.00664, True} *)


EDIT: As suggested by mjw, encountering a nonpositive value early in the list significantly alters the results.

list2 = ReplacePart[list, 1000 -> -1];

(And @@ Positive[list2]) // AbsoluteTiming (*Hanlon*)

(* {0.277642, False} *)

VectorQ[list2, Positive] // AbsoluteTiming (*J.M.*)

(* {0.000223, False} *)

(AnyTrue[list2, Negative] // Not) // AbsoluteTiming (*Morbo*)

(* {0.000262, False} *)

And @@ (list2 /. {x_?Negative -> False,
x_?Positive -> True}) // AbsoluteTiming (*Alrubaie*)

(* {1.43026, False} *)

• Looks like your method is five times faster than the next best! Can you give some insight into why this is? Thanks!
– mjw
Mar 27, 2019 at 15:34
• Also, and I guess this depends on the probability of any entry being negative, it may make sense for the algorithm to stop as soon as it finds a negative (or non-positive) element in the list.
– mjw
Mar 27, 2019 at 15:37
• @mjw, And[] does short-circuit evaluation. Mar 27, 2019 at 15:41
• @Bob, Thank you for your edit. Why, though, does it take longer for your method to work when there is a negative entry? I would have thought that in each case, it would take the same amount of time to go through the whole list.
– mjw
Mar 27, 2019 at 16:03
• @Roman, I do not believe that any lazy evaluation is being done. My comment was more to point out that an evaluation like And[True, True, False, True, True, ... True] will finish at once (and similar remarks apply for Or[]). Perhaps one can judiciously use Catch[]/Throw[]if an early-return test for long lists is desired. Mar 27, 2019 at 16:06

Ah, maybe this is too simple, but works for exactly what you're doing:

data = Table[RandomReal[{-1,1}],{i,1,1000}];
AnyTrue[data,Negative] // Not
(*False*)

data2 = Table[RandomReal[], {i, 1, 10^2}];
AnyTrue[data2, Negative] // Not
(*True*)

• AllTrue[data, Positive] to get the sign right. Or use Not on your solution. Mar 27, 2019 at 14:55
• @Roman - the poster is using AnyTrue not AllTrue Mar 27, 2019 at 15:00
• Yes @BobHanlon . In order to invert his solution to what the OP wants you have to either Not@AnyTrue[data,Negative] or (simpler) AllTrue[data,Positive] or AllTrue[data,NonNegative]. Mar 27, 2019 at 15:04
• ah, signs are reversed, missed that part. I updated the code to reflect questioners exact question. Mar 27, 2019 at 15:04
list = {1, 2, 3, 4, -5, -6, -7};

list /. {x_?Negative -> True, x_?Positive -> False}