Creates a NOT LIKE() comparison expression with the given arguments.

@param string $x Field in string format to be inspected by NOT LIKE() comparison.
@param mixed  $y Argument to be used in NOT LIKE() comparison.

@return string
961580
public function notLike($x, $y/*, ?string $escapeChar = null */)
    {
        return $this->comparison($x, 'NOT LIKE', $y) .
            (func_num_args() >= 3 ? sprintf(' ESCAPE %s', func_get_arg(2)) : '');
    }
239403
public static function ones(int $x, int $y): \CArray
    {
        return parent::ones($x, $y);
    }
1121967
function yy_r31()
    {
        $tag =
            trim(substr($this->yystack[ $this->yyidx + 0 ]->minor, $this->lex->ldel_length, - $this->lex->rdel_length));
        if ($tag == 'strip') {
            $this->strip = true;
            $this->_retvalue = null;;
        } else {
            if (defined($tag)) {
                if ($this->security) {
                    $this->security->isTrustedConstant($tag, $this->compiler);
                }
                $this->_retvalue =
                    $this->compiler->compileTag('private_print_expression', array(), array('value' => $tag));
            } else {
                if (preg_match('/^(.*)(\s+nocache)$/', $tag, $match)) {
                    $this->_retvalue = $this->compiler->compileTag($match[ 1 ], array("'nocache'"));
                } else {
                    $this->_retvalue = $this->compiler->compileTag($tag, array());
                }
            }
        }
    }
861675
public BooleanExpression notLike(Expression<String> str, char escape) {
        return like(str, escape).not();
    }
504410
public function not($expression) : self
    {
        return $this->operator('$not', $expression instanceof Expr ? $expression->getQuery() : $expression);
    }
849450
public function move($x, $y)
    {
        $this->executor->execute(DriverCommand::TOUCH_MOVE, [
            'x' => $x,
            'y' => $y,
        ]);

        return $this;
    }
793118
public static NotLike notLike(Expression<String> left, Expression<String> right, char wildCardCharacter) {
        return new NotLike(left, right, wildCardCharacter);
    }
657150
private function _mult(string $X, string $Y): string
    {
        $x = GCM::strToGMP($X);
        $Z = GCM::strToGMP(GCM::ZB_128);
        $V = GCM::strToGMP($Y);
        $R = GCM::strToGMP(self::R);
        for ($i = 0; $i < 128; ++$i) {
            // if bit at X[i] is set
            if (gmp_testbit($x, 127 - $i)) {
                $Z ^= $V;
            }
            // if LSB(Vi) = 0
            if (!gmp_testbit($V, 0)) {
                $V >>= 1;
            } else {
                $V = ($V >> 1) ^ $R;
            }
        }
        return GCM::gmpToStr($Z, 16);
    }
683201
public static function sinSumFromHav($x, $y) {
        $a = sqrt($x * (1 - $x));
        $b = sqrt($y * (1 - $y));
        return 2 * ($a + $b - 2 * ($a * $y + $b * $x));
    }
590601
public static function not(Expr $operand) : Expr
    {
        if ($operand instanceof BinOp && $operand->getOperator() === BinOp::EQUAL) {
            return self::notEqual($operand->getLeft(), $operand->getRight());
        }

        return UnaryOp::not($operand);
    }
963857
public function getValue( $x )
	{
		$y = 0;
		for( $i = $this->getRank() - 1; $i >= 0; $i-- )
			$y	= $this->coefficients[$i] + $y * $x;
		return $y;
	}
371612
public static function atan2($y, $x)
    {
        $y = $y instanceof Angle ? $y->rad : $y;
        $x = $x instanceof Angle ? $x->rad : $x;

        return static::rad(atan2($y, $x));
    }
141259
function _compare($x_value, $x_negative, $y_value, $y_negative)
    {
        if ($x_negative != $y_negative) {
            return (!$x_negative && $y_negative) ? 1 : -1;
        }

        $result = $x_negative ? -1 : 1;

        if (count($x_value) != count($y_value)) {
            return (count($x_value) > count($y_value)) ? $result : -$result;
        }
        $size = max(count($x_value), count($y_value));

        $x_value = array_pad($x_value, $size, 0);
        $y_value = array_pad($y_value, $size, 0);

        for ($i = count($x_value) - 1; $i >= 0; --$i) {
            if ($x_value[$i] != $y_value[$i]) {
                return ($x_value[$i] > $y_value[$i]) ? $result : -$result;
            }
        }

        return 0;
    }
561752
protected function like($field, $match, $joker='both', $not=FALSE){
        $this->where.= $field . ' ';
        if($not){$this->where.= 'NOT ';}
        $this->where.= 'LIKE ';
        switch ($joker){
            case 'both':
                 $this->where.= "'%$match%' ";
                break;
            case 'after':
                 $this->where.= "'$match%' ";
                break;
            case 'before':
                 $this->where.= "'%$match' ";
                break;
        }
    }
534302
private static function modulo($x, $y)
    {
        return ($x < $y ? $x : (is_int($y) ? $x % $y : fmod($x, $y))) + ($x < 0 ? $y : 0);
    }
807698
public static function not(Expr $operand) : Expr
    {
        if ($operand instanceof self) {
            if ($operand->getOperator() === self::IS_NULL) {
                return self::isNotNull($operand->getOperand());
            } elseif ($operand->getOperator() === self::IS_NOT_NULL) {
                return self::isNull($operand->getOperand());
            } elseif ($operand->getOperator() === self::NOT) {
                return $operand->getOperand();
            }
        }

        return new self(self::NOT, $operand, new Boolean());
    }
675035
public function likeExpression()
    {
        $stringExpr = $this->identificationVariable();
        $not = false;

        if ($this->lexer->isNextToken(Lexer::T_NOT)) {
            $this->match(Lexer::T_NOT);
            $not = true;
        }

        $this->match(Lexer::T_LIKE);

        $stringPattern = $this->stringExpression();

        $likeExpr = new LikeExpressionNode($stringExpr, $stringPattern);
        $likeExpr->setNot($not);

        return $likeExpr;
    }