Functions.php in Loft Data Grids 7.2

File

vendor/phpoffice/phpexcel/Classes/PHPExcel/Calculation/Functions.php

<?php

/**
 * PHPExcel
 *
 * Copyright (c) 2006 - 2014 PHPExcel
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * @category	PHPExcel
 * @package		PHPExcel_Calculation
 * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
 * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
 * @version		##VERSION##, ##DATE##
 */

/** PHPExcel root directory */
if (!defined('PHPEXCEL_ROOT')) {

  /**
   * @ignore
   */
  define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
  require PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php';
}

/** MAX_VALUE */
define('MAX_VALUE', 1.2E+308);

/** 2 / PI */
define('M_2DIVPI', 0.6366197723675814);

/** MAX_ITERATIONS */
define('MAX_ITERATIONS', 256);

/** PRECISION */
define('PRECISION', 8.88E-16);

/**
 * PHPExcel_Calculation_Functions
 *
 * @category	PHPExcel
 * @package		PHPExcel_Calculation
 * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
 */
class PHPExcel_Calculation_Functions {

  /** constants */
  const COMPATIBILITY_EXCEL = 'Excel';
  const COMPATIBILITY_GNUMERIC = 'Gnumeric';
  const COMPATIBILITY_OPENOFFICE = 'OpenOfficeCalc';
  const RETURNDATE_PHP_NUMERIC = 'P';
  const RETURNDATE_PHP_OBJECT = 'O';
  const RETURNDATE_EXCEL = 'E';

  /**
   * Compatibility mode to use for error checking and responses
   *
   * @access	private
   * @var string
   */
  protected static $compatibilityMode = self::COMPATIBILITY_EXCEL;

  /**
   * Data Type to use when returning date values
   *
   * @access	private
   * @var string
   */
  protected static $ReturnDateType = self::RETURNDATE_EXCEL;

  /**
   * List of error codes
   *
   * @access	private
   * @var array
   */
  protected static $_errorCodes = array(
    'null' => '#NULL!',
    'divisionbyzero' => '#DIV/0!',
    'value' => '#VALUE!',
    'reference' => '#REF!',
    'name' => '#NAME?',
    'num' => '#NUM!',
    'na' => '#N/A',
    'gettingdata' => '#GETTING_DATA',
  );

  /**
   * Set the Compatibility Mode
   *
   * @access	public
   * @category Function Configuration
   * @param	 string		$compatibilityMode		Compatibility Mode
   *												Permitted values are:
   *													PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL			'Excel'
   *													PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC		'Gnumeric'
   *													PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE	'OpenOfficeCalc'
   * @return	 boolean	(Success or Failure)
   */
  public static function setCompatibilityMode($compatibilityMode) {
    if ($compatibilityMode == self::COMPATIBILITY_EXCEL || $compatibilityMode == self::COMPATIBILITY_GNUMERIC || $compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
      self::$compatibilityMode = $compatibilityMode;
      return True;
    }
    return False;
  }

  //	function setCompatibilityMode()

  /**
   * Return the current Compatibility Mode
   *
   * @access	public
   * @category Function Configuration
   * @return	 string		Compatibility Mode
   *							Possible Return values are:
   *								PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL			'Excel'
   *								PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC		'Gnumeric'
   *								PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE	'OpenOfficeCalc'
   */
  public static function getCompatibilityMode() {
    return self::$compatibilityMode;
  }

  //	function getCompatibilityMode()

  /**
   * Set the Return Date Format used by functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object)
   *
   * @access	public
   * @category Function Configuration
   * @param	 string	$returnDateType			Return Date Format
   *												Permitted values are:
   *													PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC		'P'
   *													PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT		'O'
   *													PHPExcel_Calculation_Functions::RETURNDATE_EXCEL			'E'
   * @return	 boolean							Success or failure
   */
  public static function setReturnDateType($returnDateType) {
    if ($returnDateType == self::RETURNDATE_PHP_NUMERIC || $returnDateType == self::RETURNDATE_PHP_OBJECT || $returnDateType == self::RETURNDATE_EXCEL) {
      self::$ReturnDateType = $returnDateType;
      return True;
    }
    return False;
  }

  //	function setReturnDateType()

  /**
   * Return the current Return Date Format for functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object)
   *
   * @access	public
   * @category Function Configuration
   * @return	 string		Return Date Format
   *							Possible Return values are:
   *								PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC		'P'
   *								PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT		'O'
   *								PHPExcel_Calculation_Functions::RETURNDATE_EXCEL			'E'
   */
  public static function getReturnDateType() {
    return self::$ReturnDateType;
  }

