# 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 '19 at 14:26
• Use Apply as in And @@ Positive[list] Mar 27 '19 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 '19 at 15:01

Alternate solution:

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

• ...i.e. NonNegative[Min[list]]. Mar 27 '19 at 16:08
• Very good solution! This avoids lists of Booleans and hence allows for vectorization. (Boolean arrays cannot be packed.) Mar 27 '19 at 18:01
• This is about 100 times faster than any of the other solutions. Impressive! Mar 27 '19 at 20:03
• Thank you very much.
– a b
Mar 28 '19 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 '19 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 '19 at 15:37
• @mjw, And[] does short-circuit evaluation. Mar 27 '19 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 '19 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 '19 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 '19 at 14:55
• @Roman - the poster is using AnyTrue not AllTrue Mar 27 '19 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 '19 at 15:04
• ah, signs are reversed, missed that part. I updated the code to reflect questioners exact question. Mar 27 '19 at 15:04
list = {1, 2, 3, 4, -5, -6, -7};

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