值不大于
@param number $val
@param number|array $max
559662
public static function max($val, $max)
	{
	    if (is_array($max)) {
	        if (!isset($max['max'])) {
	            throw new \InvalidArgumentException('The $max argument must have "max" key');
	        }
	        $max = $max['max'];
	    }

	    return $val <= $max;
	}
1109102
public function resetPK ($val = FALSE)
	{
		
		if ($val === FALSE)
		{
			$this->reset (static::$pk);
		}
		else
		{
			$this->attributeValues[static::$pk] = $val;
		}
		
	}
492831
public function set($val)
    {
        $code = $this->get($val);

        if ($code) {
            $this->current[] = $code;

            return true;
        }

        return false;
    }
107677
public static function numericRange(
        float $value,
        float $min,
        float $max,
        ?string $message = null,
        ?string $propertyPath = null
    ) : void {
        static::numeric($value);
        static::numeric($min);
        static::numeric($max);

        if ($value < $min || $value > $max) {
            $message = sprintf(
                $message ?: 'Value %d is not between %d and %d',
                static::stringify($value),
                static::stringify($min),
                static::stringify($max)
            );

            throw static::createException($value, $message, static::INVALID_NUMERIC_RANGE, $propertyPath);
        }
    }
200611
public function rule_max( $key, $value, $max )
	{
		return $this->rule_max_num( $key, strlen( $value ), $max );
	}
391733
public void addNextValue(Object val) {
    String newVal = val.toString();
    if (this.maxVal == null || this.maxVal.compareTo(newVal) < 0) {
      this.maxVal = newVal;
    }
  }
281667
public static function length($val, $min, $max = null)
    {
        return isset($val[$min - 1]) && (null === $max || !isset($val[$max]));
    }
1055075
public static function size($val, $min = null, $max = null): bool
    {
        if (!\is_int($val)) {
            if (\is_string($val)) {
                $val = Helper::strlen(\trim($val));
            } elseif (\is_array($val)) {
                $val = \count($val);
            } else {
                return false;
            }
        }

        return self::integer($val, $min, $max);
    }
291697
protected function booleanValue($val)
    {
        if (is_numeric($val)) {
            return (bool) $val;
        } else {
            return (in_array(strtolower($val), array('true', 't', 'y', 'yes'), true) ? true : false);
        }
    }
969459
protected function isValidTranslation($val)
    {
        if (empty($val) && !is_numeric($val)) {
            return false;
        }

        if (is_string($val)) {
            return !empty(trim($val));
        }

        if ($val instanceof Translation) {
            return true;
        }

        if (is_array($val)) {
            return !!array_filter(
                $val,
                function ($v, $k) {
                    if (is_string($k) && strlen($k) > 0) {
                        if (is_string($v) && strlen($v) > 0) {
                            return true;
                        }
                    }

                    return false;
                },
                ARRAY_FILTER_USE_BOTH
            );
        }
        return false;
    }
1190125
public static function isLengthBetween($value, $min, $max)
    {
        if (is_array($min)) {
            $max = $min[1];
            $min = $min[0];
        }

        if (self::isLengthGte($value, $min) && self::isLengthLte($value, $max)) {
            return true;
        }

        return false;
    }
145733
public static function isGte($value, $max)
    {
        is_array($max) && $max = $max[0];
        if (!is_numeric($value)) {
            return false;
        } else {
            return $value >= $max;
        }
    }
243260
public function _validation_numeric_min($val, $min_val)
	{
		return $this->_empty($val) || floatval($val) >= floatval($min_val);
	}
1170667
public function max(float $max, string $error = 'not at most %d') : Real
    {
        return $this->pipe(
            self::predicate(
                function (float $value) use ($max) : bool {
                    return $value <= $max;
                },
                sprintf($error, $max)
            )
        );
    }
627202
function _maxnum (val) {
						if (attrs.maxnum && attrs.multiple && val) {
							var valid = val.length <= parseInt(attrs.maxnum);
							ngModel.$setValidity('maxnum', valid);
						}
						return val;
					}
1064761
private static function iniGetBytes($val)
    {
        $val = trim(ini_get($val));
        if ($val != '') {
            $last = strtolower(
                $val{strlen($val) - 1}
            );
        } else {
            $last = '';
        }
        $val = (int) $val;
        switch ($last) {
            // The 'G' modifier is available since PHP 5.1.0
            case 'g':
                $val *= 1024;
            case 'm':
                $val *= 1024;
            case 'k':
                $val *= 1024;
        }

        return $val;
    }
996673
public function setMax($max)
    {
        if (is_numeric($max) || Format::isVariableRef($max)) {
            $this->max = $max;
        } else {
            $msg = "'Max must be a numeric value or a variableRef, '" . gettype($max) . "' given.";
            throw new InvalidArgumentException($msg);
        }
    }