  //	function getReturnDateType()

  /**
   * DUMMY
   *
   * @access	public
   * @category Error Returns
   * @return	string	#Not Yet Implemented
   */
  public static function DUMMY() {
    return '#Not Yet Implemented';
  }

  //	function DUMMY()

  /**
   * DIV0
   *
   * @access	public
   * @category Error Returns
   * @return	string	#Not Yet Implemented
   */
  public static function DIV0() {
    return self::$_errorCodes['divisionbyzero'];
  }

  //	function DIV0()

  /**
   * NA
   *
   * Excel Function:
   *		=NA()
   *
   * Returns the error value #N/A
   *		#N/A is the error value that means "no value is available."
   *
   * @access	public
   * @category Logical Functions
   * @return	string	#N/A!
   */
  public static function NA() {
    return self::$_errorCodes['na'];
  }

  //	function NA()

  /**
   * NaN
   *
   * Returns the error value #NUM!
   *
   * @access	public
   * @category Error Returns
   * @return	string	#NUM!
   */
  public static function NaN() {
    return self::$_errorCodes['num'];
  }

  //	function NaN()

  /**
   * NAME
   *
   * Returns the error value #NAME?
   *
   * @access	public
   * @category Error Returns
   * @return	string	#NAME?
   */
  public static function NAME() {
    return self::$_errorCodes['name'];
  }

  //	function NAME()

  /**
   * REF
   *
   * Returns the error value #REF!
   *
   * @access	public
   * @category Error Returns
   * @return	string	#REF!
   */
  public static function REF() {
    return self::$_errorCodes['reference'];
  }

  //	function REF()

  /**
   * NULL
   *
   * Returns the error value #NULL!
   *
   * @access	public
   * @category Error Returns
   * @return	string	#NULL!
   */
  public static function NULL() {
    return self::$_errorCodes['null'];
  }

  //	function NULL()

  /**
   * VALUE
   *
   * Returns the error value #VALUE!
   *
   * @access	public
   * @category Error Returns
   * @return	string	#VALUE!
   */
  public static function VALUE() {
    return self::$_errorCodes['value'];
  }

  //	function VALUE()
  public static function isMatrixValue($idx) {
    return substr_count($idx, '.') <= 1 || preg_match('/\\.[A-Z]/', $idx) > 0;
  }
  public static function isValue($idx) {
    return substr_count($idx, '.') == 0;
  }
  public static function isCellValue($idx) {
    return substr_count($idx, '.') > 1;
  }
  public static function _ifCondition($condition) {
    $condition = PHPExcel_Calculation_Functions::flattenSingleValue($condition);
    if (!isset($condition[0])) {
      $condition = '=""';
    }
    if (!in_array($condition[0], array(
      '>',
      '<',
      '=',
    ))) {
      if (!is_numeric($condition)) {
        $condition = PHPExcel_Calculation::_wrapResult(strtoupper($condition));
      }
      return '=' . $condition;
    }
    else {
      preg_match('/([<>=]+)(.*)/', $condition, $matches);
      list(, $operator, $operand) = $matches;
      if (!is_numeric($operand)) {
        $operand = str_replace('"', '""', $operand);
        $operand = PHPExcel_Calculation::_wrapResult(strtoupper($operand));
      }
      return $operator . $operand;
    }
  }

  //	function _ifCondition()

  /**
   * ERROR_TYPE
   *
   * @param	mixed	$value	Value to check
   * @return	boolean
   */
  public static function ERROR_TYPE($value = '') {
    $value = self::flattenSingleValue($value);
    $i = 1;
    foreach (self::$_errorCodes as $errorCode) {
      if ($value === $errorCode) {
        return $i;
      }
      ++$i;
    }
    return self::NA();
  }

  //	function ERROR_TYPE()

  /**
   * IS_BLANK
   *
   * @param	mixed	$value	Value to check
   * @return	boolean
   */
  public static function IS_BLANK($value = NULL) {
    if (!is_null($value)) {
      $value = self::flattenSingleValue($value);
    }
    return is_null($value);
  }

  //	function IS_BLANK()

  /**
   * IS_ERR
   *
   * @param	mixed	$value	Value to check
   * @return	boolean
   */
  public static function IS_ERR($value = '') {
    $value = self::flattenSingleValue($value);
    return self::IS_ERROR($value) && !self::IS_NA($value);
  }

  //	function IS_ERR()

