You are here

Home » API reference » Loft Data Grids 7.2 » Functions.php

class PHPExcel_Calculation_Functions in Loft Data Grids 7.2

Same name and namespace in other branches
  1. 6.2 vendor/phpoffice/phpexcel/Classes/PHPExcel/Calculation/Functions.php \PHPExcel_Calculation_Functions

PHPExcel_Calculation_Functions

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

Hierarchy

Expanded class hierarchy of PHPExcel_Calculation_Functions

13 string references to 'PHPExcel_Calculation_Functions'
FunctionsTest::testERROR_TYPE in vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/FunctionsTest.php
@dataProvider providerERROR_TYPE
FunctionsTest::testIS_BLANK in vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/FunctionsTest.php
@dataProvider providerIS_BLANK
FunctionsTest::testIS_ERR in vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/FunctionsTest.php
@dataProvider providerIS_ERR
FunctionsTest::testIS_ERROR in vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/FunctionsTest.php
@dataProvider providerIS_ERROR
FunctionsTest::testIS_EVEN in vendor/phpoffice/phpexcel/unitTests/Classes/PHPExcel/Calculation/FunctionsTest.php
@dataProvider providerIS_EVEN

... See full list

File

vendor/phpoffice/phpexcel/Classes/PHPExcel/Calculation/Functions.php, line 59

View source 
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;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
PHPExcel_Calculation_Functions::$compatibilityMode protected static property * Compatibility mode to use for error checking and responses * * @access private *
PHPExcel_Calculation_Functions::$ReturnDateType protected static property * Data Type to use when returning date values * * @access private *
PHPExcel_Calculation_Functions::$_errorCodes protected static property * List of error codes * * @access private *
PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL constant constants
PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC constant
PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE constant
PHPExcel_Calculation_Functions::DIV0 public static function * DIV0 * * @access public * @category Error Returns *
PHPExcel_Calculation_Functions::DUMMY public static function * DUMMY * * @access public * @category Error Returns *
PHPExcel_Calculation_Functions::ERROR_TYPE public static function * ERROR_TYPE * *
PHPExcel_Calculation_Functions::flattenArray public static function * Convert a multi-dimensional array to a simple 1-dimensional array * *
PHPExcel_Calculation_Functions::flattenArrayIndexed public static function * Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing * *
PHPExcel_Calculation_Functions::flattenSingleValue public static function * Convert an array to a single scalar value by extracting the first element * *
PHPExcel_Calculation_Functions::getCompatibilityMode public static function * Return the current Compatibility Mode * * @access public * @category Function Configuration *
PHPExcel_Calculation_Functions::getReturnDateType public static function * 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 *
PHPExcel_Calculation_Functions::isCellValue public static function
PHPExcel_Calculation_Functions::isMatrixValue public static function
PHPExcel_Calculation_Functions::isValue public static function
PHPExcel_Calculation_Functions::IS_BLANK public static function * IS_BLANK * *
PHPExcel_Calculation_Functions::IS_ERR public static function * IS_ERR * *
PHPExcel_Calculation_Functions::IS_ERROR public static function * IS_ERROR * *
PHPExcel_Calculation_Functions::IS_EVEN public static function * IS_EVEN * *
PHPExcel_Calculation_Functions::IS_LOGICAL public static function * IS_LOGICAL * *
PHPExcel_Calculation_Functions::IS_NA public static function * IS_NA * *
PHPExcel_Calculation_Functions::IS_NONTEXT public static function * IS_NONTEXT * *
PHPExcel_Calculation_Functions::IS_NUMBER public static function * IS_NUMBER * *
PHPExcel_Calculation_Functions::IS_ODD public static function * IS_ODD * *
PHPExcel_Calculation_Functions::IS_TEXT public static function * IS_TEXT * *
PHPExcel_Calculation_Functions::N public static function * N * * Returns a value converted to a number * *
PHPExcel_Calculation_Functions::NA public static function * 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 *
PHPExcel_Calculation_Functions::NAME public static function * NAME * * Returns the error value #NAME? * * @access public * @category Error Returns *
PHPExcel_Calculation_Functions::NaN public static function * NaN * * Returns the error value #NUM! * * @access public * @category Error Returns *
PHPExcel_Calculation_Functions::NULL public static function * NULL * * Returns the error value #NULL! * * @access public * @category Error Returns *
PHPExcel_Calculation_Functions::REF public static function * REF * * Returns the error value #REF! * * @access public * @category Error Returns *
PHPExcel_Calculation_Functions::RETURNDATE_EXCEL constant
PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC constant
PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT constant
PHPExcel_Calculation_Functions::setCompatibilityMode public static function * Set the Compatibility Mode * * @access public * @category Function Configuration *
PHPExcel_Calculation_Functions::setReturnDateType public static function * 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 *
PHPExcel_Calculation_Functions::TYPE public static function * TYPE * * Returns a number that identifies the type of a value * *
PHPExcel_Calculation_Functions::VALUE public static function * VALUE * * Returns the error value #VALUE! * * @access public * @category Error Returns *
PHPExcel_Calculation_Functions::VERSION public static function * VERSION * *
PHPExcel_Calculation_Functions::_ifCondition public static function