This would probably be way more efficient:

function is_numeric_array($array)
{
    $array = array_keys($array);

    if ($array === array_filter($array, 'is_int'))
    {
        return true;
    }

    return false;
}

I just noticed what you're really trying to do is not check if all the keys in an array are integers but rather if the array is indexed (non-associative), for this use array_values() does the trick:

function is_numeric_array($array)
{
    return ($array === array_values($array));
}

If you're actually trying to determine whether it's a sequential integer array rather than associative, i.e. something that json_encode would make an array vs an object, this is probably the fastest way to to do so:

function is_normal_array($arr) {
    $c = count($arr);
    for ($i = 0; $i < $c; $i++) {
        if (!isset($arr[$i])) {
            return false;
        }
    }
    return true;
}

...of course the fastest code is code you never run, so consider whether you really, really need to do this, and only use it where you do.

Improving a little on @sepp2k answer(+1) (removing the "unused variable warning" some tools will spit out):

foreach (array_keys($array) as $a)) {
    if (!is_int($a)) {
        return false;
    }
}
return true;

If you want to check if it's an linear array:

return array_merge($array) === $array;

or @RobertPitt's solution :) (Also +1 there)

But my main point:

Why do you need this, i've never had use for something like this and it might be that the solution is change and API design flaw or data structure flaw somewhere ? Doesn't have too, but might.

Response to OPs comment:

I'm building a db method for queries that needs of a 3 keys array. In case the array is Numeric the order must be: statement, parameters, fetch. In case it's not, so the coder is specifying the key string, the order can be different and two out of three required parameters could be empty.

Ok then let my try to do that specif to your requirements :)

my_db_function(
    array("myquery", array("params", "..."), "myfetchmode")
);
// or 
my_db_function(
    array("params" => "myquery", "fetchmode" => "myfetchmode, "params" => array("myparams", "...) )
); 

Maybe i misunderstood a little but it should get the point across how one could build that with a different check :)

function my_db_fuction($statement) {

    if(isset($statement["query"])) { // Assoc 'Mode'
        $query = $statement["query"];
        if(isset($statement["params"])) { $params = $statement["params"]; } 
        else { $params = array(); }
        if(isset($statement["fetchmode"])) { $fetchmode = $statement["fetchmode"]; }
        else { $fetchmode = "select"; // optional param, default value here

    } else if(isset($statement[0]) { // Linear Array Mode

        $query = $statement[0];
        if(isset($statement[1])) { $params = $statement[1]; } 
        else { $params = array(); }
        if(isset($statement[2])) { $fetchmode = $statement[2]; }
        else { $fetchmode = "select"; // optional param, default value here

    } else {
         // Error, misformed format
    }
    // Now we got our 3 variables :)
}

That is still a pretty big code block but i didn't want to shorten it and risk worse readabilty.

What i would do with that is create a my_db_stuff_param_helper($aParams) that will always return an array containing the 3 keys filled with the real values (or defaults if nothing was passed)

  function my_db_fuction($statement) {
      $statement = my_db_parse_params($statement);
      // now e.g. $statement["query"] will always be there
  }

something along those lines "feels" (subjective, i know) better than building a generic function to do the key checking. (I guess it's isset($statement["query"]) instead of is_numeric_array what i boilds down to :)

Removed for inconsistency

Update

At first i didn't realise you wanted to check see if the keys are integers, if the reason your doing this is to make sure the keys are 0,1,2,3,4.. etc as an indexed array and not an associative array then you could use this:

function is_numeric_array($arr)
{
    return array_keys($arr) === range(0,(count($arr)-1));
}

/*
    * Tests
*/
var_dump(is_numeric_array(array('a', 'b', 'c'))); // true
var_dump(is_numeric_array(array("0" => 'a', "1" => 'b', "2" => 'c'))); // true
var_dump(is_numeric_array(array("1" => 'a', "0" => 'b', "2" => 'c'))); // false
var_dump(is_numeric_array(array("a" => 'a', "b" => 'b', "c" => 'c'))); // false

Benchmark results as requested:

Here's the code used to test the execution:

$array = array();
for($i=0;$i<=500000;$i++)
{
    $array[] = "some_string";
}

$m_initial = memory_get_usage();
is_numeric_array($array);
$increase = memory_get_usage() - $m_initial;

as you can see from the above I tested with a linear array that had 500K strings:

The value of $increase showed 65032 which is in bytes, if we converted to KB this is around about 64 rounded up, the result in KB shows 63.507 which is in my opinion is ok.

This will drop out as soon as an element is found that is not an int, making the function more efficient for large arrays.

function is_numeric_array($array) {
   foreach ($array as $a=>$b) {
      if (!is_int($a)) {
         return false;
      }
   }
   return true;
}

Ok, here's a shot for consistency and proper naming conventions (Since numeric and int mean different things all together, there's little point calling one the other...):

function isNumericArray(array $array) {
    foreach ($array as $a => $b) {
        if (!is_numeric($a)) {
            return false;
        }
    }
    return true;
}

function isIntArray(array $array) {
    foreach ($array as $a => $b) {
        if (!is_int($a)) {
            return false;
        }
    }
    return true;
}

Now, for a more OO approach, I'd build a filteriterator:

class NumericFilterIterator extends FilterIterator {
    public function accept() {
        return is_numeric(parent::current());
    }
}

class IntFilterIterator extends FilterIterator {
    public function accept() {
        return is_int(parent::current());
    }
}

Then, if you just want to iterate over the integer, just do $it = new IntFilterIterator(new ArrayIterator($array));. If you want to verify, you can do:

$it = new IntFilterIterator(new ArrayIterator($array));
if ($array != iterator_to_array($it)) {
    //Has a non-int element
}