abs - PHP code example

PHP Function Abs - A Mathematical Function That Returns the Absolute Value of a Number

A php function abs is a very useful mathematical function that returns the absolute value of the number. It can be used on both integer and float type values and is a useful tool for all web developers to have in their toolbox.

PHP has a variety of math functions that are useful for performing various mathematical operations in your code. These include the abs(), ceil(), floor(), round(), max(), min(), rand(), sqrt(), and pi(). It is important to know about all of these functions in order to properly conduct mathematical operations in your code.

The abs() function is an inbuilt PHP function that returns the absolute value of a number. It can be used on both integer or float type values and will return the same type of value that is passed into it. This function is useful for web developers who need to calculate the absolute value of a number without having to write complex mathematical expressions.

Integers are whole numbers that do not have a decimal point and can range from 0 to infinity. Floats are numbers that have a decimal point and can range between -1 and 1.

The abs() function converts negative numbers into positive numbers while leaving the positive numbers unaffected. This is a very useful function to have in your toolbox when working with numbers and can be helpful for converting large quantities of data into meaningful results. Using the abs() function can also be an efficient way to check for negative values in your input data, which would be difficult to do manually by checking each individual value.

abs example

    public static function getRawOffset(string $timezone, int $timestamp = null): int
    {
        $dateTimeImmutable = new \DateTimeImmutable(date('Y-m-d H:i:s', $timestamp ?? time()), new \DateTimeZone($timezone));

        return $dateTimeImmutable->getOffset();
    }

    public static function getGmtOffset(string $timezone, int $timestamp = null, string $displayLocale = null): string
    {
        $offset = self::getRawOffset($timezone, $timestamp);
        $abs = abs($offset);

        return sprintf(self::readEntry(['Meta', 'GmtFormat'], $displayLocale), sprintf(self::readEntry(['Meta', 'HourFormat'.(0 <= $offset ? 'Pos' : 'Neg')], $displayLocale), $abs / 3600, $abs / 60 % 60));
    }

    /** * @throws MissingResourceException if the timezone identifier has no associated country code */
    public static function getCountryCode(string $timezone): string
    {
        return self::readEntry(['ZoneToCountry', $timezone], 'meta');
    }

if (strpos($op1, 'E') !== false) {
            $op1 = self::floatalize($op1);
        }

        $op1    = trim(self::normalize($op1));
        $length = strlen($op1);
        if (($decPos = strpos($op1, '.')) === false) {
            $op1 .= '.0';
            $decPos = $length;
            $length += 2;
        }
        if ($precision < 0 && abs($precision) > $decPos) {
            return '0';
        }

        $digitsBeforeDot = $length - ($decPos + 1);
        if ($precision >= ($length - ($decPos + 1))) {
            return $op1;
        }

        if ($precision === 0) {
            $triggerPos = 1;
            $roundPos   = -1;
        }

    public static function numericTo64BitInteger($num)
    {
        $high = 0;
        /** @var int $low */
        if (PHP_INT_SIZE === 4) {
            $low = (int) $num;
        } else {
            $low = $num & 0xffffffff;
        }

        if ((+(abs($num))) >= 1) {
            if ($num > 0) {
                /** @var int $high */
                $high = min((+(floor($num/4294967296))), 4294967295);
            } else {
                /** @var int $high */
                $high = ~~((+(ceil(($num - (+((~~($num)))))/4294967296))));
            }
        }
        return array((int) $high, (int) $low);
    }

    public function plus(PriceCollection $price): void
    {
        $value = $this->getPriceForTaxState($price, $this->context);

        $definition = new QuantityPriceDefinition(
            $this->price->getUnitPrice() + abs($value),
            $this->price->getTaxRules(),
            $this->getQuantity()
        );

        $this->overwrite($definition);
    }

    /** * `minus()` allows a price subtraction of the current price scope. The provided price will be recalculated via the quantity price calculator. * The provided price is interpreted as a unit price and will reduce to the current unit price. The total price * is calculated afterwards considering quantity, tax rule and cash rounding configurations. * * @example pricing-cases/product-pricing.twig 22 5 Minus a static defined price to the existing calculated price * * @param PriceCollection $price The provided price can be a fetched price from the database or generated over the `PriceFactory` statically */