  /**
   * IS_ERROR
   *
   * @param	mixed	$value	Value to check
   * @return	boolean
   */
  public static function IS_ERROR($value = '') {
    $value = self::flattenSingleValue($value);
    if (!is_string($value)) {
      return false;
    }
    return in_array($value, array_values(self::$_errorCodes));
  }

  //	function IS_ERROR()

  /**
   * IS_NA
   *
   * @param	mixed	$value	Value to check
   * @return	boolean
   */
  public static function IS_NA($value = '') {
    $value = self::flattenSingleValue($value);
    return $value === self::NA();
  }

  //	function IS_NA()

  /**
   * IS_EVEN
   *
   * @param	mixed	$value	Value to check
   * @return	boolean
   */
  public static function IS_EVEN($value = NULL) {
    $value = self::flattenSingleValue($value);
    if ($value === NULL) {
      return self::NAME();
    }
    if (is_bool($value) || is_string($value) && !is_numeric($value)) {
      return self::VALUE();
    }
    return $value % 2 == 0;
  }

  //	function IS_EVEN()

  /**
   * IS_ODD
   *
   * @param	mixed	$value	Value to check
   * @return	boolean
   */
  public static function IS_ODD($value = NULL) {
    $value = self::flattenSingleValue($value);
    if ($value === NULL) {
      return self::NAME();
    }
    if (is_bool($value) || is_string($value) && !is_numeric($value)) {
      return self::VALUE();
    }
    return abs($value) % 2 == 1;
  }

  //	function IS_ODD()

  /**
   * IS_NUMBER
   *
   * @param	mixed	$value		Value to check
   * @return	boolean
   */
  public static function IS_NUMBER($value = NULL) {
    $value = self::flattenSingleValue($value);
    if (is_string($value)) {
      return False;
    }
    return is_numeric($value);
  }

  //	function IS_NUMBER()

  /**
   * IS_LOGICAL
   *
   * @param	mixed	$value		Value to check
   * @return	boolean
   */
  public static function IS_LOGICAL($value = NULL) {
    $value = self::flattenSingleValue($value);
    return is_bool($value);
  }

  //	function IS_LOGICAL()

  /**
   * IS_TEXT
   *
   * @param	mixed	$value		Value to check
   * @return	boolean
   */
  public static function IS_TEXT($value = NULL) {
    $value = self::flattenSingleValue($value);
    return is_string($value) && !self::IS_ERROR($value);
  }

  //	function IS_TEXT()

  /**
   * IS_NONTEXT
   *
   * @param	mixed	$value		Value to check
   * @return	boolean
   */
  public static function IS_NONTEXT($value = NULL) {
    return !self::IS_TEXT($value);
  }

  //	function IS_NONTEXT()

  /**
   * VERSION
   *
   * @return	string	Version information
   */
  public static function VERSION() {
    return 'PHPExcel 1.8.1, 2015-04-30';
  }

  //	function VERSION()

  /**
   * N
   *
   * Returns a value converted to a number
   *
   * @param	value		The value you want converted
   * @return	number		N converts values listed in the following table
   *		If value is or refers to N returns
   *		A number			That number
   *		A date				The serial number of that date
   *		TRUE				1
   *		FALSE				0
   *		An error value		The error value
   *		Anything else		0
   */
  public static function N($value = NULL) {
    while (is_array($value)) {
      $value = array_shift($value);
    }
    switch (gettype($value)) {
      case 'double':
      case 'float':
      case 'integer':
        return $value;
        break;
      case 'boolean':
        return (int) $value;
        break;
      case 'string':

        //	Errors
        if (strlen($value) > 0 && $value[0] == '#') {
          return $value;
        }
        break;
    }
    return 0;
  }

  //	function N()

  /**
   * TYPE
   *
   * Returns a number that identifies the type of a value
   *
   * @param	value		The value you want tested
   * @return	number		N converts values listed in the following table
   *		If value is or refers to N returns
   *		A number			1
   *		Text				2
   *		Logical Value		4
   *		An error value		16
   *		Array or Matrix		64
   */
  public static function TYPE($value = NULL) {
    $value = self::flattenArrayIndexed($value);
    if (is_array($value) && count($value) > 1) {
      $a = array_keys($value);
      $a = array_pop($a);

      //	Range of cells is an error
      if (self::isCellValue($a)) {
        return 16;

        //	Test for Matrix
      }
      elseif (self::isMatrixValue($a)) {
        return 64;
      }
    }
    elseif (empty($value)) {

      //	Empty Cell
      return 1;
    }
    $value = self::flattenSingleValue($value);
    if ($value === NULL || is_float($value) || is_int($value)) {
      return 1;
    }
    elseif (is_bool($value)) {
      return 4;
    }
    elseif (is_array($value)) {
      return 64;
    }
    elseif (is_string($value)) {

      //	Errors
      if (strlen($value) > 0 && $value[0] == '#') {
        return 16;
      }
      return 2;
    }
    return 0;
  }

