/var/www/hkosl.com/imusiccircle/webadmin/libraies/phpoffice/phpexcel/unitTests/custom/Complex.php


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
<?php

class Complex {

    private 
$realPart 0;
    private 
$imaginaryPart 0;
    private 
$suffix NULL;

    public static function 
_parseComplex($complexNumber)
    {
        
//    Test for real number, with no imaginary part
        
if (is_numeric($complexNumber))
            return array( 
$complexNumber0NULL );

        
//    Fix silly human errors
        
if (strpos($complexNumber,'+-') !== FALSE)
            
$complexNumber str_replace('+-','-',$complexNumber);
        if (
strpos($complexNumber,'++') !== FALSE)
            
$complexNumber str_replace('++','+',$complexNumber);
        if (
strpos($complexNumber,'--') !== FALSE)
            
$complexNumber str_replace('--','-',$complexNumber);

        
//    Basic validation of string, to parse out real and imaginary parts, and any suffix
        
$validComplex preg_match('/^([\-\+]?(\d+\.?\d*|\d*\.?\d+)([Ee][\-\+]?[0-2]?\d{1,3})?)([\-\+]?(\d+\.?\d*|\d*\.?\d+)([Ee][\-\+]?[0-2]?\d{1,3})?)?(([\-\+]?)([ij]?))$/ui',$complexNumber,$complexParts);

        if (!
$validComplex) {
            
//    Neither real nor imaginary part, so test to see if we actually have a suffix
            
$validComplex preg_match('/^([\-\+]?)([ij])$/ui',$complexNumber,$complexParts);
            if (!
$validComplex) {
                throw new 
Exception('COMPLEX: Invalid complex number');
            }
            
//    We have a suffix, so set the real to 0, the imaginary to either 1 or -1 (as defined by the sign)
            
$imaginary 1;
            if (
$complexParts[1] === '-') {
                
$imaginary $imaginary;
            }
            return array(
0$imaginary$complexParts[2]);
        }

        
//    If we don't have an imaginary part, identify whether it should be +1 or -1...
        
if (($complexParts[4] === '') && ($complexParts[9] !== '')) {
            if (
$complexParts[7] !== $complexParts[9]) {
                
$complexParts[4] = 1;
                if (
$complexParts[8] === '-') {
                    
$complexParts[4] = -1;
                }
            
//    ... or if we have only the real and no imaginary part (in which case our real should be the imaginary)
            
} else {
                
$complexParts[4] = $complexParts[1];
                
$complexParts[1] = 0;
            }
        }

        
//    Return real and imaginary parts and suffix as an array, and set a default suffix if user input lazily
        
return array( $complexParts[1],
                      
$complexParts[4],
                      !empty(
$complexParts[9]) ? $complexParts[9] : 'i'
                    
);
    }    
//    function _parseComplex()


    
public function __construct($realPart$imaginaryPart null$suffix 'i')
    {
        if (
$imaginaryPart === null) {
            if (
is_array($realPart)) {
                
//    We have an array of (potentially) real and imaginary parts, and any suffix
                
list ($realPart$imaginaryPart$suffix) = array_values($realPart) + array(0.00.0'i');
            } elseif((
is_string($realPart)) || (is_numeric($realPart))) {
                
//    We've been given a string to parse to extract the real and imaginary parts, and any suffix
                
list ($realPart$imaginaryPart$suffix) = self::_parseComplex($realPart);
            }
        }

        
//    Set parsed values in our properties
        
$this->realPart = (float) $realPart;
        
$this->imaginaryPart = (float) $imaginaryPart;
        
$this->suffix strtolower($suffix);
    }

    public function 
getReal()
    {
        return 
$this->realPart;
    }

    public function 
getImaginary()
    {
        return 
$this->imaginaryPart;
    }

    public function 
getSuffix()
    {
        return 
$this->suffix;
    }

    public function 
__toString() {
        
$str "";
        if (
$this->imaginaryPart != 0.0) {
            if (
abs($this->imaginaryPart) != 1.0) {
                
$str .= $this->imaginaryPart $this->suffix;
            } else {
                
$str .= (($this->imaginaryPart 0.0) ? '-' ''). $this->suffix;
            }
        }
        if (
$this->realPart != 0.0) {
            if ((
$str) && ($this->imaginaryPart 0.0))
                
$str "+" $str;
            
$str $this->realPart $str;
        }
        if (!
$str)
            
$str "0.0";
        return 
$str;
    }

}