if ($rule instanceof Container && $this->checkRuleType($rule) === false) {
                return false;
            }
        }

        return true;
    }

    private function filterOldOrders(OrderCollection $orders): OrderCollection
    {
        // Search with deepLinkCode needs updatedAt Filter         $latestOrderDate = (new \DateTime())->setTimezone(new \DateTimeZone('UTC'))->modify(-abs(30) . ' Day');

        return $orders->filter(fn (OrderEntity $order) => $order->getCreatedAt() > $latestOrderDate || $order->getUpdatedAt() > $latestOrderDate);
    }

    /** * @throws CustomerNotLoggedInException * @throws WrongGuestCredentialsException * @throws GuestNotAuthenticatedException */
    private function checkGuestAuth(?OrderEntity $order, Request $request): void
    {

    /** * Set RFC 822 Date * * @return string */
    protected function setDate()
    {
        $timezone = date('Z');
        $operator = ($timezone[0] === '-') ? '-' : '+';
        $timezone = abs($timezone);
        $timezone = floor($timezone / 3600) * 100 + ($timezone % 3600) / 60;

        return sprintf('%s %s%04d', date('D, j M Y H:i:s'), $operator, $timezone);
    }

    /** * @return string */
    protected function getMimeMessage()
    {
        return 'This is a multi-part message in MIME format.' . $this->newline . 'Your email application may not support this format.';
    }

    public static function getHumanReadableBytes(int $value): array
    {
        static $unit = ['B', 'KB', 'MB', 'GB', 'TB'];

        $negative = $value < 0;
        $value = \abs($value);

        if ($value < 1024) {
            $i = 0;
            $value = \floor($value);
        } elseif ($value < 0xFFFCCCCCCCCCCCC >> 40) {
            $i = 1;
        } elseif ($value < 0xFFFCCCCCCCCCCCC >> 30) {
            $i = 2;
        } elseif ($value < 0xFFFCCCCCCCCCCCC >> 20) {
            $i = 3;
        } else {

static::assertEquals($order->getPrice()->getTotalPrice(), 100);
                static::assertEquals($order->getAmountNet(), -(-100 - $taxAmount));
            },
        ];

        yield 'render credit_note with customer group net' => [
            true,
            [7],
            [-100],
            function DOrderEntity $order): void {
                static::assertEquals($order->getPrice()->getTotalPrice(), \abs(7) + \abs(-100));
                static::assertEquals($order->getAmountNet(), \abs(-100));
            },
        ];
    }

    /** * @param array<int, int> $taxes */
    private function generateDemoCart(array $taxes): Cart
    {
        $cart = $this->cartService->createNew('a-b-c');

$b = $this->height * $sin + $correction;
    $c = $this->width * $sin;
    $d = $this->height * $cos + $correction;
    if ((int) $angle == $angle && in_array($angle, [60, 150, 300])) {
      $a = $this->fixImprecision($a, $imprecision);
      $b = $this->fixImprecision($b, $imprecision);
      $c = $this->fixImprecision($c, $imprecision);
      $d = $this->fixImprecision($d, $imprecision);
    }

    // This is how GD on PHP5.5 calculates the new dimensions.     $this->boundingWidth = abs((int) $a) + abs((int) $b);
    $this->boundingHeight = abs((int) $c) + abs((int) $d);

    return $this;
  }

  /** * Performs an imprecision check on the input value and fixes it if needed. * * GD that uses C floats internally, whereas we at PHP level use C doubles. * In some cases, we need to compensate imprecision. * * @param float $input * The input value. * @param float $imprecision * The imprecision factor. * * @return float * A value, where imprecision is added to input if the delta part of the * input is lower than the absolute imprecision. */

        // When redirecting to named route, $to is an array like `['zombies' => '\Zombies::index']`.         if (is_array($to) && isset($to[0])) {
            $to = $this->processArrayCallableSyntax($from, $to);
        }

        $options = array_merge($this->currentOptions ?? [], $options ?? []);

        // Route priority detect         if (isset($options['priority'])) {
            $options['priority'] = abs((int) $options['priority']);

            if ($options['priority'] > 0) {
                $this->prioritizeDetected = true;
            }
        }

        // Hostname limiting?         if (! empty($options['hostname'])) {
            // @todo determine if there's a way to whitelist hosts?             if (! $this->checkHostname($options['hostname'])) {
                return;
            }

