Special Value Specification for VML

Complex Functions 

v?Abs(z)
v?Acos(z)
v?Acosh(z)
v?Add(z1,z2)
v?Asin(z)
v?Asinh(z)
v?Atan(z)
v?Atanh(z)
v?CIS(x)
v?Conj(z)
v?Cos(z)
v?Cosh(z)
v?Div(z1,z2)
v?Exp(z)
v?Ln(z)
v?Log10(z)
v?Mul(z1,z2)
v?MulByConj(z1,z2)
v?Pow(z1,z2)
v?Powx(z1,z2)
v?Sin(z)
v?Sinh(z)
v?Sqrt(z)
v?Sub(z1,z2)
v?Tan(z)
v?Tanh(z)

Notes:
The ? sign in a function name indicates the data type (s, d, c, z).
In the tables below, X and Y are non-zero positive finite floating point numbers.
Imaginary unit is i, i2=-1.
RE(z) is real part of z.
IM(z) is imaginary part of z.
CONJ(X+i*Y)=X-i*Y.
CIS(Y)=Cos(Y)+i*Sin(Y).
For each complex function which takes one argument, special value specification is presented in a separate table below.                                          
The argument z for the function is defined by RE(z)+i*IM(z).                                        
The result of function on the argument z can be found in the cell on intersection of RE(z) column and IM(z) line.
If the function raises exception on the argument z, the lower part of this cell shows the raised exception.
Empty cell means that this argument is not special and the result is defined mathematically.
                                                 
v?Abs(z)                                                  
    The function and special values specification for it is defined according to the formula Abs(z)=Hypot(RE(z),IM(z)).                                          
                                                                            
                                                 
v?Acos(z)                                                
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN
+ i * INF +3*Pi/4-i*INF +Pi/2-i*INF +Pi/2-i*INF +Pi/2-i*INF +Pi/2-i*INF +Pi/4-i*INF QNAN-i*INF
               
+ i * Y +Pi-i*INF         +0-i*INF QNAN+i*QNAN
               
+ i * 0 +Pi-i*INF   +Pi/2-i*0 +Pi/2-i*0   +0-i*INF QNAN+i*QNAN
               
- i * 0 +Pi+i*INF   +Pi/2+i*0 +Pi/2+i*0   +0+i*INF QNAN+i*QNAN
               
- i * Y +Pi+i*INF         +0+i*INF QNAN+i*QNAN
               
+ i * INF +3*Pi/4+i*INF +Pi/2+i*INF +Pi/2+i*INF +Pi/2+i*INF +Pi/2+i*INF +Pi/4+i*INF QNAN+i*INF
               
+ i * NAN QNAN+i*INF QNAN+i*QNAN +Pi/2+i*QNAN +Pi/2+i*QNAN QNAN+i*QNAN QNAN+i*INF QNAN+i*QNAN
               
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN                                            
    2) does not change ERROR CODE                                                
    3) Acos(CONJ(z))=CONJ(Acos(z))                                              
                                                 
v?Acosh(z)                                                  
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                          
+ i * INF +INF+i*3*Pi/4 +INF+i*Pi/2 +INF+i*Pi/2 +INF+i*Pi/2 +INF+i*Pi/2 +INF+i*Pi/4 +INF+i*QNAN                          
                                         
+ i * Y +INF+i*Pi         +INF+i*0 QNAN+i*QNAN                          
                                         
+ i * 0 +INF+i*Pi   +0+i*Pi/2 +0+i*Pi/2   +INF+i*0 QNAN+i*QNAN                          
                                         
- i * 0 +INF-i*Pi   +0-i*Pi/2 +0-i*Pi/2   +INF-i*0 QNAN+i*QNAN                          
                                         
- i * Y +INF-i*Pi         +INF-i*0 QNAN+i*QNAN                          
                                         
+ i * INF +INF-i*3*Pi/4 +INF-i*Pi/2 +INF-i*Pi/2 +INF-i*Pi/2 +INF-i*Pi/2 +INF-i*Pi/4 +INF+i*QNAN                          
                                         
+ i * NAN +INF+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                          
                                         
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN                                            
    2) does not change ERROR CODE                                                
    3) Acosh(CONJ(z))=CONJ(Acosh(z))                                            
                                                 
v?Add(z1,z2)                                            
    The function and special values specification for it is defined according to the formula Add(X1+i*Y1,X2+i*Y2) = (X1+X2) + i*(Y1+Y2).                                          
                                                 
                                                 
v?Asin(z)                                                  
    The function and special values specification for it is defined according to the formula Asin(z)=-i*Asinh(i*z).                                          
                                                 
v?Asinh(z)                                                  
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                                    
+ i * INF -INF+i*Pi/4 -INF+i*Pi/2 -INF+i*Pi/2 +INF+i*Pi/2 +INF+i*Pi/2 +INF+i*Pi/4 +INF+i*QNAN                                    
                                                   
