Unsound complex `exp` optimization

[samth]

(exp (log (make-polar 1.7976931348623153e+308 -1.797693134862315e+308)))

produces -8.648665413126592e+306-1.7956115019091953e+308i in Racket but -inf.0-inf.0i after Typed Racket optimization. Optimized code is:

(let-values (((g3)                                        
                    (#%app                                      
                     log                                        
                     (let-values (((g6) '1.7976931348623153e+308))                                                              
                       (let-values (((g7) '-1.797693134862315e+308))                                                            
                         (let-values (((unboxed-real-8)                                                                         
                                       (#%app                   
                                        unsafe-fl*              
                                        g6                      
                                        (#%app unsafe-flcos g7))))                                                              
                           (let-values (((unboxed-imag-9)                                                                       
                                         (#%app                 
                                          unsafe-fl*            
                                          g6                    
                                          (#%app unsafe-flsin g7))))                                                            
                             (#%app                                                                                             
                              unsafe-make-flrectangular         
                              unboxed-real-8                    
                              unboxed-imag-9))))))))            
        (let-values (((unboxed-real-4) (#%app unsafe-flreal-part g3)))                                                          
          (let-values (((unboxed-imag-5) (#%app unsafe-flimag-part g3)))                                                        
            (let-values (((unboxed-scaling-12)                  
                          (#%app unsafe-flexp unboxed-real-4))) 
              (let-values (((unboxed-real-10)                   
                            (#%app                              
                             unsafe-fl*                                                                                         
                             (#%app unsafe-flcos unboxed-imag-5)                                                                
                             unboxed-scaling-12)))              
                (let-values (((unboxed-imag-11)                 
                              (#%app                            
                               unsafe-fl*                                                                                       
                               (#%app unsafe-flsin unboxed-imag-5)                                                              
                               unboxed-scaling-12)))                                                                            
                  (#%app                                        
                   unsafe-make-flrectangular                    
                   unboxed-real-10                              
                   unboxed-imag-11))))))

Disabling the optimization of complex exp might be the right thing.

Originally found here: http://drdr.racket-lang.org/55300/cs/racket/share/pkgs/typed-racket-test/tr-random-testing.rkt

[mfelleisen]

That would be too bad. It produced a good speedup in some benchmarks, no?

[samth]

I don't think exp was used in those benchmarks. The big problem is that people have been working hard to improve the accuracy of math functions on complex numbers, and keeping Typed Racket in line with that is hard.

[bdeket]

I think this has more to do with a difference how the internal (cs)exp function works than with improvement that were made to complex number functions in racket.

Probably CS calculates the real/imag parts of the result as +/-(exp (+/- rp (log (sin/cos ip)))). That's also the reason that cs can calculate values that land outside the circle with radius +max.0. BC on the other hand uses (* (exp rp) (sin/cos ip), as did the optimization.

ie: CS: (exp (log 1.3e308+1.3e308i)) ~= 1.3e308+1.3e308i where on BC this gives +inf.0+inf.0i (the max value in this direction would be 1.27e308+1.27e308i

Note also that the test value used in your example works without problem on BC in both typed and untyped since the real part of the log calculated in BC is one ulp lower than in CS.

To bring everything in line, BC and the optimized typed code should do something like this:

(define (myexp z)
  (define r (real-part z))
  (define i (imag-part z))
  (define ci (cos i))
  (define si (sin i))
  (cond
    [(< r 709.7827128933841)
     (define e (exp r))
     (make-rectangular
      (* e ci)
      (* e si))]
    [else
     (define lci (log (abs ci)))
     (define lsi (log (abs si)))
     (make-rectangular
      (* (if (< ci 0) -1 1) (exp (+ r lci)))
      (* (if (< si 0) -1 1) (exp (+ r lsi))))]))

The plot's I made and the values I tested seem to suggest this is exactly what (cs)exp does.