  //	function TYPE()

  /**
   * Convert a multi-dimensional array to a simple 1-dimensional array
   *
   * @param	array	$array	Array to be flattened
   * @return	array	Flattened array
   */
  public static function flattenArray($array) {
    if (!is_array($array)) {
      return (array) $array;
    }
    $arrayValues = array();
    foreach ($array as $value) {
      if (is_array($value)) {
        foreach ($value as $val) {
          if (is_array($val)) {
            foreach ($val as $v) {
              $arrayValues[] = $v;
            }
          }
          else {
            $arrayValues[] = $val;
          }
        }
      }
      else {
        $arrayValues[] = $value;
      }
    }
    return $arrayValues;
  }

  //	function flattenArray()

  /**
   * Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing
   *
   * @param	array	$array	Array to be flattened
   * @return	array	Flattened array
   */
  public static function flattenArrayIndexed($array) {
    if (!is_array($array)) {
      return (array) $array;
    }
    $arrayValues = array();
    foreach ($array as $k1 => $value) {
      if (is_array($value)) {
        foreach ($value as $k2 => $val) {
          if (is_array($val)) {
            foreach ($val as $k3 => $v) {
              $arrayValues[$k1 . '.' . $k2 . '.' . $k3] = $v;
            }
          }
          else {
            $arrayValues[$k1 . '.' . $k2] = $val;
          }
        }
      }
      else {
        $arrayValues[$k1] = $value;
      }
    }
    return $arrayValues;
  }

  //	function flattenArrayIndexed()

  /**
   * Convert an array to a single scalar value by extracting the first element
   *
   * @param	mixed		$value		Array or scalar value
   * @return	mixed
   */
  public static function flattenSingleValue($value = '') {
    while (is_array($value)) {
      $value = array_pop($value);
    }
    return $value;
  }

}

//	class PHPExcel_Calculation_Functions
//
//	There are a few mathematical functions that aren't available on all versions of PHP for all platforms
//	These functions aren't available in Windows implementations of PHP prior to version 5.3.0
//	So we test if they do exist for this version of PHP/operating platform; and if not we create them
//
if (!function_exists('acosh')) {
  function acosh($x) {
    return 2 * log(sqrt(($x + 1) / 2) + sqrt(($x - 1) / 2));
  }

  //	function acosh()
}
if (!function_exists('asinh')) {
  function asinh($x) {
    return log($x + sqrt(1 + $x * $x));
  }

  //	function asinh()
}
if (!function_exists('atanh')) {
  function atanh($x) {
    return (log(1 + $x) - log(1 - $x)) / 2;
  }

  //	function atanh()
}

//
//	Strangely, PHP doesn't have a mb_str_replace multibyte function
//	As we'll only ever use this function with UTF-8 characters, we can simply "hard-code" the character set
//
if (!function_exists('mb_str_replace') && function_exists('mb_substr') && function_exists('mb_strlen') && function_exists('mb_strpos')) {
  function mb_str_replace($search, $replace, $subject) {
    if (is_array($subject)) {
      $ret = array();
      foreach ($subject as $key => $val) {
        $ret[$key] = mb_str_replace($search, $replace, $val);
      }
      return $ret;
    }
    foreach ((array) $search as $key => $s) {
      if ($s == '' && $s !== 0) {
        continue;
      }
      $r = !is_array($replace) ? $replace : (array_key_exists($key, $replace) ? $replace[$key] : '');
      $pos = mb_strpos($subject, $s, 0, 'UTF-8');
      while ($pos !== false) {
        $subject = mb_substr($subject, 0, $pos, 'UTF-8') . $r . mb_substr($subject, $pos + mb_strlen($s, 'UTF-8'), 65535, 'UTF-8');
        $pos = mb_strpos($subject, $s, $pos + mb_strlen($r, 'UTF-8'), 'UTF-8');
      }
    }
    return $subject;
  }
}

Constants

Name	Description
MAX_ITERATIONS	MAX_ITERATIONS
MAX_VALUE	MAX_VALUE
M_2DIVPI	2 / PI
PRECISION	PRECISION

Classes

Name	Description
PHPExcel_Calculation_Functions	PHPExcel_Calculation_Functions