src/test/regress/expected/complex.out

--
-- complex
--
-- start_ignore
DROP TABLE complex_ttbl;   
ERROR:  table "complex_ttbl" does not exist
DROP SEQUENCE  complex_seq;
ERROR:  sequence "complex_seq" does not exist
-- end_ignore
CREATE SEQUENCE complex_seq CACHE 1;
CREATE TABLE complex_ttbl (id INTEGER NOT NULL DEFAULT 1, orderid INTEGER NOT NULL DEFAULT NEXTVAL('complex_seq'), c COMPLEX) DISTRIBUTED BY (id); 
-- regular input
INSERT INTO complex_ttbl(c) VALUES (' 5');
INSERT INTO complex_ttbl(c) VALUES ('3 ');
INSERT INTO complex_ttbl(c) VALUES (' 6 ');
INSERT INTO complex_ttbl(c) VALUES (' -6 ');
INSERT INTO complex_ttbl(c) VALUES (' 5i');
INSERT INTO complex_ttbl(c) VALUES ('3i ');
INSERT INTO complex_ttbl(c) VALUES (' 6i ');
INSERT INTO complex_ttbl(c) VALUES (' -6i ');
INSERT INTO complex_ttbl(c) VALUES (' 5 + 3i ');
INSERT INTO complex_ttbl(c) VALUES (' 5 + -3i ');
INSERT INTO complex_ttbl(c) VALUES (' 6 - -7i ');
INSERT INTO complex_ttbl(c) VALUES (' -6 - -7i ');
INSERT INTO complex_ttbl(c) VALUES (' 1.2345678901234e+200  - -1.2345678901234e+200i ');
INSERT INTO complex_ttbl(c) VALUES (' -0 + -0i ');
INSERT INTO complex_ttbl(c) VALUES (' -0 - -0i ');
INSERT INTO complex_ttbl(c) VALUES (' -0 - 0i ');
INSERT INTO complex_ttbl(c) VALUES ('9+10i ');
INSERT INTO complex_ttbl(c) VALUES (' 9+10i');
INSERT INTO complex_ttbl(c) VALUES ('9-10i');
-- special input
INSERT INTO COMPLEX_ttbl(c) VALUES ('infinity + infinityi');
INSERT INTO COMPLEX_ttbl(c) VALUES ('infinity - infinityi');
INSERT INTO COMPLEX_ttbl(c) VALUES ('-InFiNity - -infinityi');
INSERT INTO COMPLEX_ttbl(c) VALUES ('-infinity + -InFinItyi');
INSERT INTO COMPLEX_ttbl(c) VALUES ('nan + nani');
INSERT INTO COMPLEX_ttbl(c) VALUES ('nan - nani');
INSERT INTO COMPLEX_ttbl(c) VALUES ('-nan - -NAni');
INSERT INTO COMPLEX_ttbl(c) VALUES ('-nAn + -naNi');
SELECT id, c FROM complex_ttbl ORDER BY orderid;
 id |                      c                       
----+----------------------------------------------
  1 | 5 + 0i
  1 | 3 + 0i
  1 | 6 + 0i
  1 | -6 + 0i
  1 | 0 + 5i
  1 | 0 + 3i
  1 | 0 + 6i
  1 | 0 - 6i
  1 | 5 + 3i
  1 | 5 - 3i
  1 | 6 + 7i
  1 | -6 + 7i
  1 | 1.2345678901234e+200 + 1.2345678901234e+200i
  1 | -0 + -0i
  1 | -0 + 0i
  1 | -0 + -0i
  1 | 9 + 10i
  1 | 9 + 10i
  1 | 9 - 10i
  1 | Infinity + Infinityi
  1 | Infinity - Infinityi
  1 | -Infinity + Infinityi
  1 | -Infinity - Infinityi
  1 | NaN + NaNi
  1 | NaN + NaNi
  1 | NaN + NaNi
  1 | NaN + NaNi
(27 rows)

-- test for underflow and overflow
SELECT COMPLEX '10e400';
ERROR:  "10e400" is out of range for type double precision
LINE 1: SELECT COMPLEX '10e400';
                       ^
