Check if this is numeric, rather than associative.

@return bool
493986
private function isNumeric()
    {
        foreach (array_keys($this->options) as $key) {
            if (!is_int($key)) {
                return false;
            }
        }

        return true;
    }
923435
protected function isVersionNumeric($version)
    {
        foreach (explode('.', $version) as $part) {
            if (!is_numeric($part)) {
                return false;
            }
        }

        return true;
    }
476063
public static function is($value)
    {
        return (is_int($value) || (is_numeric($value) && !is_float($value) && !Str::contains($value, '.')));
    }
1181377
public function isArray()
    {
        $parts = $this->getParts();

        // Array types are complex types with one element, their names begins with 'ArrayOf'.
        // So if not - that's not array. Only field must be array also.
        return $this->isComplex()
            && count($parts) == 1
            && (substr($this->name, 0, 7) == 'ArrayOf')
            && substr(reset($parts), -2, 2) == '[]';
    }
891602
def _is_numeric_data(self, data_type):
        """"""
        dt = DATA_TYPES[data_type]
        if dt['min'] and dt['max']:
            if type(self.data) is dt['type'] and dt['min'] < self.data < dt['max']:
                self.type = data_type.upper()
                self.len = len(str(self.data))
                return True
1151268
public static function IsNumericValue( $type )
	{
		if ( isset( ValueProxy::$valueFactory[ $type->getFullName() ] ) )
		{
			/**
			 * @var ValueProxyFactory $factory
			 */
			$factory = ValueProxy::$valueFactory[ $type->getFullName() ];
			return $factory->getIsNumeric();
		}

		return false;
	}
547540
public function accept()
	{
		$this->numberScanned++;
		if( !parent::accept() )
			return FALSE;
		$this->numberFound++;
		if( !$this->contentPattern )
			return TRUE;
		$filePath	= $this->current()->getPathname();
		$realPath	= realpath( $this->current()->getPathname() );
		if( $realPath )
			$filePath	= $realPath;
		$content	= FS_File_Reader::load( $filePath );
		$found		= preg_match( $this->contentPattern, $content );
		return $found;
	}
686345
protected static function is_numeric( $type ) {
		switch ( $type ) {
			case self::INT:
			case self::TINYINT:
			case self::MEDIUMINT:
			case self::BIGINT:
			case self::DOUBLE:
			case self::FLOAT:
			case self::REAL:
			case self::DECIMAL:
				return true;
				break;
			default:
				return false;
				break;
		}
	}
37326
public static function IsNativeType( $value ) : bool
   {

      return (
            \is_bool(   $value ) ||
            \is_int(    $value ) ||
            \is_string( $value ) ||
            \is_double( $value ) ||
            \is_float(  $value ) ||
            \is_array(  $value )
      );

   }
462108
protected function validateNumeric( $attribute, $value )
	{
		if ( !$this->hasAttribute( $attribute ) )
		{
			return true;
		}

		return is_null( $value ) || is_numeric( $value );
	}
954204
public function isValid()
    {
        return ((!empty($this->hex) && ctype_xdigit($this->hex)) && (!empty($this->dec) && ctype_digit($this->dec)));
    }
1039067
private static boolean isNumericType(Class<?> c) {
    return Number.class.isAssignableFrom(c)
        || double.class == c
        || float.class == c
        || long.class == c
        || int.class == c
        || short.class == c
        || byte.class == c;
  }
429966
public function castInteger()
    {
        $castFunction = function ($value) {
            return is_object($value) ? 1 : (int) $value;
        };

        if (is_numeric($this->value)) {
            return $castFunction($this->value);
        }

        return $this->handleMismatch($castFunction, 'integer');
    }
981999
public function validarCedula($numero = '')
    {
        // fuerzo parametro de entrada a string
        $numero = (string) $numero;

        // borro por si acaso errores de llamadas anteriores.
        $this->setError('');

        // validaciones
        try {
            $this->validarInicial($numero, '10');
            $this->validarCodigoProvincia(substr($numero, 0, 2));
            $this->validarTercerDigito($numero[2], 'cedula');
            $this->algoritmoModulo10(substr($numero, 0, 9), $numero[9]);
        } catch (Exception $e) {
            $this->setError($e->getMessage());

            return false;
        }

        return true;
    }
1037424
public function isConvergent ()
	{
		$is = true;
		for( $i=$this->interval->getStart(); $i<$this->interval->getEnd(); $i++ )
		{
			$an = $this->getPartialSum( $this->interval->getStart(), $i );
			$an1 = $this->getPartialSum( $this->interval->getStart(), $i+1 );
			$diff = abs( $an1 - $an );
//			echo "<br>an1: ".$an1." | an: ".$an." | diff: ".$diff;
			if (!$old_diff) $old_diff = $diff;
			else if( $diff >= $old_diff )
				$is = false;
		}
		return $is;
	}
989433
public function isDelimiter()
    {
        for ($i = count($this->tokens) - 1; $i >= 0; $i--) {
            $t = $this->tokens[$i];
            if ($t[0] === null || $t[0] === 'COMMENT') {
                continue;
            } elseif ($t[0] === 'OPENER' || $t[0] === 'OPERATOR') {
                return true;
            } elseif ($t[0] === 'IDENT') {
                switch ($t[1]) {
                    // named operators
                    case 'lt':
                    case 'gt':
                    case 'le':
                    case 'ge':
                    case 'eq':
                    case 'ne':
                    case 'cmp':
                    case 'and':
                    case 'or':
                    case 'xor':
                    // other keywords/functions
                    case 'if':
                    case 'elsif':
                    case 'while':
                    case 'unless':
                    case 'split':
                    case 'print':
                        return true;
                }
            }
            return false;
        }
        return true;
    }
824481
def isnumeric(obj):
    '''
    
    '''
    from decimal import Decimal
    if type(obj) == Decimal:
        return True
    else:
        try:
            float(obj)
        except:
            return False
        return True