Checks if a string is a valid double.

@param number The string to check
@return True if the number is a valid double (positive) else false.
332450
public static boolean isValidDouble(String number) {
        boolean valid = false;
        if (isDouble(number) && isPositive(Double.parseDouble(number))) {
            valid = true;
        }
        return valid;
    }
601310
public boolean isNumeral(final String input) {
        for (int i = 0; i < input.length(); i++) {
            if (!isNumeral(input.charAt(i))) {
                return false;
            }
        }
        return true;
    }
376298
protected Number parseFloat(String string) throws ParseException {
		try {
			return Double.valueOf(string);
		} catch (NumberFormatException e) {
			fail(FLOAT);
			return null;
		}
	}
764340
private Double getDouble(Number number)
   {
      Double result = null;

      if (number != null)
      {
         result = Double.valueOf(number.doubleValue());
      }

      return result;
   }
1199668
private int getPositiveInteger(String number) {
    try {
      return Math.max(0, Integer.parseInt(number));
    } catch (NumberFormatException e) {
      return 0;
    }
  }
1288249
public function validate($value)
    {
        if (!is_numeric($value)) {
            return false;
        }
        // Convert possible strings to number
        $number = $value + 0;

        return is_double($number) || !$this->strict && is_int($number);
    }
452664
@Override
    public boolean isValid(Object input) {
        int value;
        try {
            value = Integer.parseInt(input.toString());
        } catch (NumberFormatException e) {
            return false;
        }

        if (minAllowedValue != null && value < minAllowedValue)
            return false;
        if (maxAllowedValue != null && value > maxAllowedValue)
            return false;
        return true;
    }
938534
public static function assertNumberFormat($number)
    {
        if (is_float($number)) {
            throw new \InvalidArgumentException(sprintf('The provided value "%s" must be a string, not a float.', $number));
        }
        if (!is_numeric($number)) {
            throw new \InvalidArgumentException(sprintf('The provided value "%s" is not a numeric value.', $number));
        }
    }
1300144
public static boolean isDouble(CharSequence self) {
        try {
            Double.valueOf(self.toString().trim());
            return true;
        } catch (NumberFormatException nfe) {
            return false;
        }
    }
473784
public static boolean isNumeric(String string) {
        if (string == null || string.length() == 0)
            return false;

        int l = string.length();
        for (int i = 0; i < l; i++) {
            if (!Character.isDigit(string.codePointAt(i)))
                return false;
        }
        return true;
    }
245726
public static double getDouble(
    Object      value)
  {
    if (value == null)
    {
        return 0;
    }

    return Double.valueOf(value.toString()).doubleValue();

  }
129817
def is_valid(number):
    """"""
    n = str(number)
    if not n.isdigit():
        return False
    return int(n[-1]) == get_check_digit(n[:-1])
716566
public double getDouble(final String key) {
		final String value = getProperty(key);
		if (value == null) {
			throw new NumberFormatException("Couldn't parse property to double.");
		}
		return Double.parseDouble(value);
	}
675982
private static boolean isBigDecimal( Number n ) {
      if( n instanceof BigDecimal ){
         return true;
      }
      try{
         new BigDecimal( String.valueOf( n ) );
         return true;
      }catch( NumberFormatException e ){
         return false;
      }
   }
1047785
public static boolean isNumeric(String string)
  {
    if(string == null || string.isEmpty()) return false;

    State state = State.SIGN;
    for(int i = 0; i < string.length(); ++i) {
      char c = string.charAt(i);

      switch(state) {
      case SIGN:
        if(c == '-' || c == '+') {
          state = State.INTEGER;
          break;
        }
        if(c == DECIMAL_SEPARATOR) {
          state = State.FRACTIONAL;
          break;
        }
        if(Character.isDigit(c)) {
          state = State.INTEGER;
          break;
        }
        return false;

      case INTEGER:
        if(Character.isDigit(c)) {
          break;
        }
        if(c == GROUPING_SEPARATOR) {
          break;
        }
        if(c == DECIMAL_SEPARATOR) {
          state = State.FRACTIONAL;
          break;
        }
        if(c == 'e' || c == 'E') {
          state = State.EXPONENT_SIGN;
          break;
        }
        if(isNumericSuffix(c)) {
          state = State.END;
          break;
        }
        return false;

      case FRACTIONAL:
        if(c == 'e' || c == 'E') {
          state = State.EXPONENT_SIGN;
          break;
        }
        if(isNumericSuffix(c)) {
          state = State.END;
          break;
        }
        if(Character.isDigit(c)) {
          break;
        }
        return false;

      case EXPONENT_SIGN:
        if(c == '-' || c == '+') {
          state = State.EXPONENT;
          break;
        }
        if(Character.isDigit(c)) {
          break;
        }
        return false;

      case EXPONENT:
        if(isNumericSuffix(c)) {
          state = State.END;
          break;
        }
        if(Character.isDigit(c)) {
          break;
        }
        return false;

      case END:
        return false;

      default:
        throw new IllegalStateException();
      }

    }
    return true;
  }
1068055
public static boolean isLetterAndNumber(String string) {
        boolean result = isNotEmpty(string);
        int idx = 0;
        int len = string.length();
        while (result) {
            if (idx >= len) {
                break;
            }
            char c = string.charAt(idx);
            result = isLetter(c) || isNumber(c);
            idx++;
        }
        return result;
    }
552208
public function gt($number)
    {
        return (bool) (bccomp($this->number, static::validateInputNumber($number), $this->precision) === 1);
    }