SELECT COMPLEX '10e400i';
ERROR:  "10e400i" is out of range for type double precision
LINE 1: SELECT COMPLEX '10e400i';
                       ^
SELECT COMPLEX '-10e400';
ERROR:  "-10e400" is out of range for type double precision
LINE 1: SELECT COMPLEX '-10e400';
                       ^
SELECT COMPLEX '-10e400i';
ERROR:  "-10e400i" is out of range for type double precision
LINE 1: SELECT COMPLEX '-10e400i';
                       ^
SELECT COMPLEX '10e-400';
ERROR:  "10e-400" is out of range for type double precision
LINE 1: SELECT COMPLEX '10e-400';
                       ^
SELECT COMPLEX '10e-400i';
ERROR:  "10e-400i" is out of range for type double precision
LINE 1: SELECT COMPLEX '10e-400i';
                       ^
SELECT COMPLEX '-10e-400';
ERROR:  "-10e-400" is out of range for type double precision
LINE 1: SELECT COMPLEX '-10e-400';
                       ^
SELECT COMPLEX '-10e-400i';
ERROR:  "-10e-400i" is out of range for type double precision
LINE 1: SELECT COMPLEX '-10e-400i';
                       ^
-- bad input  
INSERT INTO complex_ttbl(c) VALUES ('');
ERROR:  invalid input syntax for type complex: ""
LINE 1: INSERT INTO complex_ttbl(c) VALUES ('');
                                            ^
INSERT INTO complex_ttbl(c) VALUES ('    ');
ERROR:  invalid input syntax for type complex: "    "
LINE 1: INSERT INTO complex_ttbl(c) VALUES ('    ');
                                            ^
INSERT INTO complex_ttbl(c) VALUES ('xyi');
ERROR:  invalid input syntax for type complex: "xyi"
LINE 1: INSERT INTO complex_ttbl(c) VALUES ('xyi');
                                            ^
INSERT INTO complex_ttbl(c) VALUES ('i'); 
ERROR:  invalid input syntax for type complex: "i"
LINE 1: INSERT INTO complex_ttbl(c) VALUES ('i');
                                            ^
INSERT INTO complex_ttbl(c) VALUES ('5.0.0 + 1i'); 
ERROR:  invalid input syntax for type complex: "5.0.0 + 1i"
LINE 1: INSERT INTO complex_ttbl(c) VALUES ('5.0.0 + 1i');
                                            ^
INSERT INTO complex_ttbl(c) VALUES ('5.0 + 1 i');  
ERROR:  invalid input syntax for type complex: "5.0 + 1 i"
LINE 1: INSERT INTO complex_ttbl(c) VALUES ('5.0 + 1 i');
                                            ^
INSERT INTO complex_ttbl(c) VALUES ('5.0 + i1');    
ERROR:  invalid input syntax for type complex: "i1"
LINE 1: INSERT INTO complex_ttbl(c) VALUES ('5.0 + i1');
                                            ^
-- re
SELECT re(COMPLEX(5, 3)) AS five;
 five 
------
    5
(1 row)

SELECT re(COMPLEX(-5, 3)) AS minus_five;
 minus_five 
------------
         -5
(1 row)

SELECT re(COMPLEX(5.1, 3)) AS five_point_one;
 five_point_one 
----------------
            5.1
(1 row)

SELECT re(COMPLEX(-5.1, 3))  AS minus_five_point_one;
 minus_five_point_one 
----------------------
                 -5.1
(1 row)

SELECT re(COMPLEX('infinity', 3)) AS inf;
   inf    
----------
 Infinity
(1 row)

SELECT re(COMPLEX('-infinity', 3)) AS minus_inf;
 minus_inf 
-----------
 -Infinity
(1 row)

SELECT re(COMPLEX('nan', 3)) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT re(COMPLEX('-nan', 3)) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT re(COMPLEX('nan', 3)) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT re(COMPLEX('-nan', 3)) AS nan;
 nan 
-----
 NaN
(1 row)

