mirror of
https://gitlab.com/signalytic/client-external/streamline/streamline-emr.git
synced 2026-09-12 19:21:33 +00:00
Import latest app updates from streamline
An updated set of source files and initialization was provided by streamline to address issues observed during initial testing. These files have been updated in order to generate a new set of app images.
This commit is contained in:
@@ -1,144 +0,0 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This file is part of the ramsey/uuid library
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*
|
||||
* @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
|
||||
* @license http://opensource.org/licenses/MIT MIT
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Ramsey\Uuid\Math;
|
||||
|
||||
use Brick\Math\BigDecimal;
|
||||
use Brick\Math\BigInteger;
|
||||
use Brick\Math\Exception\MathException;
|
||||
use Brick\Math\RoundingMode as BrickMathRounding;
|
||||
use Ramsey\Uuid\Exception\InvalidArgumentException;
|
||||
use Ramsey\Uuid\Type\Decimal;
|
||||
use Ramsey\Uuid\Type\Hexadecimal;
|
||||
use Ramsey\Uuid\Type\Integer as IntegerObject;
|
||||
use Ramsey\Uuid\Type\NumberInterface;
|
||||
|
||||
/**
|
||||
* A calculator using the brick/math library for arbitrary-precision arithmetic
|
||||
*
|
||||
* @psalm-immutable
|
||||
*/
|
||||
final class BrickMathCalculator implements CalculatorInterface
|
||||
{
|
||||
private const ROUNDING_MODE_MAP = [
|
||||
RoundingMode::UNNECESSARY => BrickMathRounding::UNNECESSARY,
|
||||
RoundingMode::UP => BrickMathRounding::UP,
|
||||
RoundingMode::DOWN => BrickMathRounding::DOWN,
|
||||
RoundingMode::CEILING => BrickMathRounding::CEILING,
|
||||
RoundingMode::FLOOR => BrickMathRounding::FLOOR,
|
||||
RoundingMode::HALF_UP => BrickMathRounding::HALF_UP,
|
||||
RoundingMode::HALF_DOWN => BrickMathRounding::HALF_DOWN,
|
||||
RoundingMode::HALF_CEILING => BrickMathRounding::HALF_CEILING,
|
||||
RoundingMode::HALF_FLOOR => BrickMathRounding::HALF_FLOOR,
|
||||
RoundingMode::HALF_EVEN => BrickMathRounding::HALF_EVEN,
|
||||
];
|
||||
|
||||
public function add(NumberInterface $augend, NumberInterface ...$addends): NumberInterface
|
||||
{
|
||||
$sum = BigInteger::of($augend->toString());
|
||||
|
||||
foreach ($addends as $addend) {
|
||||
$sum = $sum->plus($addend->toString());
|
||||
}
|
||||
|
||||
return new IntegerObject((string) $sum);
|
||||
}
|
||||
|
||||
public function subtract(NumberInterface $minuend, NumberInterface ...$subtrahends): NumberInterface
|
||||
{
|
||||
$difference = BigInteger::of($minuend->toString());
|
||||
|
||||
foreach ($subtrahends as $subtrahend) {
|
||||
$difference = $difference->minus($subtrahend->toString());
|
||||
}
|
||||
|
||||
return new IntegerObject((string) $difference);
|
||||
}
|
||||
|
||||
public function multiply(NumberInterface $multiplicand, NumberInterface ...$multipliers): NumberInterface
|
||||
{
|
||||
$product = BigInteger::of($multiplicand->toString());
|
||||
|
||||
foreach ($multipliers as $multiplier) {
|
||||
$product = $product->multipliedBy($multiplier->toString());
|
||||
}
|
||||
|
||||
return new IntegerObject((string) $product);
|
||||
}
|
||||
|
||||
public function divide(
|
||||
int $roundingMode,
|
||||
int $scale,
|
||||
NumberInterface $dividend,
|
||||
NumberInterface ...$divisors
|
||||
): NumberInterface {
|
||||
$brickRounding = $this->getBrickRoundingMode($roundingMode);
|
||||
|
||||
$quotient = BigDecimal::of($dividend->toString());
|
||||
|
||||
foreach ($divisors as $divisor) {
|
||||
$quotient = $quotient->dividedBy($divisor->toString(), $scale, $brickRounding);
|
||||
}
|
||||
|
||||
if ($scale === 0) {
|
||||
return new IntegerObject((string) $quotient->toBigInteger());
|
||||
}
|
||||
|
||||
return new Decimal((string) $quotient);
|
||||
}
|
||||
|
||||
public function fromBase(string $value, int $base): IntegerObject
|
||||
{
|
||||
try {
|
||||
return new IntegerObject((string) BigInteger::fromBase($value, $base));
|
||||
} catch (MathException | \InvalidArgumentException $exception) {
|
||||
throw new InvalidArgumentException(
|
||||
$exception->getMessage(),
|
||||
(int) $exception->getCode(),
|
||||
$exception
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
public function toBase(IntegerObject $value, int $base): string
|
||||
{
|
||||
try {
|
||||
return BigInteger::of($value->toString())->toBase($base);
|
||||
} catch (MathException | \InvalidArgumentException $exception) {
|
||||
throw new InvalidArgumentException(
|
||||
$exception->getMessage(),
|
||||
(int) $exception->getCode(),
|
||||
$exception
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
public function toHexadecimal(IntegerObject $value): Hexadecimal
|
||||
{
|
||||
return new Hexadecimal($this->toBase($value, 16));
|
||||
}
|
||||
|
||||
public function toInteger(Hexadecimal $value): IntegerObject
|
||||
{
|
||||
return $this->fromBase($value->toString(), 16);
|
||||
}
|
||||
|
||||
/**
|
||||
* Maps ramsey/uuid rounding modes to those used by brick/math
|
||||
*/
|
||||
private function getBrickRoundingMode(int $roundingMode): int
|
||||
{
|
||||
return self::ROUNDING_MODE_MAP[$roundingMode] ?? 0;
|
||||
}
|
||||
}
|
||||
@@ -1,106 +0,0 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This file is part of the ramsey/uuid library
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*
|
||||
* @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
|
||||
* @license http://opensource.org/licenses/MIT MIT
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Ramsey\Uuid\Math;
|
||||
|
||||
use Ramsey\Uuid\Type\Hexadecimal;
|
||||
use Ramsey\Uuid\Type\Integer as IntegerObject;
|
||||
use Ramsey\Uuid\Type\NumberInterface;
|
||||
|
||||
/**
|
||||
* A calculator performs arithmetic operations on numbers
|
||||
*
|
||||
* @psalm-immutable
|
||||
*/
|
||||
interface CalculatorInterface
|
||||
{
|
||||
/**
|
||||
* Returns the sum of all the provided parameters
|
||||
*
|
||||
* @param NumberInterface $augend The first addend (the integer being added to)
|
||||
* @param NumberInterface ...$addends The additional integers to a add to the augend
|
||||
*
|
||||
* @return NumberInterface The sum of all the parameters
|
||||
*/
|
||||
public function add(NumberInterface $augend, NumberInterface ...$addends): NumberInterface;
|
||||
|
||||
/**
|
||||
* Returns the difference of all the provided parameters
|
||||
*
|
||||
* @param NumberInterface $minuend The integer being subtracted from
|
||||
* @param NumberInterface ...$subtrahends The integers to subtract from the minuend
|
||||
*
|
||||
* @return NumberInterface The difference after subtracting all parameters
|
||||
*/
|
||||
public function subtract(NumberInterface $minuend, NumberInterface ...$subtrahends): NumberInterface;
|
||||
|
||||
/**
|
||||
* Returns the product of all the provided parameters
|
||||
*
|
||||
* @param NumberInterface $multiplicand The integer to be multiplied
|
||||
* @param NumberInterface ...$multipliers The factors by which to multiply the multiplicand
|
||||
*
|
||||
* @return NumberInterface The product of multiplying all the provided parameters
|
||||
*/
|
||||
public function multiply(NumberInterface $multiplicand, NumberInterface ...$multipliers): NumberInterface;
|
||||
|
||||
/**
|
||||
* Returns the quotient of the provided parameters divided left-to-right
|
||||
*
|
||||
* @param int $roundingMode The RoundingMode constant to use for this operation
|
||||
* @param int $scale The scale to use for this operation
|
||||
* @param NumberInterface $dividend The integer to be divided
|
||||
* @param NumberInterface ...$divisors The integers to divide $dividend by, in
|
||||
* the order in which the division operations should take place
|
||||
* (left-to-right)
|
||||
*
|
||||
* @return NumberInterface The quotient of dividing the provided parameters left-to-right
|
||||
*/
|
||||
public function divide(
|
||||
int $roundingMode,
|
||||
int $scale,
|
||||
NumberInterface $dividend,
|
||||
NumberInterface ...$divisors
|
||||
): NumberInterface;
|
||||
|
||||
/**
|
||||
* Converts a value from an arbitrary base to a base-10 integer value
|
||||
*
|
||||
* @param string $value The value to convert
|
||||
* @param int $base The base to convert from (i.e., 2, 16, 32, etc.)
|
||||
*
|
||||
* @return IntegerObject The base-10 integer value of the converted value
|
||||
*/
|
||||
public function fromBase(string $value, int $base): IntegerObject;
|
||||
|
||||
/**
|
||||
* Converts a base-10 integer value to an arbitrary base
|
||||
*
|
||||
* @param IntegerObject $value The integer value to convert
|
||||
* @param int $base The base to convert to (i.e., 2, 16, 32, etc.)
|
||||
*
|
||||
* @return string The value represented in the specified base
|
||||
*/
|
||||
public function toBase(IntegerObject $value, int $base): string;
|
||||
|
||||
/**
|
||||
* Converts an Integer instance to a Hexadecimal instance
|
||||
*/
|
||||
public function toHexadecimal(IntegerObject $value): Hexadecimal;
|
||||
|
||||
/**
|
||||
* Converts a Hexadecimal instance to an Integer instance
|
||||
*/
|
||||
public function toInteger(Hexadecimal $value): IntegerObject;
|
||||
}
|
||||
@@ -1,146 +0,0 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* This file was originally part of brick/math
|
||||
*
|
||||
* Copyright (c) 2013-present Benjamin Morel
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*
|
||||
* @link https://github.com/brick/math brick/math at GitHub
|
||||
*/
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Ramsey\Uuid\Math;
|
||||
|
||||
/**
|
||||
* Specifies a rounding behavior for numerical operations capable of discarding
|
||||
* precision.
|
||||
*
|
||||
* Each rounding mode indicates how the least significant returned digit of a
|
||||
* rounded result is to be calculated. If fewer digits are returned than the
|
||||
* digits needed to represent the exact numerical result, the discarded digits
|
||||
* will be referred to as the discarded fraction regardless the digits'
|
||||
* contribution to the value of the number. In other words, considered as a
|
||||
* numerical value, the discarded fraction could have an absolute value greater
|
||||
* than one.
|
||||
*/
|
||||
final class RoundingMode
|
||||
{
|
||||
/**
|
||||
* Private constructor. This class is not instantiable.
|
||||
*
|
||||
* @codeCoverageIgnore
|
||||
*/
|
||||
private function __construct()
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Asserts that the requested operation has an exact result, hence no
|
||||
* rounding is necessary.
|
||||
*/
|
||||
public const UNNECESSARY = 0;
|
||||
|
||||
/**
|
||||
* Rounds away from zero.
|
||||
*
|
||||
* Always increments the digit prior to a nonzero discarded fraction.
|
||||
* Note that this rounding mode never decreases the magnitude of the
|
||||
* calculated value.
|
||||
*/
|
||||
public const UP = 1;
|
||||
|
||||
/**
|
||||
* Rounds towards zero.
|
||||
*
|
||||
* Never increments the digit prior to a discarded fraction (i.e.,
|
||||
* truncates). Note that this rounding mode never increases the magnitude of
|
||||
* the calculated value.
|
||||
*/
|
||||
public const DOWN = 2;
|
||||
|
||||
/**
|
||||
* Rounds towards positive infinity.
|
||||
*
|
||||
* If the result is positive, behaves as for UP; if negative, behaves as for
|
||||
* DOWN. Note that this rounding mode never decreases the calculated value.
|
||||
*/
|
||||
public const CEILING = 3;
|
||||
|
||||
/**
|
||||
* Rounds towards negative infinity.
|
||||
*
|
||||
* If the result is positive, behave as for DOWN; if negative, behave as for
|
||||
* UP. Note that this rounding mode never increases the calculated value.
|
||||
*/
|
||||
public const FLOOR = 4;
|
||||
|
||||
/**
|
||||
* Rounds towards "nearest neighbor" unless both neighbors are equidistant,
|
||||
* in which case round up.
|
||||
*
|
||||
* Behaves as for UP if the discarded fraction is >= 0.5; otherwise, behaves
|
||||
* as for DOWN. Note that this is the rounding mode commonly taught at
|
||||
* school.
|
||||
*/
|
||||
public const HALF_UP = 5;
|
||||
|
||||
/**
|
||||
* Rounds towards "nearest neighbor" unless both neighbors are equidistant,
|
||||
* in which case round down.
|
||||
*
|
||||
* Behaves as for UP if the discarded fraction is > 0.5; otherwise, behaves
|
||||
* as for DOWN.
|
||||
*/
|
||||
public const HALF_DOWN = 6;
|
||||
|
||||
/**
|
||||
* Rounds towards "nearest neighbor" unless both neighbors are equidistant,
|
||||
* in which case round towards positive infinity.
|
||||
*
|
||||
* If the result is positive, behaves as for HALF_UP; if negative, behaves
|
||||
* as for HALF_DOWN.
|
||||
*/
|
||||
public const HALF_CEILING = 7;
|
||||
|
||||
/**
|
||||
* Rounds towards "nearest neighbor" unless both neighbors are equidistant,
|
||||
* in which case round towards negative infinity.
|
||||
*
|
||||
* If the result is positive, behaves as for HALF_DOWN; if negative, behaves
|
||||
* as for HALF_UP.
|
||||
*/
|
||||
public const HALF_FLOOR = 8;
|
||||
|
||||
/**
|
||||
* Rounds towards the "nearest neighbor" unless both neighbors are
|
||||
* equidistant, in which case rounds towards the even neighbor.
|
||||
*
|
||||
* Behaves as for HALF_UP if the digit to the left of the discarded fraction
|
||||
* is odd; behaves as for HALF_DOWN if it's even.
|
||||
*
|
||||
* Note that this is the rounding mode that statistically minimizes
|
||||
* cumulative error when applied repeatedly over a sequence of calculations.
|
||||
* It is sometimes known as "Banker's rounding", and is chiefly used in the
|
||||
* USA.
|
||||
*/
|
||||
public const HALF_EVEN = 9;
|
||||
}
|
||||
Reference in New Issue
Block a user