[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * PHPExcel
   4   *
   5   * Copyright (c) 2006 - 2014 PHPExcel
   6   *
   7   * This library is free software; you can redistribute it and/or
   8   * modify it under the terms of the GNU Lesser General Public
   9   * License as published by the Free Software Foundation; either
  10   * version 2.1 of the License, or (at your option) any later version.
  11   *
  12   * This library is distributed in the hope that it will be useful,
  13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   * Lesser General Public License for more details.
  16   *
  17   * You should have received a copy of the GNU Lesser General Public
  18   * License along with this library; if not, write to the Free Software
  19   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20   *
  21   * @category    PHPExcel
  22   * @package        PHPExcel_Calculation
  23   * @copyright    Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
  24   * @license        http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
  25   * @version        ##VERSION##, ##DATE##
  26   */
  27  
  28  
  29  /** PHPExcel root directory */
  30  if (!defined('PHPEXCEL_ROOT')) {
  31      /**
  32       * @ignore
  33       */
  34      define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
  35      require (PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
  36  }
  37  
  38  
  39  /**
  40   * PHPExcel_Calculation_Logical
  41   *
  42   * @category    PHPExcel
  43   * @package        PHPExcel_Calculation
  44   * @copyright    Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
  45   */
  46  class PHPExcel_Calculation_Logical {
  47  
  48      /**
  49       * TRUE
  50       *
  51       * Returns the boolean TRUE.
  52       *
  53       * Excel Function:
  54       *        =TRUE()
  55       *
  56       * @access    public
  57       * @category Logical Functions
  58       * @return    boolean        True
  59       */
  60  	public static function TRUE() {
  61          return TRUE;
  62      }    //    function TRUE()
  63  
  64  
  65      /**
  66       * FALSE
  67       *
  68       * Returns the boolean FALSE.
  69       *
  70       * Excel Function:
  71       *        =FALSE()
  72       *
  73       * @access    public
  74       * @category Logical Functions
  75       * @return    boolean        False
  76       */
  77  	public static function FALSE() {
  78          return FALSE;
  79      }    //    function FALSE()
  80  
  81  
  82      /**
  83       * LOGICAL_AND
  84       *
  85       * Returns boolean TRUE if all its arguments are TRUE; returns FALSE if one or more argument is FALSE.
  86       *
  87       * Excel Function:
  88       *        =AND(logical1[,logical2[, ...]])
  89       *
  90       *        The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
  91       *            or references that contain logical values.
  92       *
  93       *        Boolean arguments are treated as True or False as appropriate
  94       *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
  95       *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
  96       *            the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
  97       *
  98       * @access    public
  99       * @category Logical Functions
 100       * @param    mixed        $arg,...        Data values
 101       * @return    boolean        The logical AND of the arguments.
 102       */
 103  	public static function LOGICAL_AND() {
 104          // Return value
 105          $returnValue = TRUE;
 106  
 107          // Loop through the arguments
 108          $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
 109          $argCount = -1;
 110          foreach ($aArgs as $argCount => $arg) {
 111              // Is it a boolean value?
 112              if (is_bool($arg)) {
 113                  $returnValue = $returnValue && $arg;
 114              } elseif ((is_numeric($arg)) && (!is_string($arg))) {
 115                  $returnValue = $returnValue && ($arg != 0);
 116              } elseif (is_string($arg)) {
 117                  $arg = strtoupper($arg);
 118                  if (($arg == 'TRUE') || ($arg == PHPExcel_Calculation::getTRUE())) {
 119                      $arg = TRUE;
 120                  } elseif (($arg == 'FALSE') || ($arg == PHPExcel_Calculation::getFALSE())) {
 121                      $arg = FALSE;
 122                  } else {
 123                      return PHPExcel_Calculation_Functions::VALUE();
 124                  }
 125                  $returnValue = $returnValue && ($arg != 0);
 126              }
 127          }
 128  
 129          // Return
 130          if ($argCount < 0) {
 131              return PHPExcel_Calculation_Functions::VALUE();
 132          }
 133          return $returnValue;
 134      }    //    function LOGICAL_AND()
 135  
 136  
 137      /**
 138       * LOGICAL_OR
 139       *
 140       * Returns boolean TRUE if any argument is TRUE; returns FALSE if all arguments are FALSE.
 141       *
 142       * Excel Function:
 143       *        =OR(logical1[,logical2[, ...]])
 144       *
 145       *        The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
 146       *            or references that contain logical values.
 147       *
 148       *        Boolean arguments are treated as True or False as appropriate
 149       *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
 150       *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
 151       *            the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
 152       *
 153       * @access    public
 154       * @category Logical Functions
 155       * @param    mixed        $arg,...        Data values
 156       * @return    boolean        The logical OR of the arguments.
 157       */
 158  	public static function LOGICAL_OR() {
 159          // Return value
 160          $returnValue = FALSE;
 161  
 162          // Loop through the arguments
 163          $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
 164          $argCount = -1;
 165          foreach ($aArgs as $argCount => $arg) {
 166              // Is it a boolean value?
 167              if (is_bool($arg)) {
 168                  $returnValue = $returnValue || $arg;
 169              } elseif ((is_numeric($arg)) && (!is_string($arg))) {
 170                  $returnValue = $returnValue || ($arg != 0);
 171              } elseif (is_string($arg)) {
 172                  $arg = strtoupper($arg);
 173                  if (($arg == 'TRUE') || ($arg == PHPExcel_Calculation::getTRUE())) {
 174                      $arg = TRUE;
 175                  } elseif (($arg == 'FALSE') || ($arg == PHPExcel_Calculation::getFALSE())) {
 176                      $arg = FALSE;
 177                  } else {
 178                      return PHPExcel_Calculation_Functions::VALUE();
 179                  }
 180                  $returnValue = $returnValue || ($arg != 0);
 181              }
 182          }
 183  
 184          // Return
 185          if ($argCount < 0) {
 186              return PHPExcel_Calculation_Functions::VALUE();
 187          }
 188          return $returnValue;
 189      }    //    function LOGICAL_OR()
 190  
 191  
 192      /**
 193       * NOT
 194       *
 195       * Returns the boolean inverse of the argument.
 196       *
 197       * Excel Function:
 198       *        =NOT(logical)
 199       *
 200       *        The argument must evaluate to a logical value such as TRUE or FALSE
 201       *
 202       *        Boolean arguments are treated as True or False as appropriate
 203       *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
 204       *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
 205       *            the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
 206       *
 207       * @access    public
 208       * @category Logical Functions
 209       * @param    mixed        $logical    A value or expression that can be evaluated to TRUE or FALSE
 210       * @return    boolean        The boolean inverse of the argument.
 211       */
 212  	public static function NOT($logical=FALSE) {
 213          $logical = PHPExcel_Calculation_Functions::flattenSingleValue($logical);
 214          if (is_string($logical)) {
 215              $logical = strtoupper($logical);
 216              if (($logical == 'TRUE') || ($logical == PHPExcel_Calculation::getTRUE())) {
 217                  return FALSE;
 218              } elseif (($logical == 'FALSE') || ($logical == PHPExcel_Calculation::getFALSE())) {
 219                  return TRUE;
 220              } else {
 221                  return PHPExcel_Calculation_Functions::VALUE();
 222              }
 223          }
 224  
 225          return !$logical;
 226      }    //    function NOT()
 227  
 228      /**
 229       * STATEMENT_IF
 230       *
 231       * Returns one value if a condition you specify evaluates to TRUE and another value if it evaluates to FALSE.
 232       *
 233       * Excel Function:
 234       *        =IF(condition[,returnIfTrue[,returnIfFalse]])
 235       *
 236       *        Condition is any value or expression that can be evaluated to TRUE or FALSE.
 237       *            For example, A10=100 is a logical expression; if the value in cell A10 is equal to 100,
 238       *            the expression evaluates to TRUE. Otherwise, the expression evaluates to FALSE.
 239       *            This argument can use any comparison calculation operator.
 240       *        ReturnIfTrue is the value that is returned if condition evaluates to TRUE.
 241       *            For example, if this argument is the text string "Within budget" and the condition argument evaluates to TRUE,
 242       *            then the IF function returns the text "Within budget"
 243       *            If condition is TRUE and ReturnIfTrue is blank, this argument returns 0 (zero). To display the word TRUE, use
 244       *            the logical value TRUE for this argument.
 245       *            ReturnIfTrue can be another formula.
 246       *        ReturnIfFalse is the value that is returned if condition evaluates to FALSE.
 247       *            For example, if this argument is the text string "Over budget" and the condition argument evaluates to FALSE,
 248       *            then the IF function returns the text "Over budget".
 249       *            If condition is FALSE and ReturnIfFalse is omitted, then the logical value FALSE is returned.
 250       *            If condition is FALSE and ReturnIfFalse is blank, then the value 0 (zero) is returned.
 251       *            ReturnIfFalse can be another formula.
 252       *
 253       * @access    public
 254       * @category Logical Functions
 255       * @param    mixed    $condition        Condition to evaluate
 256       * @param    mixed    $returnIfTrue    Value to return when condition is true
 257       * @param    mixed    $returnIfFalse    Optional value to return when condition is false
 258       * @return    mixed    The value of returnIfTrue or returnIfFalse determined by condition
 259       */
 260  	public static function STATEMENT_IF($condition = TRUE, $returnIfTrue = 0, $returnIfFalse = FALSE) {
 261          $condition        = (is_null($condition))        ? TRUE :    (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($condition);
 262          $returnIfTrue    = (is_null($returnIfTrue))    ? 0 :        PHPExcel_Calculation_Functions::flattenSingleValue($returnIfTrue);
 263          $returnIfFalse    = (is_null($returnIfFalse))    ? FALSE :    PHPExcel_Calculation_Functions::flattenSingleValue($returnIfFalse);
 264  
 265          return ($condition) ? $returnIfTrue : $returnIfFalse;
 266      }    //    function STATEMENT_IF()
 267  
 268  
 269      /**
 270       * IFERROR
 271       *
 272       * Excel Function:
 273       *        =IFERROR(testValue,errorpart)
 274       *
 275       * @access    public
 276       * @category Logical Functions
 277       * @param    mixed    $testValue    Value to check, is also the value returned when no error
 278       * @param    mixed    $errorpart    Value to return when testValue is an error condition
 279       * @return    mixed    The value of errorpart or testValue determined by error condition
 280       */
 281  	public static function IFERROR($testValue = '', $errorpart = '') {
 282          $testValue    = (is_null($testValue))    ? '' :    PHPExcel_Calculation_Functions::flattenSingleValue($testValue);
 283          $errorpart    = (is_null($errorpart))    ? '' :    PHPExcel_Calculation_Functions::flattenSingleValue($errorpart);
 284  
 285          return self::STATEMENT_IF(PHPExcel_Calculation_Functions::IS_ERROR($testValue), $errorpart, $testValue);
 286      }    //    function IFERROR()
 287  
 288  }    //    class PHPExcel_Calculation_Logical