+ i * Y -INF+i*0         +INF+i*0 QNAN+i*QNAN                                    
                                                   
+ i * 0 -INF+i*0   -0+i*0 +0+i*0   +INF+i*0 QNAN+i*0                                    
                                                   
- i * 0 -INF-i*0   -0-i*0 +0-i*0   +INF-i*0 QNAN-i*0                                    
                                                   
- i * Y -INF-i*0         +INF-i*0 QNAN+i*QNAN                                    
                                                   
- i * INF -INF-i*Pi/4 -INF-i*Pi/2 -INF-i*Pi/2 +INF-i*Pi/2 +INF-i*Pi/2 +INF-i*Pi/4 +INF+i*QNAN                                    
                                                   
+ i * NAN -INF+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
                                                   
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN                                        
    2) does not change ERROR CODE                                        
    3) Asinh(CONJ(z))=CONJ(Asinh(z))                                        
    4) Asinh(-z)=-Asinh(z)                                                
                                                 
v?Atan(z)                                                  
    The function and special values specification for it is defined according to the formula
Atan(z)=-i*Atanh(i*z).
                                     
                                                 
v?Atanh(z)                                                
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                                    
+ i * INF -0+i*Pi/2 -0+i*Pi/2 -0+i*Pi/2 +0+i*Pi/2 +0+i*Pi/2 +0+i*Pi/2 +0+i*Pi/2                                    
                                                   
+ i * Y -0+i*Pi/2         +0+i*P/2 QNAN+i*QNAN                                    
                                                   
+ i * 0 -0+i*Pi/2   -0+i*0 +0+i*0   +0+i*Pi/2 QNAN+i*QNAN                                    
                                                   
- i * 0 -0-i*Pi/2   -0-i*0 +0-i*0   +0-i*Pi/2 QNAN+i*QNAN                                    
                                                   
- i * Y -0-i*Pi/2         +0-i*Pi/2 QNAN+i*QNAN                                    
                                                   
- i * INF -0-i*Pi/2 -0-i*Pi/2 -0-i*Pi/2 +0-i*Pi/2 +0-i*Pi/2 +0-i*Pi/2 +0-i*Pi/2                                    
                                                   
+ i * NAN -0+i*QNAN QNAN+i*QNAN -0+i*QNAN +0+i*QNAN QNAN+i*QNAN +0+i*QNAN QNAN+i*QNAN                                    
                                                   
Notes:                                                  
    1) Atanh(+-1+-i*0)=+-INF+-i*0, and ZERODIVIDE exception is raised                                          
    2) raises INVALID exception when real or imaginary part of the argument is SNAN                                      
    3) does not change ERROR CODE                                            
    4) Atanh(CONJ(z))=CONJ(Atanh(z))                                            
    5) Atanh(-z)=-Atanh(z)                                            
                                                 
v?CIS(x)                                                
x CIS(x)                                                
+ INF QNAN+i*QNAN                                                
  INVALID                                                
+ 0 +1+i*0                                                
                                                   
- 0 +1-i*0                                                
                                                   
- INF QNAN+i*QNAN                                                
  INVALID                                                
NAN QNAN+i*QNAN                                                
                                                   
Notes:                                                  
    1) raises INVALID exception when the argument is SNAN                                          
    2) raises INVALID exception and sets ERROR CODE to VML_STATUS_ERRDOM for x=+INF, x=-INF.                                          
                                     
                                             
                                                 
v?Conj(z)                                                  
    No special values are specified. The function does not raise floating-point exceptions.                                          
                                                 
                                                 
v?Cos(z)                                                  
    The function and special values specification for it is defined according to the formula Cos(z)=Cosh(i*z).
                                                 
v?Cosh(z)                                                
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                                    
+ i * INF +INF+i*QNAN QNAN+i*QNAN QNAN-i*0 QNAN+i*0 QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
  INVALID INVALID INVALID INVALID INVALID INVALID                                      
+ i * Y +INF*Cos(Y)-i*INF*Sin(Y)         +INF*CIS(Y) QNAN+i*QNAN                                    
                                                   
+ i * 0 +INF-i*0   +1-i*0 +1+i*0   +INF+i*0 QNAN+i*0                                    
                                                   
- i * 0 +INF+i*0   +1+i*0 +1-i*0   +INF-i*0 QNAN-i*0                                    
                                                   
- i * Y +INF*Cos(Y)-i*INF*Sin(Y)         +INF*CIS(Y) QNAN+i*QNAN                                    
                                                   
- i * INF +INF+i*QNAN QNAN+i*QNAN QNAN+i*0 QNAN-i*0 QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
  INVALID INVALID INVALID INVALID INVALID INVALID                                      
