Collaboration diagram for PhpOffice\PhpSpreadsheet\Calculation\Calculation:

Public Member Functions
static static static	__construct (?Spreadsheet $spreadsheet=null)

	flushInstance ()
	Flush the calculation cache for any existing instance of this class but only if a Calculation instance exists. More...

	getDebugLog ()
	Get the Logger for this calculation engine instance. More...

	__clone ()
	__clone implementation. More...

	getCalculationCacheEnabled ()
	Is calculation caching enabled? More...

	setCalculationCacheEnabled ($pValue)
	Enable/disable calculation cache. More...

	enableCalculationCache ()
	Enable calculation cache. More...

	disableCalculationCache ()
	Disable calculation cache. More...

	clearCalculationCache ()
	Clear calculation cache. More...

	clearCalculationCacheForWorksheet ($worksheetName)
	Clear calculation cache for a specified worksheet. More...

	renameCalculationCacheForWorksheet ($fromWorksheetName, $toWorksheetName)
	Rename calculation cache for a specified worksheet. More...

	setBranchPruningEnabled ($enabled)
	Enable/disable calculation cache. More...

	enableBranchPruning ()

	disableBranchPruning ()

	clearBranchStore ()

	getLocale ()
	Get the currently defined locale code. More...

	setLocale (string $locale)
	Set the locale code. More...

	_translateFormulaToLocale ($formula)

	_translateFormulaToEnglish ($formula)

	calculate (?Cell $pCell=null)
	Calculate cell value (using formula from a cell ID) Retained for backward compatibility. More...

	calculateCellValue (?Cell $pCell=null, $resetLog=true)
	Calculate the value of a cell formula. More...

	parseFormula ($formula)
	Validate and parse a formula string. More...

	calculateFormula ($formula, $cellID=null, ?Cell $pCell=null)
	Calculate the value of a formula. More...

	getValueFromCache (string $cellReference, &$cellValue)

	saveValueToCache ($cellReference, $cellValue)

	_calculateFormulaValue ($formula, $cellID=null, ?Cell $pCell=null)
	Parse a cell formula and calculate its value. More...

	extractCellRange (&$pRange='A1', ?Worksheet $pSheet=null, $resetLog=true)
	Extract range values. More...

	extractNamedRange (&$pRange='A1', ?Worksheet $pSheet=null, $resetLog=true)
	Extract range values. More...

	isImplemented ($pFunction)
	Is a specific function implemented? More...

	getFunctions ()
	Get a list of all implemented functions as an array of function objects. More...

	getImplementedFunctionNames ()
	Get a list of implemented Excel function names. More...

Static Public Member Functions
static	getInstance (?Spreadsheet $spreadsheet=null)
	Get an instance of this class. More...

static	getTRUE ()
	Return the locale-specific translation of TRUE. More...

static	getFALSE ()
	Return the locale-specific translation of FALSE. More...

static	setArrayReturnType ($returnType)
	Set the Array Return Type (Array or Value of first element in the array). More...

static	getArrayReturnType ()
	Return the Array Return Type (Array or Value of first element in the array). More...

static	translateSeparator ($fromSeparator, $toSeparator, $formula, &$inBraces)

static	localeFunc ($function)

static	wrapResult ($value)
	Wrap string values in quotes. More...

static	unwrapResult ($value)
	Remove quotes used as a wrapper to identify string values. More...

static	getMatrixDimensions (array &$matrix)
	Read the dimensions of a matrix, and re-index it with straight numeric keys starting from row 0, column 0. More...

Data Fields
const	CALCULATION_REGEXP_NUMBER = '[-+]?\d*\.?\d+(e[-+]?\d+)?'
	Constants. More...

const	CALCULATION_REGEXP_STRING = '"(?:[^"]\|"")*"'

const	CALCULATION_REGEXP_OPENBRACE = '\('

const	CALCULATION_REGEXP_FUNCTION = '@?(?:_xlfn\.)?([\p{L}][\p{L}\p{N}\.])[\s]\('

const	CALCULATION_REGEXP_CELLREF = '((([^\s,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?\$?\b([a-z]{1,3})\$?(\d{1,7})(?![\w.])'

const	CALCULATION_REGEXP_CELLREF_RELATIVE = '((([^\s\(,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?(\$?\b[a-z]{1,3})(\$?\d{1,7})(?![\w.])'

const	CALCULATION_REGEXP_COLUMN_RANGE = '(((([^\s\(,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?(\$?[a-z]{1,3})):(?![.*])'

const	CALCULATION_REGEXP_ROW_RANGE = '(((([^\s\(,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?(\$?[1-9][0-9]{0,6})):(?![.*])'

const	CALCULATION_REGEXP_COLUMNRANGE_RELATIVE = '(\$?[a-z]{1,3}):(\$?[a-z]{1,3})'

const	CALCULATION_REGEXP_ROWRANGE_RELATIVE = '(\$?\d{1,7}):(\$?\d{1,7})'

const	CALCULATION_REGEXP_DEFINEDNAME = '((([^\s,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?([_\p{L}][_\p{L}\p{N}\.]*)'

const	CALCULATION_REGEXP_ERROR = '\#[A-Z][A-Z0_\/]*[!\?]?'

const	RETURN_ARRAY_AS_ERROR = 'error'
	constants More...

const	RETURN_ARRAY_AS_VALUE = 'value'

const	RETURN_ARRAY_AS_ARRAY = 'array'

const	FORMULA_OPEN_FUNCTION_BRACE = '{'

const	FORMULA_CLOSE_FUNCTION_BRACE = '}'

const	FORMULA_STRING_QUOTE = '"'

	$suppressFormulaErrors = false

	$formulaError

	$cyclicFormulaCount = 1

Static Public Attributes
static	$localeBoolean

Protected Member Functions
	raiseFormulaError ($errorMessage)

Private Member Functions
	getLocaleFile (string $localeDir, string $locale, string $language, string $file)

	showValue ($value)
	Format details of an operand for display in the log (based on operand type). More...

	showTypeDetails ($value)
	Format type and details of an operand for display in the log (based on operand type). More...

	convertMatrixReferences ($formula)

static static static	internalParseFormula ($formula, ?Cell $pCell=null)

	processTokenStack ($tokens, $cellID=null, ?Cell $pCell=null)

	validateBinaryOperand (&$operand, &$stack)

	executeArrayComparison ($cellID, $operand1, $operand2, $operation, Stack &$stack, bool $recursingArrays)

	executeBinaryComparisonOperation ($cellID, $operand1, $operand2, $operation, Stack &$stack, $recursingArrays=false)

	strcmpLowercaseFirst ($str1, $str2)
	Compare two strings in the same way as strcmp() except that lowercase come before uppercase letters. More...

	strcmpAllowNull ($str1, $str2)
	PHP8.1 deprecates passing null to strcmp. More...

	executeNumericBinaryOperation ($operand1, $operand2, $operation, $matrixFunction, &$stack)

	addCellReference (array $args, $passCellReference, $functionCall, ?Cell $pCell=null)
	Add cell reference if needed while making sure that it is the last argument. More...

	getUnusedBranchStoreKey ()

	getTokensAsString ($tokens)

	evaluateDefinedName (Cell $pCell, DefinedName $namedRange, Worksheet $pCellWorksheet, Stack $stack)

Static Private Member Functions
static	loadLocales ()

static	translateFormula (array $from, array $to, $formula, $fromSeparator, $toSeparator)

static	checkMatrixOperands (&$operand1, &$operand2, $resize=1)
	Ensure that paired matrix operands are both matrices and of the same size. More...

static	resizeMatricesShrink (&$matrix1, &$matrix2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns)
	Ensure that paired matrix operands are both matrices of the same size. More...

static	resizeMatricesExtend (&$matrix1, &$matrix2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns)
	Ensure that paired matrix operands are both matrices of the same size. More...

static	dataTestReference (&$operandData)

Private Attributes
	$spreadsheet

	$calculationCache = []

	$calculationCacheEnabled = true

	$branchStoreKeyCounter = 0

	$branchPruningEnabled = true

	$debugLog

	$cyclicReferenceStack

	$cellStack = []

	$cyclicFormulaCounter = 1

	$cyclicFormulaCell = ''

	$delta = 0.1e-12

Static Private Attributes
static	$returnArrayAsType = self::RETURN_ARRAY_AS_VALUE

static	$instance

static	$operators

static	$binaryOperators

static	$referenceHelper

static	$localeLanguage = 'en_us'

static	$validLocaleLanguages

static	$localeArgumentSeparator = ','

static	$localeFunctions = []

static	$excelConstants

static static	$phpSpreadsheetFunctions

static static static	$controlFunctions

static	$functionReplaceFromExcel = null

static	$functionReplaceToLocale = null

static	$functionReplaceFromLocale = null

static	$functionReplaceToExcel = null

static	$operatorAssociativity

