Fastest way to test if a numerical array has complex elements

Question

I am looking for the fastest way to test whether an n-dimensional numerical (NumericQ) array (in the ArrayQ sense) is complex or not. It is considered complex if it has at least one complex element.

It is an important requirement that this test must not unpack packed arrays.

Currently I have Not@ArrayQ[arr, _, FreeQ[#, _Complex] &], which does not unpack, but it executes the test for each element of packed arrays (can be tested using Print). Theoretically it's sufficient to test only one: all elements of a packed array are necessarily of the same type. In theory it's possible to detect whether an array is packed, and if it is, only test the first element, but this is very ugly, so I'd like to avoid it. It' also not easy to implement for an n-dimensional array.

What I am hoping for is a function which is internally special cased for packed arrays and is thus very fast.

Answer 1

One potential problem with directly testing the complete list using Developer`PackedArray[arr_, type_] is that this test may fail if the whole array is not packed, but sub-arrays are. As a result, one can too easily fall through to the more general test using FreeQ (or MemberQ) and end up unpacking anyway. This can be avoided by using ReplaceAll to remove packed arrays in advance of the membership test, which is a trick I also used here.

For present purposes, we might write:

ClearAll[containsComplexesQ];
containsComplexesQ[expr_] := MemberQ[
  expr /. {
     l_List /; Developer`PackedArrayQ[l, Complex] &&
                Return[True, containsComplexesQ] -> Null, 
     l_List /; Developer`PackedArrayQ[l] -> Null
    }, _Complex, -1
  ];

Now:

On["Packing"];
testArray = {RandomReal[1, 10], RandomComplex[1 + I, 10]};

containsComplexesQ[testArray]
(* -> True *)

An important difference between MemberQ and FreeQ is that the former has Heads -> False, while the latter has Heads -> True by default. Although one may of course specify Heads -> True to mimic the behavior of the example given in the question, since the intended application is to test array-like expressions, it's just as well to leave the default as it is. Furthermore, it's sufficient for the purpose of determining whether any complex values are present to test only level -1 of the structure, rather than every level as FreeQ does by default. As a result, a judicious use of MemberQ as above may perform somewhat better than Composition[Not, FreeQ] by virtue of testing fewer subexpressions.

Answer 2

In the Developer Utilities Package there's a function PackedArrayQ that checks if an expression is a packed array, optionally of a certain type.

This can be combined with the previous test:

ComplexArrayQ[arr_]:=Developer`PackedArrayQ[arr, Complex] ||
           (Not@Developer`PackedArrayQ[arr] && Not@FreeQ[arr, Complex])

arr = RandomComplex[1 + I, {500, 10}];
Developer`PackedArrayQ[arr, Complex] (* True *)
arr[[3,1;;4]]=I;
Developer`PackedArrayQ[arr, Complex] (* False *)
ComplexArrayQ@arr                    (* True *)