+ i * NAN +INF+i*QNAN QNAN+i*QNAN QNAN+i*0 QNAN-i*0 QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
                                                   
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN                                          
    2) does not change ERROR CODE                                          
    3) Cosh(CONJ(z))=CONJ(Cosh(z))                                      
    4) Cosh(-z)=Cosh(z)                                              
                                                 
v?Div(z1,z2)                                                  
    The function and special values specification for it is defined according to the formula
Div(X1+i*Y1,X2+i*Y2) = (X1+i*Y1)*(X2-i*Y2)/(X2*X2+Y2*Y2).
                                         
                                                 
                                                 
v?Exp(z)                                                
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                                    
+ i * INF +0+i*0 QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
    INVALID INVALID INVALID INVALID INVALID                                      
+ i * Y +0*CIS(Y)         +INF*CIS(Y) QNAN+i*QNAN                                    
                                                   
+ i * 0 +0*CIS(0)   +1+i*0 +1+i*0   +INF+i*0 QNAN+i*0                                    
                                                   
- i * 0 +0*CIS(0)   +1-i*0 +1-i*0   +INF-i*0 QNAN-i*0                                    
                                                   
- i * Y +0*CIS(Y)         +INF*CIS(Y) QNAN+i*QNAN                                    
                                                   
- i * INF +0-i*0 QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
    INVALID INVALID INVALID INVALID INVALID                                      
+ i * NAN +0+i*0 QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
    INVALID INVALID INVALID INVALID                                        
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN                                        
    2) raises INVALID exception on argument z=-INF+i*QNAN
    3) does not change ERROR CO                                      
                                                 
v?Ln(z)                                                  
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                                    
+ i * INF +INF+i*3*Pi/4 +INF+i*Pi/2 +INF+i*Pi/2 +INF+i*Pi/2 +INF+i*Pi/2 +INF+i*Pi/4 +INF+i*QNAN                                    
                                                   
+ i * Y +INF+i*Pi         +INF+i*0 QNAN+i*QNAN                                    
              INVALID                                    
+ i * 0 +INF+i*Pi   -INF+i*Pi -INF+i*0   +INF+i*0 QNAN+i*QNAN                                    
      ZERODIVIDE ZERODIVIDE     INVALID                                    
- i * 0 +INF-i*Pi   -INF-i*Pi -INF-i*0   +INF-i*0 QNAN+i*QNAN                                    
      ZERODIVIDE ZERODIVIDE     INVALID                                    
- i * Y +INF-i*Pi         +INF-i*0 QNAN+i*QNAN                                    
              INVALID                                    
- i * INF +INF-i*3*Pi/4 +INF-i*Pi/2 +INF-i*Pi/2 +INF-i*Pi/2 +INF-i*Pi/2 +INF-i*Pi/4 +INF+i*QNAN                                    
                                                   
+ i * NAN +INF+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
    INVALID INVALID INVALID INVALID                                        
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN                                        
    2) does not change ERROR CODE                                          
                                                 
v?Log10(z)                                                  
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                                    
+ i * INF +INF+i*3*Pi/4/Ln(10) +INF+i*Pi/2/Ln(10) +INF+i*Pi/2/Ln(10) +INF+i*Pi/2/Ln(10) +INF+i*Pi/2/Ln(10) +INF+i*Pi/4/Ln(10) +INF+i*QNAN                                    
                                                   
+ i * Y +INF+i*Pi/Ln(10)         +INF+i*0 QNAN+i*QNAN                                    
              INVALID                                    
+ i * 0 +INF+i*Pi/Ln(10)   -INF+i*Pi/Ln(10) -INF+i*0   +INF+i*0 QNAN+i*QNAN                                    
      ZERODIVIDE ZERODIVIDE     INVALID                                    
- i * 0 +INF-i*Pi/Ln(10)   -INF-i*Pi/Ln(10) -INF-i*0   +INF-i*0 QNAN+i*QNAN                                    
      ZERODIVIDE ZERODIVIDE     INVALID                                    
- i * Y +INF-i*Pi/Ln(10)         +INF-i*0 QNAN+i*QNAN                                    
              INVALID                                    
- i * INF +INF-i*3*Pi/4/Ln(10) +INF-i*Pi/2/Ln(10) +INF-i*Pi/2/Ln(10) +INF-i*Pi/2/Ln(10) +INF-i*Pi/2/Ln(10) +INF-i*Pi/4/Ln(10) +INF+i*QNAN                                    
                                                   
+ i * NAN +INF+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
    INVALID INVALID INVALID INVALID                                        
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN                                        
    2) does not change ERROR CODE
                                                 
v?Mul(z1,z2)                                                  
    The function and special values specification for it is defined according to the formula
Mul(X1+i*Y1,X2+i*Y2) = (X1*X2-Y1*Y2) + i*(X1*Y2+Y1*X2).
                                         
                                                 
                                                 
