Check whether array is numeric or not.

@return bool
<p>Returns true if numeric, false otherwise.</p>
976773
public function isNumeric(): bool
    {
        if ($this->isEmpty()) {
            return false;
        }

        foreach ($this->keys()->getGenerator() as $key) {
            if (!\is_int($key)) {
                return false;
            }
        }

        return true;
    }
22720
public boolean isArray() {
        if (this == NONE) {
            return false;
        }
        return (((this.type instanceof Class && ((Class<?>) this.type).isArray())) || this.type instanceof GenericArrayType
                || resolveType().isArray());
    }
915388
public function isValid(): bool
    {
        $segments = explode('.', $this->value, self::NUM_SEGMENTS);

        if (count($segments) !== self::NUM_SEGMENTS) {
            return false;
        }

        for ($i = 0; $i < self::NUM_SEGMENTS; $i++) {
            $value = (int) $segments[$i];

            if ($value < self::MIN_VALUE || $value > self::MAX_VALUE) {
                return false;
            }
        }

        return true;
    }
936473
function isNumberArray( value ) {
	var len;
	if ( !isArray( value ) ) {
		return false;
	}
	len = value.length;
	if ( !len ) {
		return false;
	}
	for ( var i = 0; i < len; i++ ) {
		if ( !isNumber( value[i] ) ) {
			return false;
		}
	}
	return true;
}
228301
public static function isNumeric($array = null) {
		if (empty($array)) {
			return null;
		}
		if ($array === range(0, count($array) - 1)) {
			return true;
		}
		$numeric = true;
		$keys = array_keys($array);
		$count = count($keys);

		for ($i = 0; $i < $count; $i++) {
			if (!is_numeric($array[$keys[$i]])) {
				$numeric = false;
				break;
			}
		}
		return $numeric;
	}
1203017
private static function checkDataType($array)
    {
        if(count($array) <= 1)
        {
            return true;
        }

        $last = count($array) - 1;

        $type = self::getCustomDataType($array[$last]);

        if ($type != self::getCustomDataType($array[0]))
        {
            return false;
        }
        else
        {
            return true;
        }
    }
132892
def is_numeric(self, value, strict=False):
        """"""
        value = stringify(value)
        if value is not None:
            if value.isnumeric():
                return
        self.shout('value %r is not numeric', strict, value)
1075300
public function isArray() {
        $this->check_role = 'array';
        $result = is_array($this->value);
        $this->checkResult($result);
        return $this;
    }
261065
public static boolean isNumeric(Object obj) {
		if (obj == null) {
			return false;
		}
		char[] chars = obj.toString().toCharArray();
		int length = chars.length;
		if(length < 1)
			return false;
		
		int i = 0;
		if(length > 1 && chars[0] == '-')
			i = 1;
		
		for (; i < length; i++) {
			if (!Character.isDigit(chars[i])) {
				return false;
			}
		}
		return true;
	}
597545
public function isValidConstantType()
    {
        if ($this->type === self::TYPE_AUTO) {
            $type = $this->determineType($this->value);
        } else {
            $type = $this->type;
        }

        // Valid types for constants.
        $scalarTypes = [
            self::TYPE_BOOLEAN,
            self::TYPE_NUMBER,
            self::TYPE_INTEGER,
            self::TYPE_FLOAT,
            self::TYPE_DOUBLE,
            self::TYPE_STRING,
            self::TYPE_CONSTANT,
            self::TYPE_NULL,
            self::TYPE_EXPRESSION
        ];

        return in_array($type, $scalarTypes);
    }
361012
protected function checkType()
    {
        if (is_scalar($this->format)) {
            return array_key_exists($this->format, $this->patterns);
        } elseif (is_array($this->format)) {
            $pattern = [];
            foreach ($this->format as $f) {
                if (!array_key_exists($f, $this->patterns)) {
                    return false;
                }
                $pattern[] = substr($this->patterns[$f], 2, strlen($this->patterns[$f]) - 4);
            }
            $this->format = 'custom';
            $this->patterns[$this->format] = '/^(' . implode('|', $pattern) . ')$/';

            return true;
        }

        return false;
    }
391179
protected function isNumericArray(array $value)
    {
        foreach (array_keys($value) as $key) {
            if (is_string($key)) {
                return false;
            }
        }

        return true;
    }
281931
protected function isMultiArray($arr)
    {
        if (!is_array($arr)) {
            return false;
        }

        rsort($arr);

        return isset($arr[0]) && is_array($arr[0]);
    }
761759
public boolean isNumeric() {
		final Class c = getColumnClass();
		return c.equals(Integer.class) || c.equals(Float.class) || c.equals(Long.class) || c.equals(BigDecimal.class);
	}
476063
public static function is($value)
    {
        return (is_int($value) || (is_numeric($value) && !is_float($value) && !Str::contains($value, '.')));
    }
851802
private static boolean isNumeric(String value) {
    for (char c : value.toCharArray()) {
      if (!Character.isDigit(c)) {
        return false;
      }
    }
    return true;
  }
222061
def _is_numeric(self, values):
        """"""
        if len(values) > 0:
            assert isinstance(values[0], (float, int)), \
                "values must be numbers to perform math operations. Got {}".format(
                    type(values[0]))
        return True