-- im
SELECT im(COMPLEX(5, 3)) AS three;
 three 
-------
     3
(1 row)

SELECT im(COMPLEX(5, -3)) AS minus_three;
 minus_three 
-------------
          -3
(1 row)

SELECT im(COMPLEX(5, 3.1)) AS three_point_1;
 three_point_1 
---------------
           3.1
(1 row)

SELECT im(COMPLEX(5, -3.1)) AS minus_three_point_1;
 minus_three_point_1 
---------------------
                -3.1
(1 row)

SELECT im(COMPLEX(5, 'infinity')) AS inf;
   inf    
----------
 Infinity
(1 row)

SELECT im(COMPLEX(5, '-infinity')) AS minus_inf;
 minus_inf 
-----------
 -Infinity
(1 row)

SELECT im(COMPLEX(5, 'nan')) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT im(COMPLEX(5, '-nan')) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT im(COMPLEX(5, 'nan')) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT im(COMPLEX(5, '-nan')) AS nan;
 nan 
-----
 NaN
(1 row)

-- abs
SELECT abs(COMPLEX(4, 3)) AS five;
 five 
------
    5
(1 row)

SELECT abs(COMPLEX(4, -3)) AS five;
 five 
------
    5
(1 row)

SELECT abs(COMPLEX(-4, 3)) AS five;
 five 
------
    5
(1 row)

SELECT abs(COMPLEX(-4, -3)) AS five;
 five 
------
    5
(1 row)

SELECT abs(COMPLEX('infinity', 3)) AS inf;
   inf    
----------
 Infinity
(1 row)

SELECT abs(COMPLEX('-infinity', 3)) AS inf;
   inf    
----------
 Infinity
(1 row)

SELECT abs(COMPLEX(5, 'infinity')) AS inf;
   inf    
----------
 Infinity
(1 row)

SELECT abs(COMPLEX(5, '-infinity')) AS inf;
   inf    
----------
 Infinity
(1 row)

SELECT abs(COMPLEX('infinity', 'infinity')) AS inf;
   inf    
----------
 Infinity
(1 row)

SELECT abs(COMPLEX('nan', 3)) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT abs(COMPLEX('-nan', 3))  AS nan;
 nan 
-----
 NaN
(1 row)

SELECT abs(COMPLEX(5, 'nan'))  AS nan;
 nan 
-----
 NaN
(1 row)

SELECT abs(COMPLEX(5, '-nan'))  AS nan;
 nan 
-----
 NaN
(1 row)

SELECT abs(COMPLEX('nan', 'nan'))  AS nan;
 nan 
-----
 NaN
(1 row)

SELECT abs(COMPLEX('infinity', 'nan')) AS inf;
   inf    
----------
 Infinity
(1 row)

SELECT abs(COMPLEX('nan', 'infinity')) AS inf;
   inf    
----------
 Infinity
(1 row)

-- radians
SELECT abs(radians(COMPLEX(1, sqrt(3))) - pi()/3) < 1e-6 AS tr;
 tr 
----
 t
(1 row)

SELECT abs(radians(COMPLEX(1, -sqrt(3))) + pi()/3) < 1e-6 AS tr;
 tr 
----
 t
(1 row)

SELECT abs(radians(COMPLEX(-1, sqrt(3))) - pi()*2/3) < 1e-6 AS tr;
 tr 
----
 t
(1 row)

SELECT abs(radians(COMPLEX(-1, -sqrt(3))) + pi()*2/3) < 1e-6 AS tr;
 tr 
----
 t
(1 row)

SELECT radians(COMPLEX('infinity', 3)) AS zero;
 zero 
------
    0
(1 row)

SELECT abs(radians(COMPLEX('-infinity', 3)) - pi()) < 1e-6 AS tr;
 tr 
----
 t
(1 row)

SELECT abs(radians(COMPLEX(5, 'infinity')) - pi()/2) < 1e-6 AS tr;
 tr 
----
 t
(1 row)

SELECT abs(radians(COMPLEX(5, '-infinity')) + pi()/2) < 1e-6 AS tr;
 tr 
----
 t