v?MulByConj(z1,z2)                                                  
    The function and special values specification for it is defined according to the formula
MulByConj(X1+i*Y1,X2+i*Y2) = Mul(X1+i*Y1,X2-i*Y2).
                                         
                                                 
                                                 
v?Pow(z1,z2), v?Powx(z1,z2)                                              
    The special values specification is not defined.                                            
                                                 
v?Sin(z)                                                  
    The function and special values specification for it is defined according to the formula Sin(z)=-i*Sinh(i*z).
                                                 
v?Sinh(z)                                                  
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                                    
+ i * INF -INF+i*QNAN QNAN+i*QNAN -0+i*QNAN +0+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
  INVALID INVALID INVALID INVALID INVALID INVALID                                      
+ i * Y -INF*Cos(Y)+i*INF*Sin(Y)         +INF*CIS(Y) QNAN+i*QNAN                                    
                                                   
+ i * 0 -INF+i*0   -0+i*0 +0+i*0   +INF+i*0 QNAN+i*0                                    
                                                   
- i * 0 -INF-i*0   -0-i*0 +0-i*0   +INF-i*0 QNAN-i*0                                    
                                                   
- i * Y -INF*Cos(Y)+i*INF*Sin(Y)         +INF*CIS(Y) QNAN+i*QNAN                                    
                                                   
- i * INF -INF+i*QNAN QNAN+i*QNAN -0+i*QNAN +0+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
  INVALID INVALID INVALID INVALID INVALID INVALID                                      
+ i * NAN -INF+i*QNAN QNAN+i*QNAN -0+i*QNAN +0+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
                                                   
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN                                      
    2) does not change ERROR CODE                                      
    3) Sinh(CONJ(z))=CONJ(Sinh(z))                                            
    4) Sinh(-z)=-Sinh(z)                                                
                                                 
v?Sqrt(z)                                                  
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                                    
+ i * INF +INF+i*INF +INF+i*INF +INF+i*INF +INF+i*INF +INF+i*INF +INF+i*INF +INF+i*INF                                    
                                                   
+ i * Y +0+i*INF         +INF+i*0 QNAN+i*QNAN                                    
                                                   
+ i * 0 +0+i*INF   +0+i*0 +0+i*0   +INF+i*0 QNAN+i*QNAN                                    
                                                   
- i * 0 +0-i*INF   +0-i*0 +0-i*0   +INF-i*0 QNAN+i*QNAN                                    
                                                   
- i * Y +0-i*INF         +INF-i*0 QNAN+i*QNAN                                    
                                                   
- i * INF +INF-i*INF +INF-i*INF +INF-i*INF +INF-i*INF +INF-i*INF +INF-i*INF +INF-i*INF                                    
                                                   
+ i * NAN QNAN+i*INF QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +INF+i*QNAN QNAN+i*QNAN                                    
                                                   
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN
    2) does not change ERROR CODE
    3) Sqrt(CONJ(z))=CONJ(Sqrt(z))                                      
                                                 
v?Sub(z1,z2)                                                  
    The function and special values specification for it is defined according to the formula
Sub(X1+i*Y1,X2+i*Y2) = (X1-X2) + i*(Y1-Y2).
                                         
                                                 
                                                 
v?Tan(z)                                                  
    The function and special values specification for it is defined according to the formula Tan(z)=-i*Tanh(i*z).
                                                 
v?Tanh(z)                                                  
IM(z)\
RE(z)
-INF -X -0 +0 +X +INF NAN                                    
+ i * INF -1+i*0 QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +1+i*0 QNAN+i*QNAN                                    
    INVALID INVALID INVALID INVALID                                        
+ i * Y -1+i*0*Tan(Y)         +1+i*0*Tan(Y) QNAN+i*QNAN                                    
                                                   
+ i * 0 -1+i*0   -0+i*0 +0+i*0   +1+i*0 QNAN+i*0                                    
                                                   
- i * 0 -1-i*0   -0-i*0 +0-i*0   +1-i*0 QNAN-i*0                                    
                                                   
- i * Y -1+i*0*Tan(Y)         +1+i*0*Tan(Y) QNAN+i*QNAN                                    
                                                   
- i * INF -1-i*0 QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +1-i*0 QNAN+i*QNAN                                    
    INVALID INVALID INVALID INVALID                                        
+ i * NAN -1+i*0 QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN QNAN+i*QNAN +1+i*0 QNAN+i*QNAN                                    
                                                   
Notes:                                                  
    1) raises INVALID exception when real or imaginary part of the argument is SNAN
    2) does not change ERROR CODE
    3) Tanh(CONJ(z))=CONJ(Tanh(z))
    4) Tanh(-z)=-Tanh(z)                                        

 

Legal Information

Copyright © 2000-2008, Intel Corporation. All Rights Reserved.