Max of a table/list with indeterminate values

Question

Suppose I have a Table:

tab = {1., 2., 3., Indeterminate}

When I type Max[tab] I get Indeterminate, I would like instead to get Max of all points except the Indeterminate (i.e. Max_new_version[tab] = 3).

NB: As a secondary case the answer should also provide a method to do a conditional replacement such that tab will end up looking like (i.e. Indeterminate is replaced by zero).

tab = {1., 2., 3., 0.0}

Answer 1

The first approach would be:

Max@Cases[tab, Except[Indeterminate]]

3.

If I understand your second need, that would be:

tab /. Indeterminate -> 0.0

{1., 2., 3., 0.}

Edit

Oleksandr's approach is indeed very fast, for very long lists seems to be over 3-4 times faster then others. Since my first approach was quite straightforward, it is resonable to add another one obvious method which will be very handy (possibly the fastest) when we work with non-numeric lists :

Max@DeleteCases[l, Indeterminate]

This approach is only a bit slower for numeric lists than that by Oleksandr and probably the best for non-numeric data (when Indeterminates are exceptional cases rather than common). To test prerformance issues we take a slightly more natural data, namely lists of real numbers with appended Indeterminate's :

l = RandomChoice[RandomReal[100, 20000]~Append~Indeterminate, {10^7}]; 

and use AbsoluteTimings to compare methods, starting with the most efficient :

maxNoIndeterminate[l] // AbsoluteTiming                   (*Oleksandr*)

{0.7070000, 99.9945}

 Max@DeleteCases[l, Indeterminate] // AbsoluteTiming       (*Artes II *)

{1.1150000, 99.9945}

  Max@Cases[l, Except[Indeterminate]] // AbsoluteTiming     (*Artes I *)

 {2.7720000, 99.9945}

  Max[l /. Indeterminate -> -Infinity] // AbsoluteTiming   (*cormullion*)

 {2.8870000, 99.9945}

  Max@Select[l, NumberQ] // AbsoluteTiming                (*David Skulsky*)

 {3.5120000, 99.9945}

Answer 2

A faster way than those already given avoids iterating over the list to remove unwanted values, instead replacing Indeterminate wherever it appears by redefining it as -Infinity using Block:

maxNoIndeterminate[lst_] := Block[{Indeterminate = -Infinity}, Max[lst]];

Note that any list containing Indeterminate cannot be a packed array, so there is no reason (at least, not in this case) to replace Indeterminate with a machine number rather than -Infinity. The latter, of course, is correct for all possible inputs, whereas using any finite value is not. (Also, Max[] gives -Infinity, so there is a consistency argument to be made as well.)

Here is a timing comparison:

l = RandomChoice[Range[100] ~Append~ Indeterminate, {10^7}];

Timing[Max@Select[l, NumberQ]] (* 2.140 seconds *)

Timing[Max[l /. Indeterminate -> -Infinity]] (* 1.797 seconds *)

Timing[Max@Cases[l, Except[Indeterminate]]] (* 1.750 seconds *)

Timing@maxNoIndeterminate[l] (* 0.515 seconds *)

Edit

As the above seems a bit too trivial to stand as an answer by itself, we might as well generalize this to Min also:

withoutIndeterminate /: (f : Min | Max)[withoutIndeterminate[args___]] :=
  Block[{Indeterminate = f[]}, f[args]];

l = {1, 2, 3, Indeterminate};

Min@withoutIndeterminate[l] (* -> 1 *)
Max@withoutIndeterminate[l] (* -> 3 *)

Answer 3

One more way:

tab = {1., 2., 3., Indeterminate};
Max @ Select[tab, NumberQ]

3.

Answer 4

There is one case else to be added (how rich is Mathematica!):

Max[Replace[l, Indeterminate -> -Infinity, {1}]] // AbsoluteTiming
{0.639738, 99.9987}

which is comparable (in my machine) to:

Max@DeleteCases[l, Indeterminate] // AbsoluteTiming
{0.627598, 99.9987}

And much better than the simple /. :

Max[l /. Indeterminate -> -Infinity] // AbsoluteTiming
{1.309642, 99.9987}

Answer 5

But now suppose that you want to compute both Max and Min of a list containing Indeterminate (in other words, you want {Min[#],Max[#]}&@list)?

Sending Indeterminate to -Infinity is no longer such a great idea as you will get -Infinity for Min. And, of course, if you use Infinity, Max will not come out right.

Actually, you can use the same trick by replacing -Infinity with Sequence[]. Note that both Max[100,Sequence[]] and Min[100,Sequence[]] return 100.

Answer 6

list = {1., 2., 3., Indeterminate};

Using TakeLargest (new in 10.1)

TakeLargest[list, 1]

{3.}

list = {1, Indeterminate, 3, 5, None, Missing[]};

Getting the 2 largest values

TakeLargest[list, 2]

{5, 3}

Getting the 2 largest values and their indices

TakeLargest[list -> {"Element", "Index"}, 2]

{{5, 4}, {3, 3}}

Answer 7

list = {1., 2., 3., Indeterminate};

---

Another way using GroupBy:

GroupBy[list, NumericQ, Max][True]

3.

Answer 8

You could write this:

Max1[l_] := Max[l  /. Indeterminate -> 0.0]

so that

Max1[tab]

gives

3.