DiscountLineItem $discount,
        DiscountPackageCollection $packages,
        SalesChannelContext $context
    ): DiscountCalculatorResult {
        /** @var AbsolutePriceDefinition|null $priceDefinition */
        $priceDefinition = $discount->getPriceDefinition();

        if (!$priceDefinition instanceof AbsolutePriceDefinition) {
            throw new InvalidPriceDefinitionException($discount->getLabel(), $discount->getCode());
        }

        $fixedUnitPrice = abs($priceDefinition->getPrice());

        $totalDiscountSum = 0.0;

        $composition = [];

        foreach ($packages as $package) {
            foreach ($package->getCartItems() as $lineItem) {
                if ($lineItem->getPrice() === null) {
                    continue;
                }

    private function buildSurchargeDefinition(string $type, float|PriceCollection|string|int $value, string $key): PriceDefinitionInterface
    {
        if ($type === PercentagePriceDefinition::TYPE) {
            if ($value instanceof PriceCollection) {
                throw CartException::invalidPercentageSurcharge($key);
            }

            $value = FloatComparator::cast((float) $value);

            return new PercentagePriceDefinition(abs($value));
        }
        if ($type !== AbsolutePriceDefinition::TYPE) {
            throw CartException::surchargeTypeNotSupported($key, $type);
        }
        if (!$value instanceof PriceCollection) {
            throw CartException::absoluteSurchargeMissingPriceCollection($key);
        }
        if (!$value->has(Defaults::CURRENCY)) {
            throw CartException::missingDefaultPriceCollectionForSurcharge($key);
        }

    public function calculate(DiscountLineItem $discount, DiscountPackageCollection $packages, SalesChannelContext $context): DiscountCalculatorResult
    {
        /** @var AbsolutePriceDefinition|null $priceDefinition */
        $priceDefinition = $discount->getPriceDefinition();

        if (!$priceDefinition instanceof AbsolutePriceDefinition) {
            throw new InvalidPriceDefinitionException($discount->getLabel(), $discount->getCode());
        }

        $fixedTotalPrice = abs($priceDefinition->getPrice());

        $affectedPrices = $packages->getAffectedPrices();

        $discountDiff = $this->getTotalDiscountDiffSum($fixedTotalPrice, $packages, $affectedPrices);

        // now calculate the correct price         // from our collected total discount price         $discountPrice = $this->absolutePriceCalculator->calculate(
            -abs($discountDiff),
            $affectedPrices,
            $context
        );

                throw new ParseException(sprintf('Reference "%s" does not exist.', $value), $this->currentLineNb + 1, $this->currentLine, $this->filename);
            }

            return $this->refs[$value];
        }

        if (\in_array($value[0], ['!', '|', '>'], true) && self::preg_match('/^(?:'.self::TAG_PATTERN.' +)?'.self::BLOCK_SCALAR_HEADER_PATTERN.'$/', $value, $matches)) {
            $modifiers = $matches['modifiers'] ?? '';

            $data = $this->parseBlockScalar($matches['separator'], preg_replace('#\d+#', '', $modifiers), abs((int) $modifiers));

            if ('' !== $matches['tag'] && '!' !== $matches['tag']) {
                if ('!!binary' === $matches['tag']) {
                    return Inline::evaluateBinaryScalar($data);
                }

                return new TaggedValue(substr($matches['tag'], 1), $data);
            }

            return $data;
        }

$days = (int) $input->getOption('days');

        if ($all || $type === self::TYPE_GUESTS) {
            $criteria = new Criteria();
            $criteria->addFilter(new EqualsFilter('guest', true));
            $criteria->addFilter(new EqualsFilter('orderCustomers.id', null));
            $criteria->addFilter(
                new RangeFilter(
                    'createdAt',
                    [
                        RangeFilter::LTE => (new \DateTime())->modify(-abs($days) . ' Day')
                            ->format(Defaults::STORAGE_DATE_TIME_FORMAT),
                    ]
                )
            );

            $ids = $this->customerRepository
                ->searchIds($criteria, Context::createDefaultContext())
                ->getIds();

            if ($ids) {
                $ids = array_map(fn ($id) => ['id' => $id], $ids);