Skip to content
Snippets Groups Projects
  1. May 18, 2004
  2. May 17, 2004
  3. May 15, 2004
  4. May 14, 2004
  5. May 13, 2004
  6. May 12, 2004
    • rtoy's avatar
      Fix some issues with the complex functions with signed zeroes. See · 3e0a1c82
      rtoy authored
      comment for full details, but the issue is that Lisp says mixing a
      real and a complex requires converting the real to complex before
      doing the operation.  But Kahan's algorithms assume that this doesn't
      happen, like z-1 should not be computed as z-(1+0*i).
      
      One place where this was wrong was for acos(2 +/- 0i).  Kahan says
      acos(2+0i) is +0 - i*acosh(2) and acos(2-0i) is +0 + i*acosh(2).  We
      had this backwards for the above reason.
      
      I think this was caused by the erroneous deftransforms for real op
      complex which were removed sometime ago, causing these function to
      compute the wrong thing.
      3e0a1c82
  7. May 11, 2004
  8. May 10, 2004
  9. May 06, 2004
    • rtoy's avatar
      Add some info about generational GC and some of the functions that can · dcc2fa17
      rtoy authored
      be used to tune it.  (Still needs work.)
      dcc2fa17
    • rtoy's avatar
      Merge in the 19a changes containing Helmut Eller's implementation for · 35ff77d3
      rtoy authored
      source location for defvar and friends.
      35ff77d3
    • rtoy's avatar
      From Helmut Eller: · c5c28c25
      rtoy authored
      the following enters an infinite recursion if it gets compiled two
      times:
      
      (def-alien-type nil (struct foo
      			    (f (* (function (values) (* (struct foo)))))))
      
      During the second compile, the existing type is compared with the to
      be defined type.  This enters a recursion because (struct foo) is
      recursive and the comparison is done again.  The current code has a
      "depth" counter and simply returns true if it exceeds 10.  But it only
      works for pointers to records and loops forever for function pointers.
      
      The patch below should fix this.  It keeps a hashtable of the already
      compared types and returns true if a pair is already in the hashtable.
      c5c28c25
Loading