isFactorOf() - Code Metrics - Inspection of "Feature/update readme" - gin0115/pinkcrab_function_constructors - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — develop (#27)

by Glynn
created 2022-05-20 15:34 UTC
isFactorOf() A

↳ Parent: Project
Complexity

Conditions	4
Paths	2
Size

Total Lines	22
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	4
eloc	8
nc	2
nop	1
dl	0
loc	22
rs	10
c	0
b	0
f	0
<?php

/**
 * Number functions.
 *
 * This file is part of PinkCrab Function Constructors.
 *
 * PinkCrab Function Constructors is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, either version 2
 * of the License, or (at your option) any later version.
 *
 * PinkCrab Function Constructors is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with PinkCrab Function Constructors.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 * @author Glynn Quelch <[email protected]>
 * @license http://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
 * @package PinkCrab\FunctionConstructors
 * @since 0.0.1
 *
 * @template Number of int|float
 * @phpstan-template Number of int|float
 * @psalm-template Number of int|float
 */

declare(strict_types=1);

namespace PinkCrab\FunctionConstructors\Numbers;

use Closure;
use InvalidArgumentException;
use PinkCrab\FunctionConstructors\Comparisons as C;
filter:
    dependency_paths: ["lib/*"]

/**
 * Used to accumulate integers
 *
 * @param int $initial
 * @return Closure(int|null):(Closure|int)
 */
function accumulatorInt(int $initial = 0): Closure
{
    /**
     * @param int|null $value
     * @return Closure(int|null):(Closure|int)|int
     */
    return function (?int $value = null) use ($initial) {
        if ($value) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $initial += $value;
        }
        return $value ? accumulatorInt($initial) : $initial;
    };
}

/**
 * Used to accumulate floats
 *
 * @param float $initial
 * @return Closure(float|null):(Closure|float)
 */
function accumulatorFloat(float $initial = 0): Closure
{
    /**
     * @param float|null $value
     * @return Closure(float|null):(Closure|float)|float
     */
    return function (?float $value = null) use ($initial) {
        if ($value) {
            $initial += $value;
        }
        return $value ? accumulatorFloat($initial) : $initial;
    };
}

/**
 * Returns a function for adding a fixed amount.
 *
 * @param Number $initial Defaults to 0
 * @return Closure(Number):Number
 * @throws InvalidArgumentException If neither int or float passed.
 */
function sum($initial = 0): Closure
{
    if (! C\isNumber($initial)) {
    if (! /** @scrutinizer ignore-call */ C\isNumber($initial)) {
        throw new InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
    }

    /**
     * @param Number $value
     * @return int|float
     */
    return function ($value) use ($initial) {
        return $initial + $value;
    };
}


/**
 * Returns a function for adding a fixed amount.
 *
 * @param int $initial Defaults to 0
 * @return Closure(Number):Number
 * @throws InvalidArgumentException If neither int or float passed.
 */
function subtract($initial = 0): Closure
{
    if (! C\isNumber($initial)) {
    if (! /** @scrutinizer ignore-call */ C\isNumber($initial)) {
        throw new InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
    }

    /**
     * @param Number $value
     * @return int|float
     */
    return function ($value) use ($initial) {
        return $value - $initial;
    };
}


/**
 * Returns a function for multiplying a fixed amount.
 *
 * @param Number $initial Defaults to 1
 * @return Closure(Number):Number
 * @throws InvalidArgumentException
 */
function multiply($initial = 1): Closure
{
    if (! C\isNumber($initial)) {
    if (! /** @scrutinizer ignore-call */ C\isNumber($initial)) {
        throw new InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
    }

    /**
     * @param Number $value
     * @return Number
     */
    return function ($value) use ($initial) {
        return $value * $initial;
    };
}



/**
 * Returns a function for divideBy a fixed amount.
 *
 * @param float $divisor The value to divide the passed value by
 * @return Closure(Number):float
 */
function divideBy($divisor = 1): Closure
{
    if (! C\isNumber($divisor)) {
    if (! /** @scrutinizer ignore-call */ C\isNumber($divisor)) {
        throw new \InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
    }

    /**
     * @param float $value
     * @return float
     */
    return function ($value) use ($divisor): float {
        return $value / $divisor;
    };
}

/**
 * Returns a function for divideInto a fixed amount.
 *
 * @param float $dividend The value to divide the passed value by
 * @return Closure(Number):float
 */
function divideInto($dividend = 1): Closure
{
    if (! C\isNumber($dividend)) {
    if (! /** @scrutinizer ignore-call */ C\isNumber($dividend)) {
        throw new \InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
    }

    /**
     * @param float $value
     * @return float
     */
    return function ($value) use ($dividend): float {
        return $dividend / $value;
    };
}

/**
 * Returns a function for getting the remainder with a fixed divisor.
 *
 * @param float $divisor
 * @return Closure(Number):float
 */
function remainderBy($divisor = 1): Closure
{
    if (! C\isNumber($divisor)) {
    if (! /** @scrutinizer ignore-call */ C\isNumber($divisor)) {
        throw new \InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
    }

    /**
     * @param float $value
     * @return float
     */
    return function ($value) use ($divisor): float {
        return $value % $divisor;
    };
}

/**
 * Returns a function for getting the remainder with a fixed dividend.
 *
 * @param float $dividend
 * @return Closure(Number):float
 */
function remainderInto($dividend = 1): Closure
{
    if (! C\isNumber($dividend)) {
    if (! /** @scrutinizer ignore-call */ C\isNumber($dividend)) {
        throw new \InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
    }

    /**
     * @param float $value
     * @return float
     */
    return function ($value) use ($dividend): float {
        return $dividend % $value;
    };
}

/**
 * Returns a function for checking if a number has a factor of another number.
 *
 * @param Number $factor
 * @return Closure(Number):bool
 * @throws InvalidArgumentException If neither int or float passed.
 */
function isFactorOf($factor): Closure
{
    if (! C\isNumber($factor)) {
    if (! /** @scrutinizer ignore-call */ C\isNumber($factor)) {
        throw new \InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
    }

    /**
     * @param Number $value
     * @return bool
 * @throws InvalidArgumentException If neither int or float passed.
     */
    return function ($value) use ($factor): bool {
        if (! C\isNumber($value)) {
        if (! /** @scrutinizer ignore-call */ C\isNumber($value)) {
            throw new \InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
        }

        // Return false if 0
        if ($value === 0) {
            return false;
        }

        return $value % $factor === 0;
    };
}


/**
 * Returns a function for getting the remainder with a fixed dividend.
 *
 * @param int $precision Number of decimal places.
 * @return Closure(Number):float
 */
function round($precision = 1): Closure
{
    if (! C\isNumber($precision)) {
    if (! /** @scrutinizer ignore-call */ C\isNumber($precision)) {
        throw new \InvalidArgumentException(__FUNCTION__ . 'only accepts a Number (Float or Int)');
    }

    /**
     * @param Number $value
     * @return float
     */
    return function ($value) use ($precision): float {
        if (! C\isNumber($value)) {
        if (! /** @scrutinizer ignore-call */ C\isNumber($value)) {
            throw new \InvalidArgumentException("Num\\round() only accepts a valid Number ( Int|Float -> Float )");
        }
        return \round(\floatval($value), $precision);
    };
}

gin0115 / pinkcrab_function_constructors

Pull Request — develop (#27)

isFactorOf() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