static static	$comparisonOperators = ['>' => true

static static static	$operatorPrecedence

Detailed Description

Definition at line 17 of file Calculation.php.

Constructor & Destructor Documentation

◆ __construct()

static static static PhpOffice\PhpSpreadsheet\Calculation\Calculation::__construct ( ?Spreadsheet $spreadsheet = null )

Definition at line 2758 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$spreadsheet, and PhpOffice\PhpSpreadsheet\ReferenceHelper\getInstance().

     {
         $this->delta = 1 * 10 ** (0 - ini_get('precision'));
 
         $this->spreadsheet = $spreadsheet;
         $this->cyclicReferenceStack = new CyclicReferenceStack();
         $this->debugLog = new Logger($this->cyclicReferenceStack);
         self::$referenceHelper = ReferenceHelper::getInstance();
     }

Here is the call graph for this function:

Member Function Documentation

◆ __clone()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::__clone ( )

final

__clone implementation.

Cloning should not be allowed in a Singleton!

Definition at line 2824 of file Calculation.php.

     {
         throw new Exception('Cloning the calculation engine is not allowed!');
     }

◆ _calculateFormulaValue()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::_calculateFormulaValue	(		$formula,
			$cellID = `null`,
		?Cell	$pCell = `null`
	)

Parse a cell formula and calculate its value.

Parameters

string	$formula	The formula to parse and calculate
string	$cellID	The ID (e.g. A3) of the cell that we are calculating
Cell	$pCell	Cell to calculate

Returns: mixed

Definition at line 3482 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$cyclicFormulaCounter, PhpOffice\PhpSpreadsheet\Calculation\Calculation\getValueFromCache(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\raiseFormulaError(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\saveValueToCache().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateCellValue(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateFormula().

     {
         $cellValue = null;
 
         //  Quote-Prefixed cell values cannot be formulae, but are treated as strings
         if ($pCell !== null && $pCell->getStyle()->getQuotePrefix() === true) {
             return self::wrapResult((string) $formula);
         }
 
         if (preg_match('/^=\s*cmd\s*\|/miu', $formula) !== 0) {
             return self::wrapResult($formula);
         }
 
         //    Basic validation that this is indeed a formula
         //    We simply return the cell value if not
         $formula = trim($formula);
         if ($formula[0] != '=') {
             return self::wrapResult($formula);
         }
         $formula = ltrim(substr($formula, 1));
         if (!isset($formula[0])) {
             return self::wrapResult($formula);
         }
 
         $pCellParent = ($pCell !== null) ? $pCell->getWorksheet() : null;
         $wsTitle = ($pCellParent !== null) ? $pCellParent->getTitle() : "\x00Wrk";
         $wsCellReference = $wsTitle . '!' . $cellID;
 
         if (($cellID !== null) && ($this->getValueFromCache($wsCellReference, $cellValue))) {
             return $cellValue;
         }
         $this->debugLog->writeDebugLog("Evaluating formula for cell {$wsCellReference}");
 
         if (($wsTitle[0] !== "\x00") && ($this->cyclicReferenceStack->onStack($wsCellReference))) {
             if ($this->cyclicFormulaCount <= 0) {
                 $this->cyclicFormulaCell = '';
 
                 return $this->raiseFormulaError('Cyclic Reference in Formula');
             } elseif ($this->cyclicFormulaCell === $wsCellReference) {
                 ++$this->cyclicFormulaCounter;
                 if ($this->cyclicFormulaCounter >= $this->cyclicFormulaCount) {
                     $this->cyclicFormulaCell = '';
 
                     return $cellValue;
                 }
             } elseif ($this->cyclicFormulaCell == '') {
                 if ($this->cyclicFormulaCounter >= $this->cyclicFormulaCount) {
                     return $cellValue;
                 }
                 $this->cyclicFormulaCell = $wsCellReference;
             }
         }
 
         $this->debugLog->writeDebugLog("Formula for cell {$wsCellReference} is {$formula}");
         //    Parse the formula onto the token stack and calculate the value
         $this->cyclicReferenceStack->push($wsCellReference);
 
         $cellValue = $this->processTokenStack($this->internalParseFormula($formula, $pCell), $cellID, $pCell);
         $this->cyclicReferenceStack->pop();
 
         // Save to calculation cache
         if ($cellID !== null) {
             $this->saveValueToCache($wsCellReference, $cellValue);
         }
 
         //    Return the calculated value
         return $cellValue;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _translateFormulaToEnglish()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::_translateFormulaToEnglish ( $formula )

Definition at line 3195 of file Calculation.php.

     {
         if (self::$functionReplaceFromLocale === null) {
             self::$functionReplaceFromLocale = [];
             foreach (self::$localeFunctions as $localeFunctionName) {
                 self::$functionReplaceFromLocale[] = '/(@?[^\w\.])' . preg_quote($localeFunctionName, '/') . '([\s]*\()/Ui';
             }
             foreach (self::$localeBoolean as $excelBoolean) {
                 self::$functionReplaceFromLocale[] = '/(@?[^\w\.])' . preg_quote($excelBoolean, '/') . '([^\w\.])/Ui';
             }
         }
 
         if (self::$functionReplaceToExcel === null) {
             self::$functionReplaceToExcel = [];
             foreach (array_keys(self::$localeFunctions) as $excelFunctionName) {
                 self::$functionReplaceToExcel[] = '$1' . trim($excelFunctionName) . '$2';
             }
             foreach (array_keys(self::$localeBoolean) as $excelBoolean) {
                 self::$functionReplaceToExcel[] = '$1' . trim($excelBoolean) . '$2';
             }
         }
 
         return self::translateFormula(self::$functionReplaceFromLocale, self::$functionReplaceToExcel, $formula, self::$localeArgumentSeparator, ',');
     }

◆ _translateFormulaToLocale()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::_translateFormulaToLocale ( $formula )

Definition at line 3166 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$localeBoolean.

     {
         if (self::$functionReplaceFromExcel === null) {
             self::$functionReplaceFromExcel = [];
             foreach (array_keys(self::$localeFunctions) as $excelFunctionName) {
                 self::$functionReplaceFromExcel[] = '/(@?[^\w\.])' . preg_quote($excelFunctionName, '/') . '([\s]*\()/Ui';
             }
             foreach (array_keys(self::$localeBoolean) as $excelBoolean) {
                 self::$functionReplaceFromExcel[] = '/(@?[^\w\.])' . preg_quote($excelBoolean, '/') . '([^\w\.])/Ui';
             }
         }
 
         if (self::$functionReplaceToLocale === null) {
             self::$functionReplaceToLocale = [];
             foreach (self::$localeFunctions as $localeFunctionName) {
                 self::$functionReplaceToLocale[] = '$1' . trim($localeFunctionName) . '$2';
             }
             foreach (self::$localeBoolean as $localeBoolean) {
                 self::$functionReplaceToLocale[] = '$1' . trim($localeBoolean) . '$2';
             }
         }
 
         return self::translateFormula(self::$functionReplaceFromExcel, self::$functionReplaceToLocale, $formula, ',', self::$localeArgumentSeparator);
     }

◆ addCellReference()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::addCellReference	(	array	$args,
			$passCellReference,
			$functionCall,
		?Cell	$pCell = `null`
	)

private

Add cell reference if needed while making sure that it is the last argument.

Parameters

bool	$passCellReference
array \| string	$functionCall

Returns: array

Definition at line 5397 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

     {
         if ($passCellReference) {
             if (is_array($functionCall)) {
                 $className = $functionCall[0];
                 $methodName = $functionCall[1];
 
                 $reflectionMethod = new ReflectionMethod($className, $methodName);
                 $argumentCount = count($reflectionMethod->getParameters());
                 while (count($args) < $argumentCount - 1) {
                     $args[] = null;
                 }
             }
 
             $args[] = $pCell;
         }
 
         return $args;
     }

Here is the caller graph for this function:

◆ calculate()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::calculate ( ?Cell $pCell = null )

Calculate cell value (using formula from a cell ID) Retained for backward compatibility.

Parameters

Cell $pCell Cell to calculate

Returns: mixed

Definition at line 3291 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateCellValue().

     {
         try {
             return $this->calculateCellValue($pCell);
         } catch (\Exception $e) {
             throw new Exception($e->getMessage());
         }
     }

Here is the call graph for this function:

◆ calculateCellValue()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::calculateCellValue	(	?Cell	$pCell = `null`,
			$resetLog = `true`
	)

Calculate the value of a cell formula.

Parameters

Cell	$pCell	Cell to calculate
bool	$resetLog	Flag indicating whether the debug log should be reset or not

Returns: mixed

Definition at line 3308 of file Calculation.php.

References $c, $r, $result, PhpOffice\PhpSpreadsheet\Calculation\Calculation\$returnArrayAsType, PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue(), PhpOffice\PhpSpreadsheet\Calculation\Functions\flattenArray(), PhpOffice\PhpSpreadsheet\Calculation\Functions\NAN(), and PhpOffice\PhpSpreadsheet\Calculation\Functions\VALUE().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculate().

     {
         if ($pCell === null) {
             return null;
         }
 
         $returnArrayAsType = self::$returnArrayAsType;
         if ($resetLog) {
             //    Initialise the logging settings if requested
             $this->formulaError = null;
             $this->debugLog->clearLog();
             $this->cyclicReferenceStack->clear();
             $this->cyclicFormulaCounter = 1;
 
             self::$returnArrayAsType = self::RETURN_ARRAY_AS_ARRAY;
         }
 
         //    Execute the calculation for the cell formula
         $this->cellStack[] = [
             'sheet' => $pCell->getWorksheet()->getTitle(),
             'cell' => $pCell->getCoordinate(),
         ];
 
         try {
             $result = self::unwrapResult($this->_calculateFormulaValue($pCell->getValue(), $pCell->getCoordinate(), $pCell));
             $cellAddress = array_pop($this->cellStack);
             $this->spreadsheet->getSheetByName($cellAddress['sheet'])->getCell($cellAddress['cell']);
         } catch (\Exception $e) {
             $cellAddress = array_pop($this->cellStack);
             $this->spreadsheet->getSheetByName($cellAddress['sheet'])->getCell($cellAddress['cell']);
 
             throw new Exception($e->getMessage());
         }
 
         if ((is_array($result)) && (self::$returnArrayAsType != self::RETURN_ARRAY_AS_ARRAY)) {
             self::$returnArrayAsType = $returnArrayAsType;
             $testResult = Functions::flattenArray($result);
             if (self::$returnArrayAsType == self::RETURN_ARRAY_AS_ERROR) {
                 return Functions::VALUE();
             }
             //    If there's only a single cell in the array, then we allow it
             if (count($testResult) != 1) {
                 //    If keys are numeric, then it's a matrix result rather than a cell range result, so we permit it
                 $r = array_keys($result);
                 $r = array_shift($r);
                 if (!is_numeric($r)) {
                     return Functions::VALUE();
                 }
                 if (is_array($result[$r])) {
                     $c = array_keys($result[$r]);
                     $c = array_shift($c);
                     if (!is_numeric($c)) {
                         return Functions::VALUE();
                     }
                 }
             }
             $result = array_shift($testResult);
         }
         self::$returnArrayAsType = $returnArrayAsType;
 
         if ($result === null && $pCell->getWorksheet()->getSheetView()->getShowZeros()) {
             return 0;
         } elseif ((is_float($result)) && ((is_nan($result)) || (is_infinite($result)))) {
             return Functions::NAN();
         }
 
         return $result;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculateFormula()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::calculateFormula	(		$formula,
			$cellID = `null`,
		?Cell	$pCell = `null`
	)

Calculate the value of a formula.

Parameters

string	$formula	Formula to parse
string	$cellID	Address of the cell to calculate
Cell	$pCell	Cell to calculate

Returns: mixed

Definition at line 3410 of file Calculation.php.

References $result, PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\getCalculationCacheEnabled().

     {
         //    Initialise the logging settings
         $this->formulaError = null;
         $this->debugLog->clearLog();
         $this->cyclicReferenceStack->clear();
 
         $resetCache = $this->getCalculationCacheEnabled();
         if ($this->spreadsheet !== null && $cellID === null && $pCell === null) {
             $cellID = 'A1';
             $pCell = $this->spreadsheet->getActiveSheet()->getCell($cellID);
         } else {
             //    Disable calculation cacheing because it only applies to cell calculations, not straight formulae
             //    But don't actually flush any cache
             $this->calculationCacheEnabled = false;
         }
 
         //    Execute the calculation
         try {
             $result = self::unwrapResult($this->_calculateFormulaValue($formula, $cellID, $pCell));
         } catch (\Exception $e) {
             throw new Exception($e->getMessage());
         }
 
         if ($this->spreadsheet === null) {
             //    Reset calculation cacheing to its previous state
             $this->calculationCacheEnabled = $resetCache;
         }
 
         return $result;
     }

Here is the call graph for this function:

◆ checkMatrixOperands()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::checkMatrixOperands	(	&	$operand1,
		&	$operand2,
			$resize = `1`
	)

staticprivate

Ensure that paired matrix operands are both matrices and of the same size.

Parameters

mixed	$operand1	First matrix operand
mixed	$operand2	Second matrix operand
int	$resize	Flag indicating whether the matrices should be resized to match and (if so), whether the smaller dimension should grow or the larger should shrink. 0 = no resize 1 = shrink to fit 2 = extend to fit

Returns: array

Definition at line 3565 of file Calculation.php.

     {
         //    Examine each of the two operands, and turn them into an array if they aren't one already
         //    Note that this function should only be called if one or both of the operand is already an array
         if (!is_array($operand1)) {
             [$matrixRows, $matrixColumns] = self::getMatrixDimensions($operand2);
             $operand1 = array_fill(0, $matrixRows, array_fill(0, $matrixColumns, $operand1));
             $resize = 0;
         } elseif (!is_array($operand2)) {
             [$matrixRows, $matrixColumns] = self::getMatrixDimensions($operand1);
             $operand2 = array_fill(0, $matrixRows, array_fill(0, $matrixColumns, $operand2));
             $resize = 0;
         }
 
         [$matrix1Rows, $matrix1Columns] = self::getMatrixDimensions($operand1);
         [$matrix2Rows, $matrix2Columns] = self::getMatrixDimensions($operand2);
         if (($matrix1Rows == $matrix2Columns) && ($matrix2Rows == $matrix1Columns)) {
             $resize = 1;
         }
 
         if ($resize == 2) {
             //    Given two matrices of (potentially) unequal size, convert the smaller in each dimension to match the larger
             self::resizeMatricesExtend($operand1, $operand2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns);
         } elseif ($resize == 1) {
             //    Given two matrices of (potentially) unequal size, convert the larger in each dimension to match the smaller
             self::resizeMatricesShrink($operand1, $operand2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns);
         }
 
         return [$matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns];
     }

◆ clearBranchStore()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::clearBranchStore ( )

Definition at line 2972 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\flushInstance().

                                       : void
     {
         $this->branchStoreKeyCounter = 0;
     }

Here is the caller graph for this function:

◆ clearCalculationCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::clearCalculationCache ( )

Clear calculation cache.

Definition at line 2921 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\flushInstance(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\setCalculationCacheEnabled().

                                            : void
     {
         $this->calculationCache = [];
     }

Here is the caller graph for this function:

◆ clearCalculationCacheForWorksheet()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::clearCalculationCacheForWorksheet ( $worksheetName )

Clear calculation cache for a specified worksheet.

Parameters

string $worksheetName

Definition at line 2931 of file Calculation.php.

                                                                      : void
     {
         if (isset($this->calculationCache[$worksheetName])) {
             unset($this->calculationCache[$worksheetName]);
         }
     }

◆ convertMatrixReferences()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::convertMatrixReferences ( $formula )

private

Parameters

string $formula

Returns: false|string False indicates an error

Definition at line 3794 of file Calculation.php.

References $i, and PhpOffice\PhpSpreadsheet\Calculation\Calculation\raiseFormulaError().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula().

     {
         static $matrixReplaceFrom = [self::FORMULA_OPEN_FUNCTION_BRACE, ';', self::FORMULA_CLOSE_FUNCTION_BRACE];
         static $matrixReplaceTo = ['MKMATRIX(MKMATRIX(', '),MKMATRIX(', '))'];
 
         //    Convert any Excel matrix references to the MKMATRIX() function
         if (strpos($formula, self::FORMULA_OPEN_FUNCTION_BRACE) !== false) {
             //    If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
             if (strpos($formula, self::FORMULA_STRING_QUOTE) !== false) {
                 //    So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
                 //        the formula
                 $temp = explode(self::FORMULA_STRING_QUOTE, $formula);
                 //    Open and Closed counts used for trapping mismatched braces in the formula
                 $openCount = $closeCount = 0;
                 $i = false;
                 foreach ($temp as &$value) {
                     //    Only count/replace in alternating array entries
                     if ($i = !$i) {
                         $openCount += substr_count($value, self::FORMULA_OPEN_FUNCTION_BRACE);
                         $closeCount += substr_count($value, self::FORMULA_CLOSE_FUNCTION_BRACE);
                         $value = str_replace($matrixReplaceFrom, $matrixReplaceTo, $value);
                     }
                 }
                 unset($value);
                 //    Then rebuild the formula string
                 $formula = implode(self::FORMULA_STRING_QUOTE, $temp);
             } else {
                 //    If there's no quoted strings, then we do a simple count/replace
                 $openCount = substr_count($formula, self::FORMULA_OPEN_FUNCTION_BRACE);
                 $closeCount = substr_count($formula, self::FORMULA_CLOSE_FUNCTION_BRACE);
                 $formula = str_replace($matrixReplaceFrom, $matrixReplaceTo, $formula);
             }
             //    Trap for mismatched braces and trigger an appropriate error
             if ($openCount < $closeCount) {
                 if ($openCount > 0) {
                     return $this->raiseFormulaError("Formula Error: Mismatched matrix braces '}'");
                 }
 
                 return $this->raiseFormulaError("Formula Error: Unexpected '}' encountered");
             } elseif ($openCount > $closeCount) {
                 if ($closeCount > 0) {
                     return $this->raiseFormulaError("Formula Error: Mismatched matrix braces '{'");
                 }
 
                 return $this->raiseFormulaError("Formula Error: Unexpected '{' encountered");
             }
         }
 
         return $formula;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dataTestReference()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::dataTestReference ( & $operandData )

staticprivate

Definition at line 4361 of file Calculation.php.

     {
         $operand = $operandData['value'];
         if (($operandData['reference'] === null) && (is_array($operand))) {
             $rKeys = array_keys($operand);
             $rowKey = array_shift($rKeys);
             $cKeys = array_keys(array_keys($operand[$rowKey]));
             $colKey = array_shift($cKeys);
             if (ctype_upper($colKey)) {
                 $operandData['reference'] = $colKey . $rowKey;
             }
         }
 
         return $operand;
     }

◆ disableBranchPruning()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::disableBranchPruning ( )

Definition at line 2967 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\setBranchPruningEnabled().

                                           : void
     {
         $this->setBranchPruningEnabled(false);
     }

Here is the call graph for this function:

◆ disableCalculationCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::disableCalculationCache ( )

Disable calculation cache.

Definition at line 2913 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\setCalculationCacheEnabled().

                                              : void
     {
         $this->setCalculationCacheEnabled(false);
     }

Here is the call graph for this function:

◆ enableBranchPruning()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::enableBranchPruning ( )

Definition at line 2962 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\setBranchPruningEnabled().

                                          : void
     {
         $this->setBranchPruningEnabled(true);
     }

Here is the call graph for this function:

◆ enableCalculationCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::enableCalculationCache ( )

Enable calculation cache.

Definition at line 2905 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\setCalculationCacheEnabled().

                                             : void
     {
         $this->setCalculationCacheEnabled(true);
     }

Here is the call graph for this function:

◆ evaluateDefinedName()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::evaluateDefinedName	(	Cell	$pCell,
		DefinedName	$namedRange,
		Worksheet	$pCellWorksheet,
		Stack	$stack
	)

private

Returns: mixed|string

Definition at line 5442 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

     {
         $definedNameScope = $namedRange->getScope();
         if ($definedNameScope !== null && $definedNameScope !== $pCellWorksheet) {
             // The defined name isn't in our current scope, so #REF
             $result = Functions::REF();
             $stack->push('Error', $result, $namedRange->getName());
 
             return $result;
         }
 
         $definedNameValue = $namedRange->getValue();
         $definedNameType = $namedRange->isFormula() ? 'Formula' : 'Range';
         $definedNameWorksheet = $namedRange->getWorksheet();
 
         if ($definedNameValue[0] !== '=') {
             $definedNameValue = '=' . $definedNameValue;
         }
 
         $this->debugLog->writeDebugLog("Defined Name is a {$definedNameType} with a value of {$definedNameValue}");
 
         $recursiveCalculationCell = ($definedNameWorksheet !== null && $definedNameWorksheet !== $pCellWorksheet)
             ? $definedNameWorksheet->getCell('A1')
             : $pCell;
         $recursiveCalculationCellAddress = $recursiveCalculationCell->getCoordinate();
 
         // Adjust relative references in ranges and formulae so that we execute the calculation for the correct rows and columns
         $definedNameValue = self::$referenceHelper->updateFormulaReferencesAnyWorksheet(
             $definedNameValue,
             Coordinate::columnIndexFromString($pCell->getColumn()) - 1,
             $pCell->getRow() - 1
         );
 
         $this->debugLog->writeDebugLog("Value adjusted for relative references is {$definedNameValue}");
 
         $recursiveCalculator = new self($this->spreadsheet);
         $recursiveCalculator->getDebugLog()->setWriteDebugLog($this->getDebugLog()->getWriteDebugLog());
         $recursiveCalculator->getDebugLog()->setEchoDebugLog($this->getDebugLog()->getEchoDebugLog());
         $result = $recursiveCalculator->_calculateFormulaValue($definedNameValue, $recursiveCalculationCellAddress, $recursiveCalculationCell);
 
         if ($this->getDebugLog()->getWriteDebugLog()) {
             $this->debugLog->mergeDebugLog(array_slice($recursiveCalculator->getDebugLog()->getLog(), 3));
             $this->debugLog->writeDebugLog("Evaluation Result for Named {$definedNameType} {$namedRange->getName()} is {$this->showTypeDetails($result)}");
         }
 
         $stack->push('Defined Name', $result, $namedRange->getName());
 
         return $result;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ executeArrayComparison()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::executeArrayComparison	(		$cellID,
			$operand1,
			$operand2,
			$operation,
		Stack &	$stack,
		bool	$recursingArrays
	)

private

Parameters

null \| string	$cellID
mixed	$operand1
mixed	$operand2
string	$operation

Returns: array

Definition at line 4948 of file Calculation.php.

References $r, $result, $x, PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation(), PhpOffice\PhpSpreadsheet\Calculation\Token\Stack\pop(), PhpOffice\PhpSpreadsheet\Calculation\Token\Stack\push(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\showTypeDetails(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\showValue().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation().

     {
         $result = [];
         if (!is_array($operand2)) {
             // Operand 1 is an array, Operand 2 is a scalar
             foreach ($operand1 as $x => $operandData) {
                 $this->debugLog->writeDebugLog('Evaluating Comparison ', $this->showValue($operandData), ' ', $operation, ' ', $this->showValue($operand2));
                 $this->executeBinaryComparisonOperation($cellID, $operandData, $operand2, $operation, $stack);
                 $r = $stack->pop();
                 $result[$x] = $r['value'];
             }
         } elseif (!is_array($operand1)) {
             // Operand 1 is a scalar, Operand 2 is an array
             foreach ($operand2 as $x => $operandData) {
                 $this->debugLog->writeDebugLog('Evaluating Comparison ', $this->showValue($operand1), ' ', $operation, ' ', $this->showValue($operandData));
                 $this->executeBinaryComparisonOperation($cellID, $operand1, $operandData, $operation, $stack);
                 $r = $stack->pop();
                 $result[$x] = $r['value'];
             }
         } else {
             // Operand 1 and Operand 2 are both arrays
             if (!$recursingArrays) {
                 self::checkMatrixOperands($operand1, $operand2, 2);
             }
             foreach ($operand1 as $x => $operandData) {
                 $this->debugLog->writeDebugLog('Evaluating Comparison ', $this->showValue($operandData), ' ', $operation, ' ', $this->showValue($operand2[$x]));
                 $this->executeBinaryComparisonOperation($cellID, $operandData, $operand2[$x], $operation, $stack, true);
                 $r = $stack->pop();
                 $result[$x] = $r['value'];
             }
         }
         //    Log the result details
         $this->debugLog->writeDebugLog('Comparison Evaluation Result is ', $this->showTypeDetails($result));
         //    And push the result onto the stack
         $stack->push('Array', $result);
 
         return $result;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ executeBinaryComparisonOperation()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::executeBinaryComparisonOperation	(		$cellID,
			$operand1,
			$operand2,
			$operation,
		Stack &	$stack,
			$recursingArrays = `false`
	)

private

Parameters

null \| string	$cellID
mixed	$operand1
mixed	$operand2
string	$operation
bool	$recursingArrays

Returns: mixed

Definition at line 4996 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeArrayComparison(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

     {
         //    If we're dealing with matrix operations, we want a matrix result
         if ((is_array($operand1)) || (is_array($operand2))) {
             return $this->executeArrayComparison($cellID, $operand1, $operand2, $operation, $stack, $recursingArrays);
         }
 
         //    Simple validate the two operands if they are string values
         if (is_string($operand1) && $operand1 > '' && $operand1[0] == self::FORMULA_STRING_QUOTE) {
             $operand1 = self::unwrapResult($operand1);
         }
         if (is_string($operand2) && $operand2 > '' && $operand2[0] == self::FORMULA_STRING_QUOTE) {
             $operand2 = self::unwrapResult($operand2);
         }
 
         // Use case insensitive comparaison if not OpenOffice mode
         if (Functions::getCompatibilityMode() != Functions::COMPATIBILITY_OPENOFFICE) {
             if (is_string($operand1)) {
                 $operand1 = Shared\StringHelper::strToUpper($operand1);
             }
             if (is_string($operand2)) {
                 $operand2 = Shared\StringHelper::strToUpper($operand2);
             }
         }
 
         $useLowercaseFirstComparison = is_string($operand1) && is_string($operand2) && Functions::getCompatibilityMode() == Functions::COMPATIBILITY_OPENOFFICE;
 
         //    execute the necessary operation
         switch ($operation) {
             //    Greater than
             case '>':
                 if ($useLowercaseFirstComparison) {
                     $result = $this->strcmpLowercaseFirst($operand1, $operand2) > 0;
                 } else {
                     $result = ($operand1 > $operand2);
                 }
 
                 break;
             //    Less than
             case '<':
                 if ($useLowercaseFirstComparison) {
                     $result = $this->strcmpLowercaseFirst($operand1, $operand2) < 0;
                 } else {
                     $result = ($operand1 < $operand2);
                 }
 
                 break;
             //    Equality
             case '=':
                 if (is_numeric($operand1) && is_numeric($operand2)) {
                     $result = (abs($operand1 - $operand2) < $this->delta);
                 } else {
                     $result = $this->strcmpAllowNull($operand1, $operand2) == 0;
                 }
 
                 break;
             //    Greater than or equal
             case '>=':
                 if (is_numeric($operand1) && is_numeric($operand2)) {
                     $result = ((abs($operand1 - $operand2) < $this->delta) || ($operand1 > $operand2));
                 } elseif ($useLowercaseFirstComparison) {
                     $result = $this->strcmpLowercaseFirst($operand1, $operand2) >= 0;
                 } else {
                     $result = $this->strcmpAllowNull($operand1, $operand2) >= 0;
                 }
 
                 break;
             //    Less than or equal
             case '<=':
                 if (is_numeric($operand1) && is_numeric($operand2)) {
                     $result = ((abs($operand1 - $operand2) < $this->delta) || ($operand1 < $operand2));
                 } elseif ($useLowercaseFirstComparison) {
                     $result = $this->strcmpLowercaseFirst($operand1, $operand2) <= 0;
                 } else {
                     $result = $this->strcmpAllowNull($operand1, $operand2) <= 0;
                 }
 
                 break;
             //    Inequality
             case '<>':
                 if (is_numeric($operand1) && is_numeric($operand2)) {
                     $result = (abs($operand1 - $operand2) > 1E-14);
                 } else {
                     $result = $this->strcmpAllowNull($operand1, $operand2) != 0;
                 }
 
                 break;
 
             default:
                 throw new Exception('Unsupported binary comparison operation');
         }
 
         //    Log the result details
         $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($result));
         //    And push the result onto the stack
         $stack->push('Value', $result);
 
         return $result;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ executeNumericBinaryOperation()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::executeNumericBinaryOperation	(		$operand1,
			$operand2,
			$operation,
			$matrixFunction,
		&	$stack
	)

private

Parameters

mixed	$operand1
mixed	$operand2
mixed	$operation
string	$matrixFunction
mixed	$stack

Returns: bool|mixed

Definition at line 5134 of file Calculation.php.

References $matrix, $result, PhpOffice\PhpSpreadsheet\Calculation\Functions\COMPATIBILITY_OPENOFFICE, PhpOffice\PhpSpreadsheet\Calculation\Functions\getCompatibilityMode(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\showTypeDetails(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\validateBinaryOperand(), and PhpOffice\PhpSpreadsheet\Calculation\Functions\VALUE().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

     {
         //    Validate the two operands
         if (!$this->validateBinaryOperand($operand1, $stack)) {
             return false;
         }
         if (!$this->validateBinaryOperand($operand2, $stack)) {
             return false;
         }
 
         //    If either of the operands is a matrix, we need to treat them both as matrices
         //        (converting the other operand to a matrix if need be); then perform the required
         //        matrix operation
         if ((is_array($operand1)) || (is_array($operand2))) {
             //    Ensure that both operands are arrays/matrices of the same size
             self::checkMatrixOperands($operand1, $operand2, 2);
 
             try {
                 //    Convert operand 1 from a PHP array to a matrix
                 $matrix = new Shared\JAMA\Matrix($operand1);
                 //    Perform the required operation against the operand 1 matrix, passing in operand 2
                 $matrixResult = $matrix->$matrixFunction($operand2);
                 $result = $matrixResult->getArray();
             } catch (\Exception $ex) {
                 $this->debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
                 $result = '#VALUE!';
             }
         } else {
             if (
                 (Functions::getCompatibilityMode() != Functions::COMPATIBILITY_OPENOFFICE) &&
                 ((is_string($operand1) && !is_numeric($operand1) && strlen($operand1) > 0) ||
                     (is_string($operand2) && !is_numeric($operand2) && strlen($operand2) > 0))
             ) {
                 $result = Functions::VALUE();
             } else {
                 //    If we're dealing with non-matrix operations, execute the necessary operation
                 switch ($operation) {
                     //    Addition
                     case '+':
                         $result = $operand1 + $operand2;
 
                         break;
                     //    Subtraction
                     case '-':
                         $result = $operand1 - $operand2;
 
                         break;
                     //    Multiplication
                     case '*':
                         $result = $operand1 * $operand2;
 
                         break;
                     //    Division
                     case '/':
                         if ($operand2 == 0) {
                             //    Trap for Divide by Zero error
                             $stack->push('Error', '#DIV/0!');
                             $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails('#DIV/0!'));
 
                             return false;
                         }
                         $result = $operand1 / $operand2;
 
                         break;
                     //    Power
                     case '^':
                         $result = $operand1 ** $operand2;
 
                         break;
 
                     default:
                         throw new Exception('Unsupported numeric binary operation');
                 }
             }
         }
 
         //    Log the result details
         $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($result));
         //    And push the result onto the stack
         $stack->push('Value', $result);
 
         return $result;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extractCellRange()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::extractCellRange	(	&	$pRange = `'A1'`,
		?Worksheet	$pSheet = `null`,
			$resetLog = `true`
	)

Extract range values.

Parameters

string	$pRange	String based range representation
Worksheet	$pSheet	Worksheet
bool	$resetLog	Flag indicating whether calculation log should be reset or not

Returns: mixed Array of values in range if range contains more than one element. Otherwise, a single value is returned.

Definition at line 5240 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Cell\Coordinate\extractAllCellReferencesInRange(), and PhpOffice\PhpSpreadsheet\Worksheet\Worksheet\extractSheetTitle().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Indirect\extractRequiredCells(), PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Offset\extractRequiredCells(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

     {
         // Return value
         $returnValue = [];
 
         if ($pSheet !== null) {
             $pSheetName = $pSheet->getTitle();
 
             if (strpos($pRange, '!') !== false) {
                 [$pSheetName, $pRange] = Worksheet::extractSheetTitle($pRange, true);
                 $pSheet = $this->spreadsheet->getSheetByName($pSheetName);
             }
 
             // Extract range
             $aReferences = Coordinate::extractAllCellReferencesInRange($pRange);
             $pRange = $pSheetName . '!' . $pRange;
             if (!isset($aReferences[1])) {
                 $currentCol = '';
                 $currentRow = 0;
                 //    Single cell in range
                 sscanf($aReferences[0], '%[A-Z]%d', $currentCol, $currentRow);
                 if ($pSheet->cellExists($aReferences[0])) {
                     $returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
                 } else {
                     $returnValue[$currentRow][$currentCol] = null;
                 }
             } else {
                 // Extract cell data for all cells in the range
                 foreach ($aReferences as $reference) {
                     $currentCol = '';
                     $currentRow = 0;
                     // Extract range
                     sscanf($reference, '%[A-Z]%d', $currentCol, $currentRow);
                     if ($pSheet->cellExists($reference)) {
                         $returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
                     } else {
                         $returnValue[$currentRow][$currentCol] = null;
                     }
                 }
             }
         }
 
         return $returnValue;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extractNamedRange()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::extractNamedRange	(	&	$pRange = `'A1'`,
		?Worksheet	$pSheet = `null`,
			$resetLog = `true`
	)

Extract range values.

Parameters

string	$pRange	String based range representation
Worksheet	$pSheet	Worksheet
bool	$resetLog	Flag indicating whether calculation log should be reset or not

Returns: mixed Array of values in range if range contains more than one element. Otherwise, a single value is returned.

Definition at line 5294 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Cell\Coordinate\coordinateFromString(), PhpOffice\PhpSpreadsheet\Cell\Coordinate\extractAllCellReferencesInRange(), PhpOffice\PhpSpreadsheet\Worksheet\Worksheet\extractSheetTitle(), PhpOffice\PhpSpreadsheet\Calculation\Functions\REF(), PhpOffice\PhpSpreadsheet\DefinedName\resolveName(), and PhpOffice\PhpSpreadsheet\Cell\Coordinate\splitRange().

     {
         // Return value
         $returnValue = [];
 
         if ($pSheet !== null) {
             $pSheetName = $pSheet->getTitle();
             if (strpos($pRange, '!') !== false) {
                 [$pSheetName, $pRange] = Worksheet::extractSheetTitle($pRange, true);
                 $pSheet = $this->spreadsheet->getSheetByName($pSheetName);
             }
 
             // Named range?
             $namedRange = DefinedName::resolveName($pRange, $pSheet);
             if ($namedRange === null) {
                 return Functions::REF();
             }
 
             $pSheet = $namedRange->getWorksheet();
             $pRange = $namedRange->getValue();
             $splitRange = Coordinate::splitRange($pRange);
             //    Convert row and column references
             if (ctype_alpha($splitRange[0][0])) {
                 $pRange = $splitRange[0][0] . '1:' . $splitRange[0][1] . $namedRange->getWorksheet()->getHighestRow();
             } elseif (ctype_digit($splitRange[0][0])) {
                 $pRange = 'A' . $splitRange[0][0] . ':' . $namedRange->getWorksheet()->getHighestColumn() . $splitRange[0][1];
             }
 
             // Extract range
             $aReferences = Coordinate::extractAllCellReferencesInRange($pRange);
             if (!isset($aReferences[1])) {
                 //    Single cell (or single column or row) in range
                 [$currentCol, $currentRow] = Coordinate::coordinateFromString($aReferences[0]);
                 if ($pSheet->cellExists($aReferences[0])) {
                     $returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
                 } else {
                     $returnValue[$currentRow][$currentCol] = null;
                 }
             } else {
                 // Extract cell data for all cells in the range
                 foreach ($aReferences as $reference) {
                     // Extract range
                     [$currentCol, $currentRow] = Coordinate::coordinateFromString($reference);
                     if ($pSheet->cellExists($reference)) {
                         $returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
                     } else {
                         $returnValue[$currentRow][$currentCol] = null;
                     }
                 }
             }
         }
 
         return $returnValue;
     }

Here is the call graph for this function:

◆ flushInstance()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::flushInstance ( )

Flush the calculation cache for any existing instance of this class but only if a Calculation instance exists.

Definition at line 2805 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\clearBranchStore(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\clearCalculationCache().

                                    : void
     {
         $this->clearCalculationCache();
         $this->clearBranchStore();
     }

Here is the call graph for this function:

◆ getArrayReturnType()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getArrayReturnType ( )

static

Return the Array Return Type (Array or Value of first element in the array).

Returns: string $returnType Array return type

Definition at line 2876 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Writer\Html\generateHtmlAll(), and PhpOffice\PhpSpreadsheet\Writer\Csv\save().

     {
         return self::$returnArrayAsType;
     }

Here is the caller graph for this function:

◆ getCalculationCacheEnabled()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getCalculationCacheEnabled ( )

Is calculation caching enabled?

Returns: bool

Definition at line 2886 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$calculationCacheEnabled.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateFormula().

     {
         return $this->calculationCacheEnabled;
     }

Here is the caller graph for this function:

◆ getDebugLog()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getDebugLog ( )

Get the Logger for this calculation engine instance.

Returns: Logger

Definition at line 2816 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$debugLog.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\evaluateDefinedName().

     {
         return $this->debugLog;
     }

Here is the caller graph for this function:

◆ getFALSE()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getFALSE ( )

static

Return the locale-specific translation of FALSE.

Returns: string locale-specific translation of FALSE

Definition at line 2844 of file Calculation.php.

                                      : string
     {
         return self::$localeBoolean['FALSE'];
     }

Here is the caller graph for this function:

◆ getFunctions()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getFunctions ( )

Get a list of all implemented functions as an array of function objects.

Definition at line 5367 of file Calculation.php.

                                   : array
     {
         return self::$phpSpreadsheetFunctions;
     }

◆ getImplementedFunctionNames()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getImplementedFunctionNames ( )

Get a list of implemented Excel function names.

Returns: array

Definition at line 5377 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\isImplemented().

     {
         $returnValue = [];
         foreach (self::$phpSpreadsheetFunctions as $functionName => $function) {
             if ($this->isImplemented($functionName)) {
                 $returnValue[] = $functionName;
             }
         }
 
         return $returnValue;
     }

Here is the call graph for this function:

◆ getInstance()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getInstance ( ?Spreadsheet $spreadsheet = null )

static

Get an instance of this class.

Parameters

?Spreadsheet $spreadsheet Injected spreadsheet for working with a PhpSpreadsheet Spreadsheet object, or NULL to create a standalone calculation engine

Definition at line 2785 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$instance, and PhpOffice\PhpSpreadsheet\Calculation\Calculation\$spreadsheet.

                                                                         : self
     {
         if ($spreadsheet !== null) {
             $instance = $spreadsheet->getCalculationEngine();
             if (isset($instance)) {
                 return $instance;
             }
         }
 
         if (!isset(self::$instance) || (self::$instance === null)) {
             self::$instance = new self();
         }
 
         return self::$instance;
     }

Here is the caller graph for this function:

◆ getLocale()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getLocale ( )

Get the currently defined locale code.

Returns: string

Definition at line 2982 of file Calculation.php.

     {
         return self::$localeLanguage;
     }

◆ getLocaleFile()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getLocaleFile	(	string	$localeDir,
		string	$locale,
		string	$language,
		string	$file
	)

private

Definition at line 2987 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\setLocale().

                                                                                                      : string
     {
         $localeFileName = $localeDir . str_replace('_', DIRECTORY_SEPARATOR, $locale) .
             DIRECTORY_SEPARATOR . $file;
         if (!file_exists($localeFileName)) {
             //    If there isn't a locale specific file, look for a language specific file
             $localeFileName = $localeDir . $language . DIRECTORY_SEPARATOR . $file;
             if (!file_exists($localeFileName)) {
                 throw new Exception('Locale file not found');
             }
         }
 
         return $localeFileName;
     }

Here is the caller graph for this function:

◆ getMatrixDimensions()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getMatrixDimensions ( array & $matrix )

static

Read the dimensions of a matrix, and re-index it with straight numeric keys starting from row 0, column 0.

Parameters

array $matrix matrix operand

Returns: int[] An array comprising the number of rows, and number of columns

Definition at line 3603 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\LookupRef\RowColumnInformation\COLUMNS(), and PhpOffice\PhpSpreadsheet\Calculation\LookupRef\RowColumnInformation\ROWS().

     {
         $matrixRows = count($matrix);
         $matrixColumns = 0;
         foreach ($matrix as $rowKey => $rowValue) {
             if (!is_array($rowValue)) {
                 $matrix[$rowKey] = [$rowValue];
                 $matrixColumns = max(1, $matrixColumns);
             } else {
                 $matrix[$rowKey] = array_values($rowValue);
                 $matrixColumns = max(count($rowValue), $matrixColumns);
             }
         }
         $matrix = array_values($matrix);
 
         return [$matrixRows, $matrixColumns];
     }

Here is the caller graph for this function:

◆ getTokensAsString()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getTokensAsString ( $tokens )

private

Definition at line 5425 of file Calculation.php.

References PHPMailer\PHPMailer\$token.

     {
         $tokensStr = array_map(function ($token) {
             $value = $token['value'] ?? 'no value';
             while (is_array($value)) {
                 $value = array_pop($value);
             }
 
             return $value;
         }, $tokens);
 
         return '[ ' . implode(' | ', $tokensStr) . ' ]';
     }

◆ getTRUE()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getTRUE ( )

static

Return the locale-specific translation of TRUE.

Returns: string locale-specific translation of TRUE

Definition at line 2834 of file Calculation.php.

                                     : string
     {
         return self::$localeBoolean['TRUE'];
     }

Here is the caller graph for this function:

◆ getUnusedBranchStoreKey()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getUnusedBranchStoreKey ( )

private

Definition at line 5417 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$branchStoreKeyCounter.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula().

     {
         $storeKeyValue = 'storeKey-' . $this->branchStoreKeyCounter;
         ++$this->branchStoreKeyCounter;
 
         return $storeKeyValue;
     }

Here is the caller graph for this function:

◆ getValueFromCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getValueFromCache	(	string	$cellReference,
		&	$cellValue
	)

Parameters

mixed $cellValue

Definition at line 3445 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue().

                                                                          : bool
     {
         $this->debugLog->writeDebugLog("Testing cache value for cell {$cellReference}");
         // Is calculation cacheing enabled?
         // If so, is the required value present in calculation cache?
         if (($this->calculationCacheEnabled) && (isset($this->calculationCache[$cellReference]))) {
             $this->debugLog->writeDebugLog("Retrieving value for cell {$cellReference} from cache");
             // Return the cached result
 
             $cellValue = $this->calculationCache[$cellReference];
 
             return true;
         }
 
         return false;
     }

Here is the caller graph for this function:

◆ internalParseFormula()

static static static PhpOffice\PhpSpreadsheet\Calculation\Calculation::internalParseFormula	(		$formula,
		?Cell	$pCell = `null`
	)

private

Parameters

string $formula

Returns: array<int, mixed>|false

Definition at line 3883 of file Calculation.php.

References $d, $index, Sabre\VObject\$output, $row, PhpOffice\PhpSpreadsheet\Calculation\Calculation\convertMatrixReferences(), PhpOffice\PhpSpreadsheet\Worksheet\Worksheet\extractSheetTitle(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\getUnusedBranchStoreKey(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\raiseFormulaError().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\parseFormula().

     {
         if (($formula = $this->convertMatrixReferences(trim($formula))) === false) {
             return false;
         }
 
         //    If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent worksheet),
         //        so we store the parent worksheet so that we can re-attach it when necessary
         $pCellParent = ($pCell !== null) ? $pCell->getWorksheet() : null;
 
         $regexpMatchString = '/^(' . self::CALCULATION_REGEXP_FUNCTION .
             '|' . self::CALCULATION_REGEXP_CELLREF .
             '|' . self::CALCULATION_REGEXP_COLUMN_RANGE .
             '|' . self::CALCULATION_REGEXP_ROW_RANGE .
             '|' . self::CALCULATION_REGEXP_NUMBER .
             '|' . self::CALCULATION_REGEXP_STRING .
             '|' . self::CALCULATION_REGEXP_OPENBRACE .
             '|' . self::CALCULATION_REGEXP_DEFINEDNAME .
             '|' . self::CALCULATION_REGEXP_ERROR .
             ')/sui';
 
         //    Start with initialisation
         $index = 0;
         $stack = new Stack();
         $output = [];
         $expectingOperator = false; //    We use this test in syntax-checking the expression to determine when a
         //        - is a negation or + is a positive operator rather than an operation
         $expectingOperand = false; //    We use this test in syntax-checking the expression to determine whether an operand
         //        should be null in a function call
 
         // IF branch pruning
         // currently pending storeKey (last item of the storeKeysStack
         $pendingStoreKey = null;
         // stores a list of storeKeys (string[])
         $pendingStoreKeysStack = [];
         $expectingConditionMap = []; // ['storeKey' => true, ...]
         $expectingThenMap = []; // ['storeKey' => true, ...]
         $expectingElseMap = []; // ['storeKey' => true, ...]
         $parenthesisDepthMap = []; // ['storeKey' => 4, ...]
 
         //    The guts of the lexical parser
         //    Loop through the formula extracting each operator and operand in turn
         while (true) {
             // Branch pruning: we adapt the output item to the context (it will
             // be used to limit its computation)
             $currentCondition = null;
             $currentOnlyIf = null;
             $currentOnlyIfNot = null;
             $previousStoreKey = null;
             $pendingStoreKey = end($pendingStoreKeysStack);
 
             if ($this->branchPruningEnabled) {
                 // this is a condition ?
                 if (isset($expectingConditionMap[$pendingStoreKey]) && $expectingConditionMap[$pendingStoreKey]) {
                     $currentCondition = $pendingStoreKey;
                     $stackDepth = count($pendingStoreKeysStack);
                     if ($stackDepth > 1) { // nested if
                         $previousStoreKey = $pendingStoreKeysStack[$stackDepth - 2];
                     }
                 }
                 if (isset($expectingThenMap[$pendingStoreKey]) && $expectingThenMap[$pendingStoreKey]) {
                     $currentOnlyIf = $pendingStoreKey;
                 } elseif (isset($previousStoreKey)) {
                     if (isset($expectingThenMap[$previousStoreKey]) && $expectingThenMap[$previousStoreKey]) {
                         $currentOnlyIf = $previousStoreKey;
                     }
                 }
                 if (isset($expectingElseMap[$pendingStoreKey]) && $expectingElseMap[$pendingStoreKey]) {
                     $currentOnlyIfNot = $pendingStoreKey;
                 } elseif (isset($previousStoreKey)) {
                     if (isset($expectingElseMap[$previousStoreKey]) && $expectingElseMap[$previousStoreKey]) {
                         $currentOnlyIfNot = $previousStoreKey;
                     }
                 }
             }
 
             $opCharacter = $formula[$index]; //    Get the first character of the value at the current index position
 
             if ((isset(self::$comparisonOperators[$opCharacter])) && (strlen($formula) > $index) && (isset(self::$comparisonOperators[$formula[$index + 1]]))) {
                 $opCharacter .= $formula[++$index];
             }
             //    Find out if we're currently at the beginning of a number, variable, cell reference, function, parenthesis or operand
             $isOperandOrFunction = (bool) preg_match($regexpMatchString, substr($formula, $index), $match);
 
             if ($opCharacter == '-' && !$expectingOperator) {                //    Is it a negation instead of a minus?
                 //    Put a negation on the stack
                 $stack->push('Unary Operator', '~', null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                 ++$index; //        and drop the negation symbol
             } elseif ($opCharacter == '%' && $expectingOperator) {
                 //    Put a percentage on the stack
                 $stack->push('Unary Operator', '%', null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                 ++$index;
             } elseif ($opCharacter == '+' && !$expectingOperator) {            //    Positive (unary plus rather than binary operator plus) can be discarded?
                 ++$index; //    Drop the redundant plus symbol
             } elseif ((($opCharacter == '~') || ($opCharacter == '|')) && (!$isOperandOrFunction)) {    //    We have to explicitly deny a tilde or pipe, because they are legal
                 return $this->raiseFormulaError("Formula Error: Illegal character '~'"); //        on the stack but not in the input expression
             } elseif ((isset(self::$operators[$opCharacter]) || $isOperandOrFunction) && $expectingOperator) {    //    Are we putting an operator on the stack?
                 while (
                     $stack->count() > 0 &&
                     ($o2 = $stack->last()) &&
                     isset(self::$operators[$o2['value']]) &&
                     @(self::$operatorAssociativity[$opCharacter] ? self::$operatorPrecedence[$opCharacter] < self::$operatorPrecedence[$o2['value']] : self::$operatorPrecedence[$opCharacter] <= self::$operatorPrecedence[$o2['value']])
                 ) {
                     $output[] = $stack->pop(); //    Swap operands and higher precedence operators from the stack to the output
                 }
 
                 //    Finally put our current operator onto the stack
                 $stack->push('Binary Operator', $opCharacter, null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
 
                 ++$index;
                 $expectingOperator = false;
             } elseif ($opCharacter == ')' && $expectingOperator) {            //    Are we expecting to close a parenthesis?
                 $expectingOperand = false;
                 while (($o2 = $stack->pop()) && $o2['value'] != '(') {        //    Pop off the stack back to the last (
                     if ($o2 === null) {
                         return $this->raiseFormulaError('Formula Error: Unexpected closing brace ")"');
                     }
                     $output[] = $o2;
                 }
                 $d = $stack->last(2);
 
                 // Branch pruning we decrease the depth whether is it a function
                 // call or a parenthesis
                 if (!empty($pendingStoreKey)) {
                     --$parenthesisDepthMap[$pendingStoreKey];
                 }
 
                 if (is_array($d) && preg_match('/^' . self::CALCULATION_REGEXP_FUNCTION . '$/miu', $d['value'], $matches)) {    //    Did this parenthesis just close a function?
                     if (!empty($pendingStoreKey) && $parenthesisDepthMap[$pendingStoreKey] == -1) {
                         // we are closing an IF(
                         if ($d['value'] != 'IF(') {
                             return $this->raiseFormulaError('Parser bug we should be in an "IF("');
                         }
                         if ($expectingConditionMap[$pendingStoreKey]) {
                             return $this->raiseFormulaError('We should not be expecting a condition');
                         }
                         $expectingThenMap[$pendingStoreKey] = false;
                         $expectingElseMap[$pendingStoreKey] = false;
                         --$parenthesisDepthMap[$pendingStoreKey];
                         array_pop($pendingStoreKeysStack);
                         unset($pendingStoreKey);
                     }
 
                     $functionName = $matches[1]; //    Get the function name
                     $d = $stack->pop();
                     $argumentCount = $d['value']; //    See how many arguments there were (argument count is the next value stored on the stack)
                     $output[] = $d; //    Dump the argument count on the output
                     $output[] = $stack->pop(); //    Pop the function and push onto the output
                     if (isset(self::$controlFunctions[$functionName])) {
                         $expectedArgumentCount = self::$controlFunctions[$functionName]['argumentCount'];
                         $functionCall = self::$controlFunctions[$functionName]['functionCall'];
                     } elseif (isset(self::$phpSpreadsheetFunctions[$functionName])) {
                         $expectedArgumentCount = self::$phpSpreadsheetFunctions[$functionName]['argumentCount'];
                         $functionCall = self::$phpSpreadsheetFunctions[$functionName]['functionCall'];
                     } else {    // did we somehow push a non-function on the stack? this should never happen
                         return $this->raiseFormulaError('Formula Error: Internal error, non-function on stack');
                     }
                     //    Check the argument count
                     $argumentCountError = false;
                     $expectedArgumentCountString = null;
                     if (is_numeric($expectedArgumentCount)) {
                         if ($expectedArgumentCount < 0) {
                             if ($argumentCount > abs($expectedArgumentCount)) {
                                 $argumentCountError = true;
                                 $expectedArgumentCountString = 'no more than ' . abs($expectedArgumentCount);
                             }
                         } else {
                             if ($argumentCount != $expectedArgumentCount) {
                                 $argumentCountError = true;
                                 $expectedArgumentCountString = $expectedArgumentCount;
                             }
                         }
                     } elseif ($expectedArgumentCount != '*') {
                         $isOperandOrFunction = preg_match('/(\d*)([-+,])(\d*)/', $expectedArgumentCount, $argMatch);
                         switch ($argMatch[2]) {
                             case '+':
                                 if ($argumentCount < $argMatch[1]) {
                                     $argumentCountError = true;
                                     $expectedArgumentCountString = $argMatch[1] . ' or more ';
                                 }
 
                                 break;
                             case '-':
                                 if (($argumentCount < $argMatch[1]) || ($argumentCount > $argMatch[3])) {
                                     $argumentCountError = true;
                                     $expectedArgumentCountString = 'between ' . $argMatch[1] . ' and ' . $argMatch[3];
                                 }
 
                                 break;
                             case ',':
                                 if (($argumentCount != $argMatch[1]) && ($argumentCount != $argMatch[3])) {
                                     $argumentCountError = true;
                                     $expectedArgumentCountString = 'either ' . $argMatch[1] . ' or ' . $argMatch[3];
                                 }
 
                                 break;
                         }
                     }
                     if ($argumentCountError) {
                         return $this->raiseFormulaError("Formula Error: Wrong number of arguments for $functionName() function: $argumentCount given, " . $expectedArgumentCountString . ' expected');
                     }
                 }
                 ++$index;
             } elseif ($opCharacter == ',') {            //    Is this the separator for function arguments?
                 if (
                     !empty($pendingStoreKey) &&
                     $parenthesisDepthMap[$pendingStoreKey] == 0
                 ) {
                     // We must go to the IF next argument
                     if ($expectingConditionMap[$pendingStoreKey]) {
                         $expectingConditionMap[$pendingStoreKey] = false;
                         $expectingThenMap[$pendingStoreKey] = true;
                     } elseif ($expectingThenMap[$pendingStoreKey]) {
                         $expectingThenMap[$pendingStoreKey] = false;
                         $expectingElseMap[$pendingStoreKey] = true;
                     } elseif ($expectingElseMap[$pendingStoreKey]) {
                         return $this->raiseFormulaError('Reaching fourth argument of an IF');
                     }
                 }
                 while (($o2 = $stack->pop()) && $o2['value'] != '(') {        //    Pop off the stack back to the last (
                     if ($o2 === null) {
                         return $this->raiseFormulaError('Formula Error: Unexpected ,');
                     }
                     $output[] = $o2; // pop the argument expression stuff and push onto the output
                 }
                 //    If we've a comma when we're expecting an operand, then what we actually have is a null operand;
                 //        so push a null onto the stack
                 if (($expectingOperand) || (!$expectingOperator)) {
                     $output[] = ['type' => 'NULL Value', 'value' => self::$excelConstants['NULL'], 'reference' => null];
                 }
                 // make sure there was a function
                 $d = $stack->last(2);
                 if (!preg_match('/^' . self::CALCULATION_REGEXP_FUNCTION . '$/miu', $d['value'], $matches)) {
                     return $this->raiseFormulaError('Formula Error: Unexpected ,');
                 }
                 $d = $stack->pop();
                 $itemStoreKey = $d['storeKey'] ?? null;
                 $itemOnlyIf = $d['onlyIf'] ?? null;
                 $itemOnlyIfNot = $d['onlyIfNot'] ?? null;
                 $stack->push($d['type'], ++$d['value'], $d['reference'], $itemStoreKey, $itemOnlyIf, $itemOnlyIfNot); // increment the argument count
                 $stack->push('Brace', '(', null, $itemStoreKey, $itemOnlyIf, $itemOnlyIfNot); // put the ( back on, we'll need to pop back to it again
                 $expectingOperator = false;
                 $expectingOperand = true;
                 ++$index;
             } elseif ($opCharacter == '(' && !$expectingOperator) {
                 if (!empty($pendingStoreKey)) { // Branch pruning: we go deeper
                     ++$parenthesisDepthMap[$pendingStoreKey];
                 }
                 $stack->push('Brace', '(', null, $currentCondition, $currentOnlyIf, $currentOnlyIf);
                 ++$index;
             } elseif ($isOperandOrFunction && !$expectingOperator) {    // do we now have a function/variable/number?
                 $expectingOperator = true;
                 $expectingOperand = false;
                 $val = $match[1];
                 $length = strlen($val);
 
                 if (preg_match('/^' . self::CALCULATION_REGEXP_FUNCTION . '$/miu', $val, $matches)) {
                     $val = preg_replace('/\s/u', '', $val);
                     if (isset(self::$phpSpreadsheetFunctions[strtoupper($matches[1])]) || isset(self::$controlFunctions[strtoupper($matches[1])])) {    // it's a function
                         $valToUpper = strtoupper($val);
                     } else {
                         $valToUpper = 'NAME.ERROR(';
                     }
                     // here $matches[1] will contain values like "IF"
                     // and $val "IF("
                     if ($this->branchPruningEnabled && ($valToUpper == 'IF(')) { // we handle a new if
                         $pendingStoreKey = $this->getUnusedBranchStoreKey();
                         $pendingStoreKeysStack[] = $pendingStoreKey;
                         $expectingConditionMap[$pendingStoreKey] = true;
                         $parenthesisDepthMap[$pendingStoreKey] = 0;
                     } else { // this is not an if but we go deeper
                         if (!empty($pendingStoreKey) && array_key_exists($pendingStoreKey, $parenthesisDepthMap)) {
                             ++$parenthesisDepthMap[$pendingStoreKey];
                         }
                     }
 
                     $stack->push('Function', $valToUpper, null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                     // tests if the function is closed right after opening
                     $ax = preg_match('/^\s*\)/u', substr($formula, $index + $length));
                     if ($ax) {
                         $stack->push('Operand Count for Function ' . $valToUpper . ')', 0, null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                         $expectingOperator = true;
                     } else {
                         $stack->push('Operand Count for Function ' . $valToUpper . ')', 1, null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                         $expectingOperator = false;
                     }
                     $stack->push('Brace', '(');
                 } elseif (preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '$/i', $val, $matches)) {
                     //    Watch for this case-change when modifying to allow cell references in different worksheets...
                     //    Should only be applied to the actual cell column, not the worksheet name
                     //    If the last entry on the stack was a : operator, then we have a cell range reference
                     $testPrevOp = $stack->last(1);
                     if ($testPrevOp !== null && $testPrevOp['value'] === ':') {
                         //    If we have a worksheet reference, then we're playing with a 3D reference
                         if ($matches[2] == '') {
                             //    Otherwise, we 'inherit' the worksheet reference from the start cell reference
                             //    The start of the cell range reference should be the last entry in $output
                             $rangeStartCellRef = $output[count($output) - 1]['value'];
                             preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '$/i', $rangeStartCellRef, $rangeStartMatches);
                             if ($rangeStartMatches[2] > '') {
                                 $val = $rangeStartMatches[2] . '!' . $val;
                             }
                         } else {
                             $rangeStartCellRef = $output[count($output) - 1]['value'];
                             preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '$/i', $rangeStartCellRef, $rangeStartMatches);
                             if ($rangeStartMatches[2] !== $matches[2]) {
                                 return $this->raiseFormulaError('3D Range references are not yet supported');
                             }
                         }
                     } elseif (strpos($val, '!') === false && $pCellParent !== null) {
                         $worksheet = $pCellParent->getTitle();
                         $val = "'{$worksheet}'!{$val}";
                     }
 
                     $outputItem = $stack->getStackItem('Cell Reference', $val, $val, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
 
                     $output[] = $outputItem;
                 } else {    // it's a variable, constant, string, number or boolean
                     $localeConstant = false;
                     $stackItemType = 'Value';
                     $stackItemReference = null;
 
                     //    If the last entry on the stack was a : operator, then we may have a row or column range reference
                     $testPrevOp = $stack->last(1);
                     if ($testPrevOp !== null && $testPrevOp['value'] === ':') {
                         $stackItemType = 'Cell Reference';
                         $startRowColRef = $output[count($output) - 1]['value'];
                         [$rangeWS1, $startRowColRef] = Worksheet::extractSheetTitle($startRowColRef, true);
                         $rangeSheetRef = $rangeWS1;
                         if ($rangeWS1 !== '') {
                             $rangeWS1 .= '!';
                         }
                         $rangeSheetRef = trim($rangeSheetRef, "'");
                         [$rangeWS2, $val] = Worksheet::extractSheetTitle($val, true);
                         if ($rangeWS2 !== '') {
                             $rangeWS2 .= '!';
                         } else {
                             $rangeWS2 = $rangeWS1;
                         }
 
                         $refSheet = $pCellParent;
                         if ($pCellParent !== null && $rangeSheetRef !== '' && $rangeSheetRef !== $pCellParent->getTitle()) {
                             $refSheet = $pCellParent->getParent()->getSheetByName($rangeSheetRef);
                         }
 
                         if (ctype_digit($val) && $val <= 1048576) {
                             //    Row range
                             $stackItemType = 'Row Reference';
                             $endRowColRef = ($refSheet !== null) ? $refSheet->getHighestDataColumn($val) : 'XFD'; //    Max 16,384 columns for Excel2007
                             $val = "{$rangeWS2}{$endRowColRef}{$val}";
                         } elseif (ctype_alpha($val) && strlen($val) <= 3) {
                             //    Column range
                             $stackItemType = 'Column Reference';
                             $endRowColRef = ($refSheet !== null) ? $refSheet->getHighestDataRow($val) : 1048576; //    Max 1,048,576 rows for Excel2007
                             $val = "{$rangeWS2}{$val}{$endRowColRef}";
                         }
                         $stackItemReference = $val;
                     } elseif ($opCharacter == self::FORMULA_STRING_QUOTE) {
                         //    UnEscape any quotes within the string
                         $val = self::wrapResult(str_replace('""', self::FORMULA_STRING_QUOTE, self::unwrapResult($val)));
                     } elseif (isset(self::$excelConstants[trim(strtoupper($val))])) {
                         $stackItemType = 'Constant';
                         $excelConstant = trim(strtoupper($val));
                         $val = self::$excelConstants[$excelConstant];
                     } elseif (($localeConstant = array_search(trim(strtoupper($val)), self::$localeBoolean)) !== false) {
                         $stackItemType = 'Constant';
                         $val = self::$excelConstants[$localeConstant];
                     } elseif (
                         preg_match('/^' . self::CALCULATION_REGEXP_ROW_RANGE . '/miu', substr($formula, $index), $rowRangeReference)
                     ) {
                         $val = $rowRangeReference[1];
                         $length = strlen($rowRangeReference[1]);
                         $stackItemType = 'Row Reference';
                         $column = 'A';
                         if (($testPrevOp !== null && $testPrevOp['value'] === ':') && $pCellParent !== null) {
                             $column = $pCellParent->getHighestDataColumn($val);
                         }
                         $val = "{$rowRangeReference[2]}{$column}{$rowRangeReference[7]}";
                         $stackItemReference = $val;
                     } elseif (
                         preg_match('/^' . self::CALCULATION_REGEXP_COLUMN_RANGE . '/miu', substr($formula, $index), $columnRangeReference)
                     ) {
                         $val = $columnRangeReference[1];
                         $length = strlen($val);
                         $stackItemType = 'Column Reference';
                         $row = '1';
                         if (($testPrevOp !== null && $testPrevOp['value'] === ':') && $pCellParent !== null) {
                             $row = $pCellParent->getHighestDataRow($val);
                         }
                         $val = "{$val}{$row}";
                         $stackItemReference = $val;
                     } elseif (preg_match('/^' . self::CALCULATION_REGEXP_DEFINEDNAME . '.*/miu', $val, $match)) {
                         $stackItemType = 'Defined Name';
                         $stackItemReference = $val;
                     } elseif (is_numeric($val)) {
                         if ((strpos($val, '.') !== false) || (stripos($val, 'e') !== false) || ($val > PHP_INT_MAX) || ($val < -PHP_INT_MAX)) {
                             $val = (float) $val;
                         } else {
                             $val = (int) $val;
                         }
                     }
 
                     $details = $stack->getStackItem($stackItemType, $val, $stackItemReference, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                     if ($localeConstant) {
                         $details['localeValue'] = $localeConstant;
                     }
                     $output[] = $details;
                 }
                 $index += $length;
             } elseif ($opCharacter == '$') {    // absolute row or column range
                 ++$index;
             } elseif ($opCharacter == ')') {    // miscellaneous error checking
                 if ($expectingOperand) {
                     $output[] = ['type' => 'NULL Value', 'value' => self::$excelConstants['NULL'], 'reference' => null];
                     $expectingOperand = false;
                     $expectingOperator = true;
                 } else {
                     return $this->raiseFormulaError("Formula Error: Unexpected ')'");
                 }
             } elseif (isset(self::$operators[$opCharacter]) && !$expectingOperator) {
                 return $this->raiseFormulaError("Formula Error: Unexpected operator '$opCharacter'");
             } else {    // I don't even want to know what you did to get here
                 return $this->raiseFormulaError('Formula Error: An unexpected error occurred');
             }
             //    Test for end of formula string
             if ($index == strlen($formula)) {
                 //    Did we end with an operator?.
                 //    Only valid for the % unary operator
                 if ((isset(self::$operators[$opCharacter])) && ($opCharacter != '%')) {
                     return $this->raiseFormulaError("Formula Error: Operator '$opCharacter' has no operands");
                 }
 
                 break;
             }
             //    Ignore white space
             while (($formula[$index] == "\n") || ($formula[$index] == "\r")) {
                 ++$index;
             }
 
             if ($formula[$index] == ' ') {
                 while ($formula[$index] == ' ') {
                     ++$index;
                 }
 
                 //    If we're expecting an operator, but only have a space between the previous and next operands (and both are
                 //        Cell References) then we have an INTERSECTION operator
                 if (
                     ($expectingOperator) &&
                     ((preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '.*/Ui', substr($formula, $index), $match)) &&
                         ($output[count($output) - 1]['type'] == 'Cell Reference') ||
                         (preg_match('/^' . self::CALCULATION_REGEXP_DEFINEDNAME . '.*/miu', substr($formula, $index), $match)) &&
                         ($output[count($output) - 1]['type'] == 'Defined Name' || $output[count($output) - 1]['type'] == 'Value')
                     )
                 ) {
                     while (
                         $stack->count() > 0 &&
                         ($o2 = $stack->last()) &&
                         isset(self::$operators[$o2['value']]) &&
                         @(self::$operatorAssociativity[$opCharacter] ? self::$operatorPrecedence[$opCharacter] < self::$operatorPrecedence[$o2['value']] : self::$operatorPrecedence[$opCharacter] <= self::$operatorPrecedence[$o2['value']])
                     ) {
                         $output[] = $stack->pop(); //    Swap operands and higher precedence operators from the stack to the output
                     }
                     $stack->push('Binary Operator', '|'); //    Put an Intersect Operator on the stack
                     $expectingOperator = false;
                 }
             }
         }
 
         while (($op = $stack->pop()) !== null) {    // pop everything off the stack and push onto output
             if ((is_array($op) && $op['value'] == '(') || ($op === '(')) {
                 return $this->raiseFormulaError("Formula Error: Expecting ')'"); // if there are any opening braces on the stack, then braces were unbalanced
             }
             $output[] = $op;
         }
 
         return $output;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isImplemented()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::isImplemented ( $pFunction )

Is a specific function implemented?

Parameters

string $pFunction Function Name

Returns: bool

Definition at line 5356 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getImplementedFunctionNames().

     {
         $pFunction = strtoupper($pFunction);
         $notImplemented = !isset(self::$phpSpreadsheetFunctions[$pFunction]) || (is_array(self::$phpSpreadsheetFunctions[$pFunction]['functionCall']) && self::$phpSpreadsheetFunctions[$pFunction]['functionCall'][1] === 'DUMMY');
 
         return !$notImplemented;
     }

Here is the caller graph for this function:

◆ loadLocales()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::loadLocales ( )

staticprivate

Definition at line 2768 of file Calculation.php.

References $filename.

                                          : void
     {
         $localeFileDirectory = __DIR__ . '/locale/';
         foreach (glob($localeFileDirectory . '*', GLOB_ONLYDIR) as $filename) {
             $filename = substr($filename, strlen($localeFileDirectory));
             if ($filename != 'en') {
                 self::$validLocaleLanguages[] = $filename;
             }
         }
     }

◆ localeFunc()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::localeFunc ( $function )

static

Definition at line 3220 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Token\Stack\push().

     {
         if (self::$localeLanguage !== 'en_us') {
             $functionName = trim($function, '(');
             if (isset(self::$localeFunctions[$functionName])) {
                 $brace = ($functionName != $function);
                 $function = self::$localeFunctions[$functionName];
                 if ($brace) {
                     $function .= '(';
                 }
             }
         }
 
         return $function;
     }

Here is the caller graph for this function:

◆ parseFormula()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::parseFormula ( $formula )

Validate and parse a formula string.

Parameters

string $formula Formula to parse

Returns: array|bool

Definition at line 3384 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula().

     {
         //    Basic validation that this is indeed a formula
         //    We return an empty array if not
         $formula = trim($formula);
         if ((!isset($formula[0])) || ($formula[0] != '=')) {
             return [];
         }
         $formula = ltrim(substr($formula, 1));
         if (!isset($formula[0])) {
             return [];
         }
 
         //    Parse the formula and return the token stack
         return $this->internalParseFormula($formula);
     }

Here is the call graph for this function:

◆ processTokenStack()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::processTokenStack	(		$tokens,
			$cellID = `null`,
		?Cell	$pCell = `null`
	)

private

Parameters

mixed	$tokens
null \| string	$cellID

Returns: array<int, mixed>|false

Definition at line 4385 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue().

     {
         if ($tokens == false) {
             return false;
         }
 
         //    If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent cell collection),
         //        so we store the parent cell collection so that we can re-attach it when necessary
         $pCellWorksheet = ($pCell !== null) ? $pCell->getWorksheet() : null;
         $pCellParent = ($pCell !== null) ? $pCell->getParent() : null;
         $stack = new Stack();
 
         // Stores branches that have been pruned
         $fakedForBranchPruning = [];
         // help us to know when pruning ['branchTestId' => true/false]
         $branchStore = [];
         //    Loop through each token in turn
         foreach ($tokens as $tokenData) {
             $token = $tokenData['value'];
 
             // Branch pruning: skip useless resolutions
             $storeKey = $tokenData['storeKey'] ?? null;
             if ($this->branchPruningEnabled && isset($tokenData['onlyIf'])) {
                 $onlyIfStoreKey = $tokenData['onlyIf'];
                 $storeValue = $branchStore[$onlyIfStoreKey] ?? null;
                 $storeValueAsBool = ($storeValue === null) ?
                     true : (bool) Functions::flattenSingleValue($storeValue);
                 if (is_array($storeValue)) {
                     $wrappedItem = end($storeValue);
                     $storeValue = end($wrappedItem);
                 }
 
                 if (
                     isset($storeValue)
                     && (
                         !$storeValueAsBool
                         || Functions::isError($storeValue)
                         || ($storeValue === 'Pruned branch')
                     )
                 ) {
                     // If branching value is not true, we don't need to compute
                     if (!isset($fakedForBranchPruning['onlyIf-' . $onlyIfStoreKey])) {
                         $stack->push('Value', 'Pruned branch (only if ' . $onlyIfStoreKey . ') ' . $token);
                         $fakedForBranchPruning['onlyIf-' . $onlyIfStoreKey] = true;
                     }
 
                     if (isset($storeKey)) {
                         // We are processing an if condition
                         // We cascade the pruning to the depending branches
                         $branchStore[$storeKey] = 'Pruned branch';
                         $fakedForBranchPruning['onlyIfNot-' . $storeKey] = true;
                         $fakedForBranchPruning['onlyIf-' . $storeKey] = true;
                     }
 
                     continue;
                 }
             }
 
             if ($this->branchPruningEnabled && isset($tokenData['onlyIfNot'])) {
                 $onlyIfNotStoreKey = $tokenData['onlyIfNot'];
                 $storeValue = $branchStore[$onlyIfNotStoreKey] ?? null;
                 $storeValueAsBool = ($storeValue === null) ?
                     true : (bool) Functions::flattenSingleValue($storeValue);
                 if (is_array($storeValue)) {
                     $wrappedItem = end($storeValue);
                     $storeValue = end($wrappedItem);
                 }
                 if (
                     isset($storeValue)
                     && (
                         $storeValueAsBool
                         || Functions::isError($storeValue)
                         || ($storeValue === 'Pruned branch'))
                 ) {
                     // If branching value is true, we don't need to compute
                     if (!isset($fakedForBranchPruning['onlyIfNot-' . $onlyIfNotStoreKey])) {
                         $stack->push('Value', 'Pruned branch (only if not ' . $onlyIfNotStoreKey . ') ' . $token);
                         $fakedForBranchPruning['onlyIfNot-' . $onlyIfNotStoreKey] = true;
                     }
 
                     if (isset($storeKey)) {
                         // We are processing an if condition
                         // We cascade the pruning to the depending branches
                         $branchStore[$storeKey] = 'Pruned branch';
                         $fakedForBranchPruning['onlyIfNot-' . $storeKey] = true;
                         $fakedForBranchPruning['onlyIf-' . $storeKey] = true;
                     }
 
                     continue;
                 }
             }
 
             // if the token is a binary operator, pop the top two values off the stack, do the operation, and push the result back on the stack
             if (isset(self::$binaryOperators[$token])) {
                 //    We must have two operands, error if we don't
                 if (($operand2Data = $stack->pop()) === null) {
                     return $this->raiseFormulaError('Internal error - Operand value missing from stack');
                 }
                 if (($operand1Data = $stack->pop()) === null) {
                     return $this->raiseFormulaError('Internal error - Operand value missing from stack');
                 }
 
                 $operand1 = self::dataTestReference($operand1Data);
                 $operand2 = self::dataTestReference($operand2Data);
 
                 //    Log what we're doing
                 if ($token == ':') {
                     $this->debugLog->writeDebugLog('Evaluating Range ', $this->showValue($operand1Data['reference']), ' ', $token, ' ', $this->showValue($operand2Data['reference']));
                 } else {
                     $this->debugLog->writeDebugLog('Evaluating ', $this->showValue($operand1), ' ', $token, ' ', $this->showValue($operand2));
                 }
 
                 //    Process the operation in the appropriate manner
                 switch ($token) {
                     //    Comparison (Boolean) Operators
                     case '>':            //    Greater than
                     case '<':            //    Less than
                     case '>=':            //    Greater than or Equal to
                     case '<=':            //    Less than or Equal to
                     case '=':            //    Equality
                     case '<>':            //    Inequality
                         $result = $this->executeBinaryComparisonOperation($cellID, $operand1, $operand2, $token, $stack);
                         if (isset($storeKey)) {
                             $branchStore[$storeKey] = $result;
                         }
 
                         break;
                     //    Binary Operators
                     case ':':            //    Range
                         if (strpos($operand1Data['reference'], '!') !== false) {
                             [$sheet1, $operand1Data['reference']] = Worksheet::extractSheetTitle($operand1Data['reference'], true);
                         } else {
                             $sheet1 = ($pCellParent !== null) ? $pCellWorksheet->getTitle() : '';
                         }
 
                         [$sheet2, $operand2Data['reference']] = Worksheet::extractSheetTitle($operand2Data['reference'], true);
                         if (empty($sheet2)) {
                             $sheet2 = $sheet1;
                         }
 
                         if ($sheet1 == $sheet2) {
                             if ($operand1Data['reference'] === null) {
                                 if ((trim($operand1Data['value']) != '') && (is_numeric($operand1Data['value']))) {
                                     $operand1Data['reference'] = $pCell->getColumn() . $operand1Data['value'];
                                 } elseif (trim($operand1Data['reference']) == '') {
                                     $operand1Data['reference'] = $pCell->getCoordinate();
                                 } else {
                                     $operand1Data['reference'] = $operand1Data['value'] . $pCell->getRow();
                                 }
                             }
                             if ($operand2Data['reference'] === null) {
                                 if ((trim($operand2Data['value']) != '') && (is_numeric($operand2Data['value']))) {
                                     $operand2Data['reference'] = $pCell->getColumn() . $operand2Data['value'];
                                 } elseif (trim($operand2Data['reference']) == '') {
                                     $operand2Data['reference'] = $pCell->getCoordinate();
                                 } else {
                                     $operand2Data['reference'] = $operand2Data['value'] . $pCell->getRow();
                                 }
                             }
 
                             $oData = array_merge(explode(':', $operand1Data['reference']), explode(':', $operand2Data['reference']));
                             $oCol = $oRow = [];
                             foreach ($oData as $oDatum) {
                                 $oCR = Coordinate::coordinateFromString($oDatum);
                                 $oCol[] = Coordinate::columnIndexFromString($oCR[0]) - 1;
                                 $oRow[] = $oCR[1];
                             }
                             $cellRef = Coordinate::stringFromColumnIndex(min($oCol) + 1) . min($oRow) . ':' . Coordinate::stringFromColumnIndex(max($oCol) + 1) . max($oRow);
                             if ($pCellParent !== null) {
                                 $cellValue = $this->extractCellRange($cellRef, $this->spreadsheet->getSheetByName($sheet1), false);
                             } else {
                                 return $this->raiseFormulaError('Unable to access Cell Reference');
                             }
 
                             $stack->push('Cell Reference', $cellValue, $cellRef);
                         } else {
                             $stack->push('Error', Functions::REF(), null);
                         }
 
                         break;
                     case '+':            //    Addition
                         $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'plusEquals', $stack);
                         if (isset($storeKey)) {
                             $branchStore[$storeKey] = $result;
                         }
 
                         break;
                     case '-':            //    Subtraction
                         $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'minusEquals', $stack);
                         if (isset($storeKey)) {
                             $branchStore[$storeKey] = $result;
                         }
 
                         break;
                     case '*':            //    Multiplication
                         $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'arrayTimesEquals', $stack);
                         if (isset($storeKey)) {
                             $branchStore[$storeKey] = $result;
                         }
 
                         break;
                     case '/':            //    Division
                         $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'arrayRightDivide', $stack);
                         if (isset($storeKey)) {
                             $branchStore[$storeKey] = $result;
                         }
 
                         break;
                     case '^':            //    Exponential
                         $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'power', $stack);
                         if (isset($storeKey)) {
                             $branchStore[$storeKey] = $result;
                         }
 
                         break;
                     case '&':            //    Concatenation
                         //    If either of the operands is a matrix, we need to treat them both as matrices
                         //        (converting the other operand to a matrix if need be); then perform the required
                         //        matrix operation
                         if (is_bool($operand1)) {
                             $operand1 = ($operand1) ? self::$localeBoolean['TRUE'] : self::$localeBoolean['FALSE'];
                         }
                         if (is_bool($operand2)) {
                             $operand2 = ($operand2) ? self::$localeBoolean['TRUE'] : self::$localeBoolean['FALSE'];
                         }
                         if ((is_array($operand1)) || (is_array($operand2))) {
                             //    Ensure that both operands are arrays/matrices
                             self::checkMatrixOperands($operand1, $operand2, 2);
 
                             try {
                                 //    Convert operand 1 from a PHP array to a matrix
                                 $matrix = new Shared\JAMA\Matrix($operand1);
                                 //    Perform the required operation against the operand 1 matrix, passing in operand 2
                                 $matrixResult = $matrix->concat($operand2);
                                 $result = $matrixResult->getArray();
                             } catch (\Exception $ex) {
                                 $this->debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
                                 $result = '#VALUE!';
                             }
                         } else {
                             $result = self::FORMULA_STRING_QUOTE . str_replace('""', self::FORMULA_STRING_QUOTE, self::unwrapResult($operand1) . self::unwrapResult($operand2)) . self::FORMULA_STRING_QUOTE;
                         }
                         $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($result));
                         $stack->push('Value', $result);
 
                         if (isset($storeKey)) {
                             $branchStore[$storeKey] = $result;
                         }
 
                         break;
                     case '|':            //    Intersect
                         $rowIntersect = array_intersect_key($operand1, $operand2);
                         $cellIntersect = $oCol = $oRow = [];
                         foreach (array_keys($rowIntersect) as $row) {
                             $oRow[] = $row;
                             foreach ($rowIntersect[$row] as $col => $data) {
                                 $oCol[] = Coordinate::columnIndexFromString($col) - 1;
                                 $cellIntersect[$row] = array_intersect_key($operand1[$row], $operand2[$row]);
                             }
                         }
                         if (count(Functions::flattenArray($cellIntersect)) === 0) {
                             $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($cellIntersect));
                             $stack->push('Error', Functions::null(), null);
                         } else {
                             $cellRef = Coordinate::stringFromColumnIndex(min($oCol) + 1) . min($oRow) . ':' .
                                 Coordinate::stringFromColumnIndex(max($oCol) + 1) . max($oRow);
                             $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($cellIntersect));
                             $stack->push('Value', $cellIntersect, $cellRef);
                         }
 
                         break;
                 }
 
                 // if the token is a unary operator, pop one value off the stack, do the operation, and push it back on
             } elseif (($token === '~') || ($token === '%')) {
                 if (($arg = $stack->pop()) === null) {
                     return $this->raiseFormulaError('Internal error - Operand value missing from stack');
                 }
                 $arg = $arg['value'];
                 if ($token === '~') {
                     $this->debugLog->writeDebugLog('Evaluating Negation of ', $this->showValue($arg));
                     $multiplier = -1;
                 } else {
                     $this->debugLog->writeDebugLog('Evaluating Percentile of ', $this->showValue($arg));
                     $multiplier = 0.01;
                 }
                 if (is_array($arg)) {
                     self::checkMatrixOperands($arg, $multiplier, 2);
 
                     try {
                         $matrix1 = new Shared\JAMA\Matrix($arg);
                         $matrixResult = $matrix1->arrayTimesEquals($multiplier);
                         $result = $matrixResult->getArray();
                     } catch (\Exception $ex) {
                         $this->debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
                         $result = '#VALUE!';
                     }
                     $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($result));
                     $stack->push('Value', $result);
                     if (isset($storeKey)) {
                         $branchStore[$storeKey] = $result;
                     }
                 } else {
                     $this->executeNumericBinaryOperation($multiplier, $arg, '*', 'arrayTimesEquals', $stack);
                 }
             } elseif (preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '$/i', $token ?? '', $matches)) {
                 $cellRef = null;
 
                 if (isset($matches[8])) {
                     if ($pCell === null) {
                         //                        We can't access the range, so return a REF error
                         $cellValue = Functions::REF();
                     } else {
                         $cellRef = $matches[6] . $matches[7] . ':' . $matches[9] . $matches[10];
                         if ($matches[2] > '') {
                             $matches[2] = trim($matches[2], "\"'");
                             if ((strpos($matches[2], '[') !== false) || (strpos($matches[2], ']') !== false)) {
                                 //    It's a Reference to an external spreadsheet (not currently supported)
                                 return $this->raiseFormulaError('Unable to access External Workbook');
                             }
                             $matches[2] = trim($matches[2], "\"'");
                             $this->debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in worksheet ', $matches[2]);
                             if ($pCellParent !== null) {
                                 $cellValue = $this->extractCellRange($cellRef, $this->spreadsheet->getSheetByName($matches[2]), false);
                             } else {
                                 return $this->raiseFormulaError('Unable to access Cell Reference');
                             }
                             $this->debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->showTypeDetails($cellValue));
                         } else {
                             $this->debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in current worksheet');
                             if ($pCellParent !== null) {
                                 $cellValue = $this->extractCellRange($cellRef, $pCellWorksheet, false);
                             } else {
                                 return $this->raiseFormulaError('Unable to access Cell Reference');
                             }
                             $this->debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' is ', $this->showTypeDetails($cellValue));
                         }
                     }
                 } else {
                     if ($pCell === null) {
                         //  We can't access the cell, so return a REF error
                         $cellValue = Functions::REF();
                     } else {
                         $cellRef = $matches[6] . $matches[7];
                         if ($matches[2] > '') {
                             $matches[2] = trim($matches[2], "\"'");
                             if ((strpos($matches[2], '[') !== false) || (strpos($matches[2], ']') !== false)) {
                                 //    It's a Reference to an external spreadsheet (not currently supported)
                                 return $this->raiseFormulaError('Unable to access External Workbook');
                             }
                             $this->debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in worksheet ', $matches[2]);
                             if ($pCellParent !== null) {
                                 $cellSheet = $this->spreadsheet->getSheetByName($matches[2]);
                                 if ($cellSheet && $cellSheet->cellExists($cellRef)) {
                                     $cellValue = $this->extractCellRange($cellRef, $this->spreadsheet->getSheetByName($matches[2]), false);
                                     $pCell->attach($pCellParent);
                                 } else {
                                     $cellRef = ($cellSheet !== null) ? "{$matches[2]}!{$cellRef}" : $cellRef;
                                     $cellValue = null;
                                 }
                             } else {
                                 return $this->raiseFormulaError('Unable to access Cell Reference');
                             }
                             $this->debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->showTypeDetails($cellValue));
                         } else {
                             $this->debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in current worksheet');
                             if ($pCellParent->has($cellRef)) {
                                 $cellValue = $this->extractCellRange($cellRef, $pCellWorksheet, false);
                                 $pCell->attach($pCellParent);
                             } else {
                                 $cellValue = null;
                             }
                             $this->debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' is ', $this->showTypeDetails($cellValue));
                         }
                     }
                 }
 
                 $stack->push('Cell Value', $cellValue, $cellRef);
                 if (isset($storeKey)) {
                     $branchStore[$storeKey] = $cellValue;
                 }
 
                 // if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on
             } elseif (preg_match('/^' . self::CALCULATION_REGEXP_FUNCTION . '$/miu', $token ?? '', $matches)) {
                 if ($pCellParent) {
                     $pCell->attach($pCellParent);
                 }
 
                 $functionName = $matches[1];
                 $argCount = $stack->pop();
                 $argCount = $argCount['value'];
                 if ($functionName != 'MKMATRIX') {
                     $this->debugLog->writeDebugLog('Evaluating Function ', self::localeFunc($functionName), '() with ', (($argCount == 0) ? 'no' : $argCount), ' argument', (($argCount == 1) ? '' : 's'));
                 }
                 if ((isset(self::$phpSpreadsheetFunctions[$functionName])) || (isset(self::$controlFunctions[$functionName]))) {    // function
                     $passByReference = false;
                     $passCellReference = false;
                     $functionCall = null;
                     if (isset(self::$phpSpreadsheetFunctions[$functionName])) {
                         $functionCall = self::$phpSpreadsheetFunctions[$functionName]['functionCall'];
                         $passByReference = isset(self::$phpSpreadsheetFunctions[$functionName]['passByReference']);
                         $passCellReference = isset(self::$phpSpreadsheetFunctions[$functionName]['passCellReference']);
                     } elseif (isset(self::$controlFunctions[$functionName])) {
                         $functionCall = self::$controlFunctions[$functionName]['functionCall'];
                         $passByReference = isset(self::$controlFunctions[$functionName]['passByReference']);
                         $passCellReference = isset(self::$controlFunctions[$functionName]['passCellReference']);
                     }
                     // get the arguments for this function
                     $args = $argArrayVals = [];
                     for ($i = 0; $i < $argCount; ++$i) {
                         $arg = $stack->pop();
                         $a = $argCount - $i - 1;
                         if (
                             ($passByReference) &&
                             (isset(self::$phpSpreadsheetFunctions[$functionName]['passByReference'][$a])) &&
                             (self::$phpSpreadsheetFunctions[$functionName]['passByReference'][$a])
                         ) {
                             if ($arg['reference'] === null) {
                                 $args[] = $cellID;
                                 if ($functionName != 'MKMATRIX') {
                                     $argArrayVals[] = $this->showValue($cellID);
                                 }
                             } else {
                                 $args[] = $arg['reference'];
                                 if ($functionName != 'MKMATRIX') {
                                     $argArrayVals[] = $this->showValue($arg['reference']);
                                 }
                             }
                         } else {
                             $args[] = self::unwrapResult($arg['value']);
                             if ($functionName != 'MKMATRIX') {
                                 $argArrayVals[] = $this->showValue($arg['value']);
                             }
                         }
                     }
 
                     //    Reverse the order of the arguments
                     krsort($args);
 
                     if (($passByReference) && ($argCount == 0)) {
                         $args[] = $cellID;
                         $argArrayVals[] = $this->showValue($cellID);
                     }
 
                     if ($functionName != 'MKMATRIX') {
                         if ($this->debugLog->getWriteDebugLog()) {
                             krsort($argArrayVals);
                             $this->debugLog->writeDebugLog('Evaluating ', self::localeFunc($functionName), '( ', implode(self::$localeArgumentSeparator . ' ', Functions::flattenArray($argArrayVals)), ' )');
                         }
                     }
 
                     //    Process the argument with the appropriate function call
                     $args = $this->addCellReference($args, $passCellReference, $functionCall, $pCell);
 
                     if (!is_array($functionCall)) {
                         foreach ($args as &$arg) {
                             $arg = Functions::flattenSingleValue($arg);
                         }
                         unset($arg);
                     }
 
                     $result = call_user_func_array($functionCall, $args);
 
                     if ($functionName != 'MKMATRIX') {
                         $this->debugLog->writeDebugLog('Evaluation Result for ', self::localeFunc($functionName), '() function call is ', $this->showTypeDetails($result));
                     }
                     $stack->push('Value', self::wrapResult($result));
                     if (isset($storeKey)) {
                         $branchStore[$storeKey] = $result;
                     }
                 }
             } else {
                 // if the token is a number, boolean, string or an Excel error, push it onto the stack
                 if (isset(self::$excelConstants[strtoupper($token ?? '')])) {
                     $excelConstant = strtoupper($token);
                     $stack->push('Constant Value', self::$excelConstants[$excelConstant]);
                     if (isset($storeKey)) {
                         $branchStore[$storeKey] = self::$excelConstants[$excelConstant];
                     }
                     $this->debugLog->writeDebugLog('Evaluating Constant ', $excelConstant, ' as ', $this->showTypeDetails(self::$excelConstants[$excelConstant]));
                 } elseif ((is_numeric($token)) || ($token === null) || (is_bool($token)) || ($token == '') || ($token[0] == self::FORMULA_STRING_QUOTE) || ($token[0] == '#')) {
                     $stack->push('Value', $token);
                     if (isset($storeKey)) {
                         $branchStore[$storeKey] = $token;
                     }
                     // if the token is a named range or formula, evaluate it and push the result onto the stack
                 } elseif (preg_match('/^' . self::CALCULATION_REGEXP_DEFINEDNAME . '$/miu', $token, $matches)) {
                     $definedName = $matches[6];
                     if ($pCell === null || $pCellWorksheet === null) {
                         return $this->raiseFormulaError("undefined name '$token'");
                     }
 
                     $this->debugLog->writeDebugLog('Evaluating Defined Name ', $definedName);
                     $namedRange = DefinedName::resolveName($definedName, $pCellWorksheet);
                     if ($namedRange === null) {
                         return $this->raiseFormulaError("undefined name '$definedName'");
                     }
 
                     $result = $this->evaluateDefinedName($pCell, $namedRange, $pCellWorksheet, $stack);
                     if (isset($storeKey)) {
                         $branchStore[$storeKey] = $result;
                     }
                 } else {
                     return $this->raiseFormulaError("undefined name '$token'");
                 }
             }
         }
         // when we're out of tokens, the stack should have a single element, the final result
         if ($stack->count() != 1) {
             return $this->raiseFormulaError('internal error');
         }
         $output = $stack->pop();
         $output = $output['value'];
 
         return $output;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ raiseFormulaError()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::raiseFormulaError ( $errorMessage )

protected

Definition at line 5219 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\convertMatrixReferences(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

     {
         $this->formulaError = $errorMessage;
         $this->cyclicReferenceStack->clear();
         if (!$this->suppressFormulaErrors) {
             throw new Exception($errorMessage);
         }
         trigger_error($errorMessage, E_USER_ERROR);
 
         return false;
     }

Here is the caller graph for this function:

◆ renameCalculationCacheForWorksheet()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::renameCalculationCacheForWorksheet	(	$fromWorksheetName,
		$toWorksheetName
	)

Rename calculation cache for a specified worksheet.

Parameters

string	$fromWorksheetName
string	$toWorksheetName

Definition at line 2944 of file Calculation.php.

                                                                                             : void
     {
         if (isset($this->calculationCache[$fromWorksheetName])) {
             $this->calculationCache[$toWorksheetName] = &$this->calculationCache[$fromWorksheetName];
             unset($this->calculationCache[$fromWorksheetName]);
         }
     }

◆ resizeMatricesExtend()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::resizeMatricesExtend	(	&	$matrix1,
		&	$matrix2,
			$matrix1Rows,
			$matrix1Columns,
			$matrix2Rows,
			$matrix2Columns
	)

staticprivate

Ensure that paired matrix operands are both matrices of the same size.

Parameters

mixed	$matrix1	First matrix operand
mixed	$matrix2	Second matrix operand
int	$matrix1Rows	Row size of first matrix operand
int	$matrix1Columns	Column size of first matrix operand
int	$matrix2Rows	Row size of second matrix operand
int	$matrix2Columns	Column size of second matrix operand

Definition at line 3674 of file Calculation.php.

References $i, and $x.

                                                                                                                                     : void
     {
         if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {
             if ($matrix2Columns < $matrix1Columns) {
                 for ($i = 0; $i < $matrix2Rows; ++$i) {
                     $x = $matrix2[$i][$matrix2Columns - 1];
                     for ($j = $matrix2Columns; $j < $matrix1Columns; ++$j) {
                         $matrix2[$i][$j] = $x;
                     }
                 }
             }
             if ($matrix2Rows < $matrix1Rows) {
                 $x = $matrix2[$matrix2Rows - 1];
                 for ($i = 0; $i < $matrix1Rows; ++$i) {
                     $matrix2[$i] = $x;
                 }
             }
         }
 
         if (($matrix1Columns < $matrix2Columns) || ($matrix1Rows < $matrix2Rows)) {
             if ($matrix1Columns < $matrix2Columns) {
                 for ($i = 0; $i < $matrix1Rows; ++$i) {
                     $x = $matrix1[$i][$matrix1Columns - 1];
                     for ($j = $matrix1Columns; $j < $matrix2Columns; ++$j) {
                         $matrix1[$i][$j] = $x;
                     }
                 }
             }
             if ($matrix1Rows < $matrix2Rows) {
                 $x = $matrix1[$matrix1Rows - 1];
                 for ($i = 0; $i < $matrix2Rows; ++$i) {
                     $matrix1[$i] = $x;
                 }
             }
         }
     }

◆ resizeMatricesShrink()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::resizeMatricesShrink	(	&	$matrix1,
		&	$matrix2,
			$matrix1Rows,
			$matrix1Columns,
			$matrix2Rows,
			$matrix2Columns
	)

staticprivate

Ensure that paired matrix operands are both matrices of the same size.

Parameters

mixed	$matrix1	First matrix operand
mixed	$matrix2	Second matrix operand
int	$matrix1Rows	Row size of first matrix operand
int	$matrix1Columns	Column size of first matrix operand
int	$matrix2Rows	Row size of second matrix operand
int	$matrix2Columns	Column size of second matrix operand

Definition at line 3631 of file Calculation.php.

References $i.

                                                                                                                                     : void
     {
         if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {
             if ($matrix2Rows < $matrix1Rows) {
                 for ($i = $matrix2Rows; $i < $matrix1Rows; ++$i) {
                     unset($matrix1[$i]);
                 }
             }
             if ($matrix2Columns < $matrix1Columns) {
                 for ($i = 0; $i < $matrix1Rows; ++$i) {
                     for ($j = $matrix2Columns; $j < $matrix1Columns; ++$j) {
                         unset($matrix1[$i][$j]);
                     }
                 }
             }
         }
 
         if (($matrix1Columns < $matrix2Columns) || ($matrix1Rows < $matrix2Rows)) {
             if ($matrix1Rows < $matrix2Rows) {
                 for ($i = $matrix1Rows; $i < $matrix2Rows; ++$i) {
                     unset($matrix2[$i]);
                 }
             }
             if ($matrix1Columns < $matrix2Columns) {
                 for ($i = 0; $i < $matrix2Rows; ++$i) {
                     for ($j = $matrix1Columns; $j < $matrix2Columns; ++$j) {
                         unset($matrix2[$i][$j]);
                     }
                 }
             }
         }
     }

◆ saveValueToCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::saveValueToCache	(	$cellReference,
		$cellValue
	)

Parameters

string	$cellReference
mixed	$cellValue

Definition at line 3466 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue().

                                                                 : void
     {
         if ($this->calculationCacheEnabled) {
             $this->calculationCache[$cellReference] = $cellValue;
         }
     }

Here is the caller graph for this function:

◆ setArrayReturnType()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::setArrayReturnType ( $returnType )

static

Set the Array Return Type (Array or Value of first element in the array).

Parameters

string $returnType Array return type

Returns: bool Success or failure

Definition at line 2856 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Writer\Html\generateHtmlAll(), and PhpOffice\PhpSpreadsheet\Writer\Csv\save().

     {
         if (
             ($returnType == self::RETURN_ARRAY_AS_VALUE) ||
             ($returnType == self::RETURN_ARRAY_AS_ERROR) ||
             ($returnType == self::RETURN_ARRAY_AS_ARRAY)
         ) {
             self::$returnArrayAsType = $returnType;
 
             return true;
         }
 
         return false;
     }

Here is the caller graph for this function:

◆ setBranchPruningEnabled()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::setBranchPruningEnabled ( $enabled )

Enable/disable calculation cache.

Parameters

mixed $enabled

Definition at line 2957 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\disableBranchPruning(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\enableBranchPruning().

                                                      : void
     {
         $this->branchPruningEnabled = $enabled;
     }

Here is the caller graph for this function:

◆ setCalculationCacheEnabled()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::setCalculationCacheEnabled ( $pValue )

Enable/disable calculation cache.

Parameters

bool $pValue

Definition at line 2896 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\clearCalculationCache().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\disableCalculationCache(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\enableCalculationCache().

                                                        : void
     {
         $this->calculationCacheEnabled = $pValue;
         $this->clearCalculationCache();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setLocale()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::setLocale ( string $locale )

Set the locale code.

Parameters

string $locale The locale to use for formula translation, eg: 'en_us'

Returns: bool

Definition at line 3009 of file Calculation.php.

References $language, PhpOffice\PhpSpreadsheet\Calculation\Calculation\$localeFunctions, and PhpOffice\PhpSpreadsheet\Calculation\Calculation\getLocaleFile().

     {
         //    Identify our locale and language
         $language = $locale = strtolower($locale);
         if (strpos($locale, '_') !== false) {
             [$language] = explode('_', $locale);
         }
         if (count(self::$validLocaleLanguages) == 1) {
             self::loadLocales();
         }
 
         //    Test whether we have any language data for this language (any locale)
         if (in_array($language, self::$validLocaleLanguages)) {
             //    initialise language/locale settings
             self::$localeFunctions = [];
             self::$localeArgumentSeparator = ',';
             self::$localeBoolean = ['TRUE' => 'TRUE', 'FALSE' => 'FALSE', 'NULL' => 'NULL'];
 
             //    Default is US English, if user isn't requesting US english, then read the necessary data from the locale files
             if ($locale !== 'en_us') {
                 $localeDir = implode(DIRECTORY_SEPARATOR, [__DIR__, 'locale', null]);
                 //    Search for a file with a list of function names for locale
                 try {
                     $functionNamesFile = $this->getLocaleFile($localeDir, $locale, $language, 'functions');
                 } catch (Exception $e) {
                     return false;
                 }
 
                 //    Retrieve the list of locale or language specific function names
                 $localeFunctions = file($functionNamesFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
                 foreach ($localeFunctions as $localeFunction) {
                     [$localeFunction] = explode('##', $localeFunction); //    Strip out comments
                     if (strpos($localeFunction, '=') !== false) {
                         [$fName, $lfName] = array_map('trim', explode('=', $localeFunction));
                         if ((isset(self::$phpSpreadsheetFunctions[$fName])) && ($lfName != '') && ($fName != $lfName)) {
                             self::$localeFunctions[$fName] = $lfName;
                         }
                     }
                 }
                 //    Default the TRUE and FALSE constants to the locale names of the TRUE() and FALSE() functions
                 if (isset(self::$localeFunctions['TRUE'])) {
                     self::$localeBoolean['TRUE'] = self::$localeFunctions['TRUE'];
                 }
                 if (isset(self::$localeFunctions['FALSE'])) {
                     self::$localeBoolean['FALSE'] = self::$localeFunctions['FALSE'];
                 }
 
                 try {
                     $configFile = $this->getLocaleFile($localeDir, $locale, $language, 'config');
                 } catch (Exception $e) {
                     return false;
                 }
 
                 $localeSettings = file($configFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
                 foreach ($localeSettings as $localeSetting) {
                     [$localeSetting] = explode('##', $localeSetting); //    Strip out comments
                     if (strpos($localeSetting, '=') !== false) {
                         [$settingName, $settingValue] = array_map('trim', explode('=', $localeSetting));
                         $settingName = strtoupper($settingName);
                         if ($settingValue !== '') {
                             switch ($settingName) {
                                 case 'ARGUMENTSEPARATOR':
                                     self::$localeArgumentSeparator = $settingValue;
 
                                     break;
                             }
                         }
                     }
                 }
             }
 
             self::$functionReplaceFromExcel = self::$functionReplaceToExcel =
             self::$functionReplaceFromLocale = self::$functionReplaceToLocale = null;
             self::$localeLanguage = $locale;
 
             return true;
         }
 
         return false;
     }

Here is the call graph for this function:

◆ showTypeDetails()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::showTypeDetails ( $value )

private

Format type and details of an operand for display in the log (based on operand type).

Parameters

mixed $value First matrix operand

Returns: null|string

Definition at line 3756 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Functions\flattenArray(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\showValue().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeArrayComparison(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeNumericBinaryOperation(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\validateBinaryOperand().

     {
         if ($this->debugLog->getWriteDebugLog()) {
             $testArray = Functions::flattenArray($value);
             if (count($testArray) == 1) {
                 $value = array_pop($testArray);
             }
 
             if ($value === null) {
                 return 'a NULL value';
             } elseif (is_float($value)) {
                 $typeString = 'a floating point number';
             } elseif (is_int($value)) {
                 $typeString = 'an integer number';
             } elseif (is_bool($value)) {
                 $typeString = 'a boolean';
             } elseif (is_array($value)) {
                 $typeString = 'a matrix';
             } else {
                 if ($value == '') {
                     return 'an empty string';
                 } elseif ($value[0] == '#') {
                     return 'a ' . $value . ' error';
                 }
                 $typeString = 'a string';
             }
 
             return $typeString . ' with a value of ' . $this->showValue($value);
         }
 
         return null;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ showValue()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::showValue ( $value )

private

Format details of an operand for display in the log (based on operand type).

Parameters

mixed $value First matrix operand

Returns: mixed

Definition at line 3718 of file Calculation.php.

References $row, PhpOffice\PhpSpreadsheet\Calculation\Functions\flattenArray(), and PhpOffice\PhpSpreadsheet\Calculation\Functions\flattenSingleValue().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeArrayComparison(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\showTypeDetails().

     {
         if ($this->debugLog->getWriteDebugLog()) {
             $testArray = Functions::flattenArray($value);
             if (count($testArray) == 1) {
                 $value = array_pop($testArray);
             }
 
             if (is_array($value)) {
                 $returnMatrix = [];
                 $pad = $rpad = ', ';
                 foreach ($value as $row) {
                     if (is_array($row)) {
                         $returnMatrix[] = implode($pad, array_map([$this, 'showValue'], $row));
                         $rpad = '; ';
                     } else {
                         $returnMatrix[] = $this->showValue($row);
                     }
                 }
 
                 return '{ ' . implode($rpad, $returnMatrix) . ' }';
             } elseif (is_string($value) && (trim($value, self::FORMULA_STRING_QUOTE) == $value)) {
                 return self::FORMULA_STRING_QUOTE . $value . self::FORMULA_STRING_QUOTE;
             } elseif (is_bool($value)) {
                 return ($value) ? self::$localeBoolean['TRUE'] : self::$localeBoolean['FALSE'];
             }
         }
 
         return Functions::flattenSingleValue($value);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ strcmpAllowNull()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::strcmpAllowNull	(	$str1,
		$str2
	)

private

PHP8.1 deprecates passing null to strcmp.

Parameters

null \| string	$str1	First string value for the comparison
null \| string	$str2	Second string value for the comparison

Returns: int

Definition at line 5120 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation().

     {
         return strcmp($str1 ?? '', $str2 ?? '');
     }

Here is the caller graph for this function:

◆ strcmpLowercaseFirst()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::strcmpLowercaseFirst	(	$str1,
		$str2
	)

private

Compare two strings in the same way as strcmp() except that lowercase come before uppercase letters.

Parameters

null \| string	$str1	First string value for the comparison
null \| string	$str2	Second string value for the comparison

Returns: int

Definition at line 5104 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Shared\StringHelper\strCaseReverse().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation().

     {
         $inversedStr1 = Shared\StringHelper::strCaseReverse($str1);
         $inversedStr2 = Shared\StringHelper::strCaseReverse($str2);
 
         return strcmp($inversedStr1 ?? '', $inversedStr2 ?? '');
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ translateFormula()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::translateFormula	(	array	$from,
		array	$to,
			$formula,
			$fromSeparator,
			$toSeparator
	)

staticprivate

Parameters

	string[]	$from
	string[]	$to
string	$formula
string	$fromSeparator
string	$toSeparator

Returns: string

Definition at line 3131 of file Calculation.php.

References $i.

     {
         //    Convert any Excel function names to the required language
         if (self::$localeLanguage !== 'en_us') {
             $inBraces = false;
             //    If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
             if (strpos($formula, self::FORMULA_STRING_QUOTE) !== false) {
                 //    So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
                 //        the formula
                 $temp = explode(self::FORMULA_STRING_QUOTE, $formula);
                 $i = false;
                 foreach ($temp as &$value) {
                     //    Only count/replace in alternating array entries
                     if ($i = !$i) {
                         $value = preg_replace($from, $to, $value);
                         $value = self::translateSeparator($fromSeparator, $toSeparator, $value, $inBraces);
                     }
                 }
                 unset($value);
                 //    Then rebuild the formula string
                 $formula = implode(self::FORMULA_STRING_QUOTE, $temp);
             } else {
                 //    If there's no quoted strings, then we do a simple count/replace
                 $formula = preg_replace($from, $to, $formula);
                 $formula = self::translateSeparator($fromSeparator, $toSeparator, $formula, $inBraces);
             }
         }
 
         return $formula;
     }

◆ translateSeparator()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::translateSeparator	(		$fromSeparator,
			$toSeparator,
			$formula,
		&	$inBraces
	)

static

Parameters

string	$fromSeparator
string	$toSeparator
string	$formula
bool	$inBraces

Returns: string

Definition at line 3098 of file Calculation.php.

References $i.

Referenced by PhpOffice\PhpSpreadsheet\Reader\Ods\BaseReader\convertToExcelFormulaValue(), and PhpOffice\PhpSpreadsheet\Reader\Ods\convertToExcelFormulaValue().

     {
         $strlen = mb_strlen($formula);
         for ($i = 0; $i < $strlen; ++$i) {
             $chr = mb_substr($formula, $i, 1);
             switch ($chr) {
                 case self::FORMULA_OPEN_FUNCTION_BRACE:
                     $inBraces = true;
 
                     break;
                 case self::FORMULA_CLOSE_FUNCTION_BRACE:
                     $inBraces = false;
 
                     break;
                 case $fromSeparator:
                     if (!$inBraces) {
                         $formula = mb_substr($formula, 0, $i) . $toSeparator . mb_substr($formula, $i + 1);
                     }
             }
         }
 
         return $formula;
     }

Here is the caller graph for this function:

◆ unwrapResult()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::unwrapResult ( $value )

static

Remove quotes used as a wrapper to identify string values.

Parameters

mixed $value

Returns: mixed

Definition at line 3269 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Functions\NAN().

Referenced by PhpOffice\PhpSpreadsheet\Reader\Slk\processCFinal(), PhpOffice\PhpSpreadsheet\Reader\Slk\processCRecord(), and PhpOffice\PhpSpreadsheet\Chart\DataSeriesValues\refresh().

     {
         if (is_string($value)) {
             if ((isset($value[0])) && ($value[0] == self::FORMULA_STRING_QUOTE) && (substr($value, -1) == self::FORMULA_STRING_QUOTE)) {
                 return substr($value, 1, -1);
             }
             //    Convert numeric errors to NAN error
         } elseif ((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
             return Functions::NAN();
         }
 
         return $value;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validateBinaryOperand()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::validateBinaryOperand	(	&	$operand,
		&	$stack
	)

private

Definition at line 4902 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Shared\StringHelper\convertToNumberIfFraction(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\showTypeDetails().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeNumericBinaryOperation().

     {
         if (is_array($operand)) {
             if ((count($operand, COUNT_RECURSIVE) - count($operand)) == 1) {
                 do {
                     $operand = array_pop($operand);
                 } while (is_array($operand));
             }
         }
         //    Numbers, matrices and booleans can pass straight through, as they're already valid
         if (is_string($operand)) {
             //    We only need special validations for the operand if it is a string
             //    Start by stripping off the quotation marks we use to identify true excel string values internally
             if ($operand > '' && $operand[0] == self::FORMULA_STRING_QUOTE) {
                 $operand = self::unwrapResult($operand);
             }
             //    If the string is a numeric value, we treat it as a numeric, so no further testing
             if (!is_numeric($operand)) {
                 //    If not a numeric, test to see if the value is an Excel error, and so can't be used in normal binary operations
                 if ($operand > '' && $operand[0] == '#') {
                     $stack->push('Value', $operand);
                     $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($operand));
 
                     return false;
                 } elseif (!Shared\StringHelper::convertToNumberIfFraction($operand)) {
                     //    If not a numeric or a fraction, then it's a text string, and so can't be used in mathematical binary operations
                     $stack->push('Error', '#VALUE!');
                     $this->debugLog->writeDebugLog('Evaluation Result is a ', $this->showTypeDetails('#VALUE!'));
 
                     return false;
                 }
             }
         }
 
         //    return a true if the value of the operand is one that we can use in normal binary operations
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wrapResult()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::wrapResult ( $value )

static

Wrap string values in quotes.

Parameters

mixed $value

Returns: mixed

Definition at line 3243 of file Calculation.php.

References PhpOffice\PhpSpreadsheet\Calculation\Functions\NAN().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Functions\ifCondition(), and PhpOffice\PhpSpreadsheet\Calculation\Database\DatabaseAbstract\processCondition().

     {
         if (is_string($value)) {
             //    Error values cannot be "wrapped"
             if (preg_match('/^' . self::CALCULATION_REGEXP_ERROR . '$/i', $value, $match)) {
                 //    Return Excel errors "as is"
                 return $value;
             }
 
             //    Return strings wrapped in quotes
             return self::FORMULA_STRING_QUOTE . $value . self::FORMULA_STRING_QUOTE;
         } elseif ((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
             //    Convert numeric errors to NaN error
             return Functions::NAN();
         }
 
         return $value;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

◆ $binaryOperators

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$binaryOperators

staticprivate

Initial value:

= [

'+' => true

Definition at line 110 of file Calculation.php.

◆ $branchPruningEnabled

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$branchPruningEnabled = true

private

Definition at line 90 of file Calculation.php.

◆ $branchStoreKeyCounter

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$branchStoreKeyCounter = 0

private

Definition at line 88 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getUnusedBranchStoreKey().

◆ $calculationCache

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$calculationCache = []

private

Definition at line 74 of file Calculation.php.

◆ $calculationCacheEnabled

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$calculationCacheEnabled = true

private

Definition at line 81 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getCalculationCacheEnabled().

◆ $cellStack

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cellStack = []

private

Definition at line 154 of file Calculation.php.

◆ $comparisonOperators

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::$comparisonOperators = ['>' => true

staticprivate

Definition at line 3859 of file Calculation.php.

◆ $controlFunctions

static static PhpOffice\PhpSpreadsheet\Calculation\Calculation::$controlFunctions

staticprivate

Initial value:

= [
        'MKMATRIX' => [
            'argumentCount' => '*'

Definition at line 2743 of file Calculation.php.

◆ $cyclicFormulaCell

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cyclicFormulaCell = ''

private

Definition at line 165 of file Calculation.php.

◆ $cyclicFormulaCount

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cyclicFormulaCount = 1

Definition at line 172 of file Calculation.php.

◆ $cyclicFormulaCounter

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cyclicFormulaCounter = 1

private

Definition at line 163 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue().

◆ $cyclicReferenceStack

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cyclicReferenceStack

private

Definition at line 152 of file Calculation.php.

◆ $debugLog

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$debugLog

private

Definition at line 122 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getDebugLog().

◆ $delta

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$delta = 0.1e-12

private

Definition at line 179 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions\Beta\betaFraction(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation().

◆ $excelConstants

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$excelConstants

staticprivate

Initial value:

= [

'TRUE' => true

Definition at line 224 of file Calculation.php.

◆ $formulaError

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$formulaError

Definition at line 138 of file Calculation.php.

◆ $functionReplaceFromExcel

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$functionReplaceFromExcel = null

staticprivate

Definition at line 3162 of file Calculation.php.

◆ $functionReplaceFromLocale

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$functionReplaceFromLocale = null

staticprivate

Definition at line 3191 of file Calculation.php.

◆ $functionReplaceToExcel

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$functionReplaceToExcel = null

staticprivate

Definition at line 3193 of file Calculation.php.

◆ $functionReplaceToLocale

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$functionReplaceToLocale = null

staticprivate

Definition at line 3164 of file Calculation.php.

◆ $instance

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$instance

staticprivate

Definition at line 60 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getInstance(), PhpOffice\PhpSpreadsheet\Calculation\TextData\Replace\substitute(), and PhpOffice\PhpSpreadsheet\Calculation\TextData\SUBSTITUTE().

◆ $localeArgumentSeparator

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$localeArgumentSeparator = ','

staticprivate

Definition at line 203 of file Calculation.php.

◆ $localeBoolean

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$localeBoolean

static

Initial value:

= [

'TRUE' => 'TRUE'

Definition at line 212 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_translateFormulaToLocale().

◆ $localeFunctions

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$localeFunctions = []

staticprivate

Definition at line 205 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\setLocale().

◆ $localeLanguage

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$localeLanguage = 'en_us'

staticprivate

Definition at line 186 of file Calculation.php.

◆ $operatorAssociativity

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$operatorAssociativity

staticprivate

Initial value:

= [

'^' => 0

Definition at line 3848 of file Calculation.php.

◆ $operatorPrecedence

static static PhpOffice\PhpSpreadsheet\Calculation\Calculation::$operatorPrecedence

staticprivate

Initial value:

= [

':' => 8

Definition at line 3864 of file Calculation.php.

◆ $operators

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$operators

staticprivate

Initial value:

= [

'+' => true

Definition at line 98 of file Calculation.php.

◆ $phpSpreadsheetFunctions

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::$phpSpreadsheetFunctions

staticprivate

Initial value:

= [
        'ABS' => [
            'category' => Category::CATEGORY_MATH_AND_TRIG

Definition at line 231 of file Calculation.php.

◆ $referenceHelper

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$referenceHelper

staticprivate

Definition at line 145 of file Calculation.php.

◆ $returnArrayAsType

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$returnArrayAsType = self::RETURN_ARRAY_AS_VALUE

staticprivate

Definition at line 53 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateCellValue().

◆ $spreadsheet

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$spreadsheet

private

Definition at line 67 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\__construct(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\evaluateDefinedName(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\getInstance().

◆ $suppressFormulaErrors

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$suppressFormulaErrors = false

Definition at line 131 of file Calculation.php.

◆ $validLocaleLanguages

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$validLocaleLanguages

staticprivate

Initial value:

= [
        'en', 
    ]

Definition at line 194 of file Calculation.php.

◆ CALCULATION_REGEXP_CELLREF

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_CELLREF = '((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?\b([a-z]{1,3})\$?(\d{1,7})(?![\w.])'

Definition at line 30 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Worksheet\Worksheet\getWorksheetAndCoordinate(), PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Indirect\INDIRECT(), PhpOffice\PhpSpreadsheet\Calculation\Functions\isFormula(), PhpOffice\PhpSpreadsheet\Writer\Xls\Workbook\parseDefinedNameValue(), and PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Formula\text().

◆ CALCULATION_REGEXP_CELLREF_RELATIVE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_CELLREF_RELATIVE = '((([^\s\(,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?(\$?\b[a-z]{1,3})(\$?\d{1,7})(?![\w.])'

Definition at line 32 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Writer\Ods\NamedExpressions\convertAddress(), PhpOffice\PhpSpreadsheet\Writer\Ods\Formula\convertCellReferences(), and PhpOffice\PhpSpreadsheet\ReferenceHelper\updateCellReferencesAllWorksheets().

◆ CALCULATION_REGEXP_COLUMN_RANGE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_COLUMN_RANGE = '(((([^\s\(,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?(\$?[a-z]{1,3})):(?![.*])'

Definition at line 33 of file Calculation.php.

◆ CALCULATION_REGEXP_COLUMNRANGE_RELATIVE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_COLUMNRANGE_RELATIVE = '(\$?[a-z]{1,3}):(\$?[a-z]{1,3})'

Definition at line 37 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\ReferenceHelper\updateColumnRangesAllWorksheets().

◆ CALCULATION_REGEXP_DEFINEDNAME

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_DEFINEDNAME = '((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?([_\p{L}][_\p{L}\p{N}\.]*)'

Definition at line 40 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Writer\Xls\Parser\convert(), PhpOffice\PhpSpreadsheet\Writer\Ods\Formula\convertDefinedNames(), PhpOffice\PhpSpreadsheet\Writer\Xls\Parser\fact(), PhpOffice\PhpSpreadsheet\Worksheet\Worksheet\getWorksheetAndCoordinate(), and PhpOffice\PhpSpreadsheet\Writer\Xls\Parser\match().

◆ CALCULATION_REGEXP_ERROR

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_ERROR = '\#[A-Z][A-Z0_\/]*[!\?]?'

Definition at line 42 of file Calculation.php.

◆ CALCULATION_REGEXP_FUNCTION

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_FUNCTION = '@?(?:_xlfn\.)?([\p{L}][\p{L}\p{N}\.]*)[\s]*\('

Definition at line 28 of file Calculation.php.

◆ CALCULATION_REGEXP_NUMBER

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_NUMBER = '[-+]?\d*\.?\d+(e[-+]?\d+)?'

Constants.

Regular Expressions

Definition at line 22 of file Calculation.php.

◆ CALCULATION_REGEXP_OPENBRACE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_OPENBRACE = '\('

Definition at line 26 of file Calculation.php.

◆ CALCULATION_REGEXP_ROW_RANGE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_ROW_RANGE = '(((([^\s\(,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?(\$?[1-9][0-9]{0,6})):(?![.*])'

Definition at line 34 of file Calculation.php.

◆ CALCULATION_REGEXP_ROWRANGE_RELATIVE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_ROWRANGE_RELATIVE = '(\$?\d{1,7}):(\$?\d{1,7})'

Definition at line 38 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\ReferenceHelper\updateRowRangesAllWorksheets().

◆ CALCULATION_REGEXP_STRING

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_STRING = '"(?:[^"]|"")*"'

Definition at line 24 of file Calculation.php.

◆ FORMULA_CLOSE_FUNCTION_BRACE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::FORMULA_CLOSE_FUNCTION_BRACE = '}'

Definition at line 50 of file Calculation.php.

◆ FORMULA_OPEN_FUNCTION_BRACE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::FORMULA_OPEN_FUNCTION_BRACE = '{'

Definition at line 49 of file Calculation.php.

◆ FORMULA_STRING_QUOTE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::FORMULA_STRING_QUOTE = '"'

Definition at line 51 of file Calculation.php.

◆ RETURN_ARRAY_AS_ARRAY

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::RETURN_ARRAY_AS_ARRAY = 'array'

Definition at line 47 of file Calculation.php.

◆ RETURN_ARRAY_AS_ERROR

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::RETURN_ARRAY_AS_ERROR = 'error'

constants

Definition at line 45 of file Calculation.php.

◆ RETURN_ARRAY_AS_VALUE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::RETURN_ARRAY_AS_VALUE = 'value'

Definition at line 46 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Writer\Html\generateHtmlAll(), and PhpOffice\PhpSpreadsheet\Writer\Csv\save().

The documentation for this class was generated from the following file:

libs/composer/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Calculation.php

Public Member Functions

Static Public Member Functions

Data Fields

Static Public Attributes

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ __clone()

◆ _calculateFormulaValue()

◆ _translateFormulaToEnglish()

◆ _translateFormulaToLocale()

◆ addCellReference()

◆ calculate()

◆ calculateCellValue()

◆ calculateFormula()

◆ checkMatrixOperands()

◆ clearBranchStore()

◆ clearCalculationCache()

◆ clearCalculationCacheForWorksheet()

◆ convertMatrixReferences()

◆ dataTestReference()

◆ disableBranchPruning()

◆ disableCalculationCache()

◆ enableBranchPruning()

◆ enableCalculationCache()

◆ evaluateDefinedName()

◆ executeArrayComparison()

◆ executeBinaryComparisonOperation()

◆ executeNumericBinaryOperation()

◆ extractCellRange()

◆ extractNamedRange()

◆ flushInstance()

◆ getArrayReturnType()

◆ getCalculationCacheEnabled()

◆ getDebugLog()

◆ getFALSE()

◆ getFunctions()

◆ getImplementedFunctionNames()

◆ getInstance()

◆ getLocale()

◆ getLocaleFile()

◆ getMatrixDimensions()

◆ getTokensAsString()

◆ getTRUE()

◆ getUnusedBranchStoreKey()

◆ getValueFromCache()

◆ internalParseFormula()

◆ isImplemented()

◆ loadLocales()

◆ localeFunc()

◆ parseFormula()

◆ processTokenStack()

◆ raiseFormulaError()

◆ renameCalculationCacheForWorksheet()

◆ resizeMatricesExtend()

◆ resizeMatricesShrink()

◆ saveValueToCache()

◆ setArrayReturnType()

◆ setBranchPruningEnabled()

◆ setCalculationCacheEnabled()

◆ setLocale()

◆ showTypeDetails()

◆ showValue()

◆ strcmpAllowNull()

◆ strcmpLowercaseFirst()

◆ translateFormula()

◆ translateSeparator()

◆ unwrapResult()

◆ validateBinaryOperand()

◆ wrapResult()

Field Documentation

◆ $binaryOperators

◆ $branchPruningEnabled

◆ $branchStoreKeyCounter