(1 row)

SELECT abs(radians(COMPLEX('infinity', 'infinity')) - pi()*45/180) < 1e-6 AS tr;
 tr 
----
 t
(1 row)

SELECT radians(COMPLEX('nan', 3)) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT radians(COMPLEX('-nan', 3)) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT radians(COMPLEX(5, 'nan')) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT radians(COMPLEX(5, '-nan')) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT radians(COMPLEX('nan', 'nan')) AS nan; 
 nan 
-----
 NaN
(1 row)

SELECT radians(COMPLEX('infinity', 'nan')) AS nan;
 nan 
-----
 NaN
(1 row)

SELECT radians(COMPLEX('nan', 'infinity')) AS nan;
 nan 
-----
 NaN
(1 row)

-- conj
SELECT conj(COMPLEX(5, 3)) = (COMPLEX(5,-3)) AS tr;
 tr 
----
 t
(1 row)

SELECT conj(COMPLEX(5, -3)) = (COMPLEX(5,3)) AS tr;
 tr 
----
 t
(1 row)

SELECT conj(COMPLEX(5, 3.1)) = (COMPLEX(5,-3.1)) AS tr;
 tr 
----
 t
(1 row)

SELECT conj(COMPLEX(5, -3.1)) = (COMPLEX(5,3.1)) AS tr;
 tr 
----
 t
(1 row)

SELECT conj(COMPLEX(5, 'infinity')) = (COMPLEX(5,'-infinity')) AS tr;
 tr 
----
 t
(1 row)

SELECT conj(COMPLEX(5, '-infinity')) = (COMPLEX(5,'infinity')) AS tr;
 tr 
----
 t
(1 row)

