@param $variable

@return Operator\Division
505990
public function divide($variable)
    {
        return $this->wrap(new Operator\Division($this, $this->asVariable($variable)));
    }
1215520
protected function evalVarDesc($variable, $key)
    {
        $type = $this->getType($variable);

        if ($type == 'method') {
            return $this->evalMethodDesc($variable);
        }

        if (isset($this->commentMap[$key])) {
            return $this->commentMap[$key];
        }

        if ($type == 'array') {
            return $this->evalArrDesc($variable);
        }

        if ($type == 'object') {
            return $this->evalObjDesc($variable);
        }

        return '';
    }
1360608
public function divide($factor)
    {
        if (!is_numeric($factor)) {
            throw new \InvalidArgumentException('Factor must be numeric');
        }

        $amount = bcdiv($this->amount, strval($factor), self::BCSCALE);

        return self::valueOf($amount, $this->currency);
    }
109259
protected function getDataCss($variable)
    {
        $css = [
            'padding'               => '7px',
            'background-color'      => $this->zebra ? '#D8D9DB' : '#FFF',
            'color'                 => '#405261',
        ];

        $type = gettype($variable);
        if ($type == 'NULL') {
            $css['color'] = '#999';
        }

        return $this->arrayToCss($css);
    }
1029820
protected function evalObjLabel($variable)
    {
        $class = get_class($variable);
        $label = class_basename($variable);

        if ($variable instanceof ComponentBase) {
            $label = '<strong>Component</strong>';
        }
        elseif ($variable instanceof Collection) {
            $label = 'Collection('.$variable->count().')';
        }
        elseif ($variable instanceof Paginator) {
            $label = 'Paged Collection('.$variable->count().')';
        }
        elseif ($variable instanceof Model) {
            $label = 'Model';
        }

        return '<abbr title="'.e($class).'">'.$label.'</abbr>';
    }
1312877
function Division(Selectable $operand1, Selectable $operand2, $alias = '')
    {
        return $this->CreateDivision($operand1, $operand2, $alias);
    }
655559
public function divide($number)
    {
        self::mustBeNumeric($number, 'Value to divide');
        
        $number = is_object($number) ? $number->value : $number;
        
        if ($number == 0) {
            throw new \InvalidArgumentException('You cannot divide by zero!');
        }

        return new self($this->value / $number);
    }
110847
public function setAggregateValue($var)
    {
        GPBUtil::checkString($var, True);
        $this->aggregate_value = $var;
        $this->has_aggregate_value = true;

        return $this;
    }
642362
public function renderAssignment($variable, $declaration, $semicolon = false, $newLine = false)
    {
        $separator = $this->renderSeparator();

        return $this->renderCode($variable.$separator.'='.$separator.$declaration, $semicolon, $newLine);
    }
1325453
public static function argv(string $variable, $default = null) {
		return isset(self::$_argv[$variable])
			? self::$_argv[$variable]
			: $default;
	}
26422
public function divide($value)
    {
        if (!$value instanceof self) {
            $value = new self($value, $this->getScale(), false);
        }

        $rawValue = $value->getValue();
        if ($rawValue == 0) {
            throw new InvalidArgumentException('Cannot divide by zero.');
        }

        $newValue = bcdiv($this->getValue(), $rawValue, $this->getScale());

        return $this->assignValue($newValue);
    }
1289539
public static function getTypeFromPHPVariable($variable)
    {
        if (is_object($variable)) {
            if ($variable instanceof \DateTime) {
                return self::getType('date');
            } elseif ($variable instanceof \MongoId) {
                return self::getType('id');
            }
        } else {
            $type = gettype($variable);
            switch ($type) {
                case 'integer';
                    return self::getType('int');
            }
        }
        return null;
    }
462841
public static function filterAll(&$var)
    {
        if (is_array($var)) {
            foreach ($var as &$v) {
                self::filterAll($v);
            }
        } else {
            $var = addslashes($var);
            $var = self::filterStr($var);
            $var = self::filterSql($var);
        }
        return $var;
    }
1170758
public function with(string ...$variables): self
    {
        $query = new self;
        $query->clauses = $this->clauses->add(
            new Clause\WithClause(...$variables)
        );

        return $query;
    }
1245241
public static function div($x, $y)
    {
        $X = static::parse($x);
        $Y = static::parse($y);

        if ($Y->p == 0) throw new DivisionByZeroException();

        $resp = $X->p * $Y->q;
        $resq = $X->q * $Y->p;

        return new Rational($resp, $resq);
    }
10245
private function with($variable, $value)
    {
        if ($value === $this->$variable) {
            return $this;
        }

        $uri = clone $this;
        $uri->$variable = $value;

        return $uri;
    }
1155884
public function divide($number): Utility
    {
        $divisible = new static($number);

        if ($divisible->value() == 0 || $this->number == 0) {
            throw new DivisionByZeroError();
        }

        $value = $this->number / $divisible->value();

        return new static($value);
    }