SELECT conj(COMPLEX(5, 'nan')) = (COMPLEX(5,'nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT conj(COMPLEX(5, '-nan')) = (COMPLEX(5,'nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT conj(COMPLEX(5, 'nan')) = (COMPLEX(5,'nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT conj(COMPLEX(5, '-nan')) = (COMPLEX(5,'nan')) AS tr;
 tr 
----
 t
(1 row)

-- hashcomplex
SELECT hashcomplex(COMPLEX(0,0)) = hashcomplex(COMPLEX(0,-0)) AS tr;
 tr 
----
 t
(1 row)

SELECT hashcomplex(COMPLEX(0,0)) = hashcomplex(COMPLEX(-0,0)) AS tr;
 tr 
----
 t
(1 row)

SELECT hashcomplex(COMPLEX(0,0)) = hashcomplex(COMPLEX(-0,-0)) AS tr;
 tr 
----
 t
(1 row)

-- not equal
SELECT NOT c != c AS tr FROM complex_ttbl;
 tr 
----
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
(27 rows)

-- unary plus
SELECT +(COMPLEX(5, 3)) = (COMPLEX(5, 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(-5, 3)) = (COMPLEX(-5, 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5.1, 3)) = (COMPLEX(5.1, 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(-5.1, 3)) = (COMPLEX(-5.1, 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX('infinity', 3)) = (COMPLEX('infinity', 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX('-infinity', 3)) = (COMPLEX('-infinity', 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX('nan', 3)) = (COMPLEX('nan', 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX('-nan', 3)) = (COMPLEX('-nan', 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX('nan', 3)) = (COMPLEX('-nan', 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX('-nan', 3)) = (COMPLEX('nan', 3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, 3)) = (COMPLEX(5,3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, -3)) = (COMPLEX(5,-3)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, 3.1)) = (COMPLEX(5,3.1)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, -3.1)) = (COMPLEX(5,-3.1)) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, 'infinity')) = (COMPLEX(5,'infinity')) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, '-infinity')) = (COMPLEX(5,'-infinity')) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, 'nan')) = (COMPLEX(5,'nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, '-nan')) = (COMPLEX(5,'-nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, 'nan')) = (COMPLEX(5,'-nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT +(COMPLEX(5, '-nan')) = (COMPLEX(5,'nan')) AS tr;
 tr 
----
 t
(1 row)

-- unary minus
SELECT -(COMPLEX(5, 3)) = (COMPLEX(-5, -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX(-5, 3)) = (COMPLEX(5, -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX(5.1, 3)) = (COMPLEX(-5.1, -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX(-5.1, 3)) = (COMPLEX(5.1, -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX('infinity', 3)) = (COMPLEX('-infinity', -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX('-infinity', 3)) = (COMPLEX('infinity', -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX('nan', 3)) = (COMPLEX('nan', -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX('-nan', 3)) = (COMPLEX('nan', -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX('nan', 3)) = (COMPLEX('nan', -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX('-nan', 3)) = (COMPLEX('nan', -3)) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX(5, 'infinity')) = (COMPLEX(-5,'-infinity')) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX(5, '-infinity')) = (COMPLEX(-5,'infinity')) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX(5, 'nan')) = (COMPLEX(-5,'nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX(5, '-nan')) = (COMPLEX(-5,'nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX(5, 'nan')) = (COMPLEX(-5,'nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT -(COMPLEX(5, '-nan')) = (COMPLEX(-5,'nan')) AS tr;
 tr 
----
 t
(1 row)

SELECT c + -c = COMPLEX(0,0) 
	FROM complex_ttbl 
	WHERE re(c) <> FLOAT8 'nan' AND im(c) <> FLOAT8 'nan' AND abs(re(c)) <> FLOAT8 'infinity' AND abs(im(c)) <> FLOAT8 'infinity';
 ?column? 
----------
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
 t
(19 rows)

-- plus
SELECT COMPLEX(3, 5) + COMPLEX(6, 7) = COMPLEX(9,12) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'infinity') + COMPLEX(6, 7) = COMPLEX(9, 'infinity') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('infinity', 5) + COMPLEX(6, 7) = COMPLEX('infinity', 12) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, '-infinity') + COMPLEX(6, 7) = COMPLEX(9, '-infinity') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('-infinity', 5) + COMPLEX(6, 7) = COMPLEX('-infinity', 12) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'nan') + COMPLEX(6, 7) = COMPLEX(9, 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('nan', 5) + COMPLEX(6, 7) = COMPLEX('nan', 12) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, '-nan') + COMPLEX(6, 7) = COMPLEX(9, 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('-nan', 5) + COMPLEX(6, 7) = COMPLEX('nan', 12) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'nan') + COMPLEX(6, 'infinity') = COMPLEX(9, 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('nan', 5) + COMPLEX('infinity', 7) = COMPLEX('nan', 12) AS tr;
 tr 
----
 t
(1 row)

-- minus
SELECT COMPLEX(3, 5) - COMPLEX(6, 7) = COMPLEX(-3, -2) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'infinity') - COMPLEX(6, 7) = COMPLEX(-3, 'infinity') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('infinity', 5) - COMPLEX(6, 7) = COMPLEX('infinity', -2) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, '-infinity') - COMPLEX(6, 7) = COMPLEX(-3, '-infinity') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('-infinity', 5) - COMPLEX(6, 7) = COMPLEX('-infinity', -2) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'nan') - COMPLEX(6, 7) = COMPLEX(-3, 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('nan', 5) - COMPLEX(6, 7) = COMPLEX('nan', -2) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, '-nan') - COMPLEX(6, 7) = COMPLEX(-3, 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('-nan', 5) - COMPLEX(6, 7) = COMPLEX('nan', -2) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'nan') - COMPLEX(6, 'infinity') = COMPLEX(-3, 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('nan', 5) - COMPLEX('infinity', 7) = COMPLEX('nan', -2) AS tr;
 tr 
----
 t
(1 row)

-- multiply
SELECT COMPLEX(3, 5) * COMPLEX(6, 7) = COMPLEX(-17, 51) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'infinity') * COMPLEX(6, 7) = COMPLEX('-infinity', 'infinity') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('infinity', 5) * COMPLEX(6, 7) = COMPLEX('infinity', 'infinity') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, '-infinity') * COMPLEX(6, 7) = COMPLEX('infinity', '-infinity') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('-infinity', 5) * COMPLEX(6, 7) = COMPLEX('-infinity', '-infinity') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'nan') * COMPLEX(6, 7) = COMPLEX('nan', 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('nan', 5) * COMPLEX(6, 7) = COMPLEX('nan', 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, '-nan') * COMPLEX(6, 7) = COMPLEX('nan', 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('-nan', 5) * COMPLEX(6, 7) = COMPLEX('nan', 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'nan') * COMPLEX(6, 'infinity') = COMPLEX('nan', 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('nan', 5) * COMPLEX('infinity', 7) = COMPLEX('nan', 'nan') AS tr;
 tr 
----
 t
(1 row)

-- divide
CREATE OR REPLACE FUNCTION complex_dp_eq(a COMPLEX, b COMPLEX, diff FLOAT8) RETURNS BOOLEAN AS $$
BEGIN
	RETURN (abs(re(a) - re(b)) < diff) AND (abs(im(a) - im(b)) < diff);
END;
$$ LANGUAGE PLPGSQL IMMUTABLE STRICT;
SELECT COMPLEX(2,2)/COMPLEX(1,1) = COMPLEX(2,0) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'infinity') / COMPLEX(6, 7) = COMPLEX('infinity', 'infinity') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(3, 'nan') / COMPLEX(6, 7) = COMPLEX('nan', 'nan') AS tr;
 tr 
----
 t
(1 row)

-- for division the denominator is special
SELECT COMPLEX(3, 5) / COMPLEX('infinity', 7) = COMPLEX('NaN','NaN') AS tr;
 tr 
----
 t
(1 row)

-- divived by 0, python not supported divided by zero, and different version of glibc have different behavior
SELECT COMPLEX(5,3)/COMPLEX(0,0) = COMPLEX('nan', 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX('infinity',3)/COMPLEX(0,0) = COMPLEX('nan', 'nan') AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(5,'nan')/COMPLEX(0,0) = COMPLEX('infinity', 'nan') AS tr;
 tr 
----
 t
(1 row)

-- @
SELECT @(COMPLEX(5,3)) = abs(COMPLEX(5,3)) AS tr;
 tr 
----
 t
(1 row)

-- pow and ^
SELECT complex_dp_eq(COMPLEX(1,sqrt(3))^3 , COMPLEX(-1*2^3, 0), 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(COMPLEX(0.5, 0.5*sqrt(3))^0.5, COMPLEX(0.5*sqrt(3), 0.5), 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(5,3)^0 = COMPLEX(1,0) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(COMPLEX(5,3)^(-0.5) , COMPLEX(1,0)/(COMPLEX(5,3)^0.5), 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(COMPLEX(5,3)^(-3) , COMPLEX(1,0)/COMPLEX(5,3)^3, 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(COMPLEX(5,3)^COMPLEX(3,5), COMPLEX(-7.04464, -11.27606), 1e-5) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(5^COMPLEX(3,5), COMPLEX(-24.00101, 122.67416), 1e-5) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(5,3)^COMPLEX(3,5) = power(COMPLEX(5,3), COMPLEX(3,5)) AS tr;
 tr 
----
 t
(1 row)

SELECT (-1)^0.5 AS wrong;
ERROR:  a negative number raised to a non-integer power yields a complex result
SELECT power(-1, 0.5) AS wrong;
ERROR:  a negative number raised to a non-integer power yields a complex result
SELECT complex_dp_eq(power(-1::COMPLEX, 0.5), COMPLEX(0, -1), 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(power(COMPLEX(-1, 0), 0.5), COMPLEX(0,1), 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(power('-1 + -0i'::COMPLEX, 0.5), COMPLEX(0, -1), 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(power('-1 - 0i'::COMPLEX, 0.5), COMPLEX(0, -1), 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(power('-1 + 0i'::COMPLEX, 0.5), COMPLEX(0,1), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- sqrt
SELECT sqrt(COMPLEX(5,3)) = power(COMPLEX(5,3), 0.5) AS tr;
 tr 
----
 t
(1 row)

-- cbrt
SELECT cbrt(COMPLEX(5,3)) = power(COMPLEX(5,3), (1.0/3)) AS tr;
 tr 
----
 t
(1 row)

-- degrees
SELECT degrees(COMPLEX(5,3)) = degrees(radians(COMPLEX(5,3))) AS tr;
 tr 
----
 t
(1 row)

-- exp
SELECT complex_dp_eq(exp(COMPLEX(5,3)), COMPLEX(-146.927913908319 , 20.944066208746), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- ln
SELECT complex_dp_eq(ln(COMPLEX(5,3)), COMPLEX(1.76318026230808 , 0.540419500270584), 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT complex_dp_eq(exp(ln(COMPLEX(5,3))), COMPLEX(5,3), 1e-6) AS tr;
 tr 
----
 t
(1 row)

SELECT ln(0::COMPLEX) = COMPLEX('-infinity', 0) AS tr;
 tr 
----
 t
(1 row)

-- log10
SELECT complex_dp_eq(log(COMPLEX(5,3)) , ln(COMPLEX(5,3))/ln(10), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- log
SELECT complex_dp_eq(log(COMPLEX(3,5),COMPLEX(5,3)) , ln(COMPLEX(5,3))/ln(COMPLEX(3,5)), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- acos
SELECT complex_dp_eq(acos(COMPLEX(5,3)), COMPLEX(0, -1)*ln(COMPLEX(5,3) + COMPLEX(0,1)*sqrt(1 - COMPLEX(5,3)^2)), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- asin
SELECT complex_dp_eq(asin(COMPLEX(5,3)), COMPLEX(0, -1)*ln(COMPLEX(5,3)*COMPLEX(0,1) + sqrt(1 - COMPLEX(5,3)^2)), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- atan
SELECT complex_dp_eq(atan(COMPLEX(5,3)), 0.5*COMPLEX(0,1)*(ln(1 - COMPLEX(5,3)*COMPLEX(0,1)) - ln(1 + COMPLEX(5,3)*COMPLEX(0,1))), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- cos
SELECT complex_dp_eq(cos(COMPLEX(5,3)), COMPLEX( 2.85581500422739 , 9.60638344843258), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- sin
SELECT complex_dp_eq(sin(COMPLEX(5,3)), COMPLEX(-9.65412547685484 , 2.84169229560635), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- cot
SELECT complex_dp_eq(cot(COMPLEX(5,3)), cos(COMPLEX(5,3))/sin(COMPLEX(5,3)), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- tan
SELECT complex_dp_eq(tan(COMPLEX(5,3)), sin(COMPLEX(5,3))/cos(COMPLEX(5,3)), 1e-6) AS tr;
 tr 
----
 t
(1 row)

-- type cast
SELECT COMPLEX '5+3i' ^ 4::int2 = power(COMPLEX(5,3),4::COMPLEX) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX '5+3i' ^ 4::INT4 = power(COMPLEX(5,3),4::COMPLEX) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX '5+3i' ^ 4::INT8 = power(COMPLEX(5,3),4::COMPLEX) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX '5+3i' ^ 4 		= power(COMPLEX(5,3),4::COMPLEX) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX '5+3i' ^ 4.5::FLOAT4 = power(COMPLEX(5,3),COMPLEX(4.5,0)) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX '5+3i' ^ 4.5::FLOAT8 = power(COMPLEX(5,3),COMPLEX(4.5,0)) AS tr;
 tr 
----
 t
(1 row)

SELECT COMPLEX(5,4)::POINT = POINT(5,4) AS tr;
ERROR:  operator does not exist: point = point
LINE 1: SELECT COMPLEX(5,4)::POINT = POINT(5,4) AS tr;
                                   ^
HINT:  No operator matches the given name and argument type(s). You might need to add explicit type casts.
SELECT POINT(5,4)::COMPLEX = COMPLEX(5,4) AS tr;
 tr 
----
 t
(1 row)

-- clear up
DROP TABLE complex_ttbl;
DROP SEQUENCE complex_seq;
DROP FUNCTION complex_dp_eq(a COMPLEX, b COMPLEX, diff FLOAT8);
-- check hashable
CREATE SEQUENCE complex_seq CACHE 1;
CREATE TABLE complex_ttbl (id INT4 DEFAULT NEXTVAL('complex_seq'), c COMPLEX) DISTRIBUTED BY (c);
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(NEXTVAL('complex_seq'), NEXTVAL('complex_seq')));
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(NEXTVAL('complex_seq'), NEXTVAL('complex_seq')));
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(NEXTVAL('complex_seq'), NEXTVAL('complex_seq')));
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(NEXTVAL('complex_seq'), NEXTVAL('complex_seq')));
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(NEXTVAL('complex_seq'), NEXTVAL('complex_seq')));
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(NEXTVAL('complex_seq'), NEXTVAL('complex_seq')));
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(0, 0));
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(0, -0));
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(-0, 0));
INSERT INTO complex_ttbl(c) VALUES (COMPLEX(-0, -0));
SELECT * FROM complex_ttbl ORDER BY id;
 id |    c     
----+----------
  1 | 2 + 3i
  4 | 5 + 6i
  7 | 8 + 9i
 10 | 11 + 12i
 13 | 14 + 15i
 16 | 17 + 18i
 19 | 0 + 0i
 20 | 0 + 0i
 21 | 0 + 0i
 22 | 0 + 0i
(10 rows)

SELECT COUNT(c) = 4 AS tr, COUNT(DISTINCT gp_segment_id) = 1 AS tr 
	FROM complex_ttbl 
	WHERE re(c) = 0 AND im(c) = 0;
 tr | tr 
----+----
 t  | t
(1 row)

-- Use a complex in GROUP BY, to test the hash function used in hash agg.
set enable_groupagg = off;
SELECT c, count(*) FROM complex_ttbl GROUP BY c;
    c     | count 
----------+-------
 0 + 0i   |     4
 11 + 12i |     1
 14 + 15i |     1
 17 + 18i |     1
 2 + 3i   |     1
 5 + 6i   |     1
 8 + 9i   |     1
(7 rows)

reset enable_groupagg;
DROP TABLE complex_ttbl;
DROP SEQUENCE complex_seq;
-- dot product
SELECT dotproduct(ARRAY[COMPLEX(1,3),COMPLEX(5,7)], ARRAY[COMPLEX(2,4),COMPLEX(6,8)]) = COMPLEX(1,3)*COMPLEX(2,4) + COMPLEX(5,7)*COMPLEX(6,8) AS tr;
 tr 
----
 t
(1 row)

SELECT dotproduct(ARRAY[COMPLEX(1,3),COMPLEX(5,7)], ARRAY[COMPLEX(2,4),NULL]) IS NULL AS tr;
 tr 
----
 t
(1 row)

SELECT dotproduct(ARRAY[COMPLEX(1,3),COMPLEX(5,7)], ARRAY[COMPLEX(2,4),COMPLEX(6,8), COMPLEX(10,12)]);
ERROR:  cannot dot product two 1-dim arrays with different number of elements
DETAIL:  The number of elements of the left argument is 2, the number of elements of the right argument is 3.
SELECT dotproduct(ARRAY[COMPLEX(1,3),COMPLEX(5,7)], ARRAY[ARRAY[COMPLEX(2,4)],ARRAY[COMPLEX(6,8)]]);
ERROR:  cannot dot product two multi-dimentsion arrays
DETAIL:  The dimension of the left argument is 1, the dimension of the right argument is 2.
-- GIN index on complex array
CREATE TABLE complex_array_tab (complex_arr complex[]);
CREATE INDEX ON complex_array_tab USING gin (complex_arr);
INSERT INTO complex_array_tab VALUES (ARRAY[COMPLEX(1,3), COMPLEX(5,7)]);
INSERT INTO complex_array_tab VALUES (ARRAY[COMPLEX(2,4), COMPLEX(6,8)]);
SELECT * FROM complex_array_tab WHERE complex_arr @> ARRAY[COMPLEX(2,4)];
     complex_arr     
---------------------
 {"2 + 4i","6 + 8i"}
(1 row)