# Re: limit function

This page is part of the web mail archives of SRFI 70 from before July 7th, 2015. The new archives for SRFI 70 contain all messages, not just those from before July 7th, 2015.

```>  | >  | Thereby all functions will be legitimately valued at all points
>  | >  | with no need of ambiguous value representation, however who's
>  | >  | value may be more precisely determined at a specific limit through
>  | >  | the use of a limit macro as desired.
>  | >  |
>  | >  | Thereby hypothetically: (presuming sufficient numerical precision)
>  | >  |
>  | >  | (tan pi/2) => 0
>  | >  | (limit (lambda (x) (tan x)) (pi/2 -0/1)) => +1/0
>  | >  | (limit (lambda (x) (tan x)) (pi/2 +0/1)) => -1/0
>  | >  |
>  | >  | (+ 4. (/ (abs 0) 0)) => 4.0
>  | >  | (limit (lambda (x) (+ 4. (/ (abs x) x))) (0 -0/1)) => 3.0
>  | >  | (limit (lambda (x) (+ 4. (/ (abs x) x))) (0 +0/1)) => 5.0
>  | >
>  | > LIMIT already handles these cases correctly.  But I am unconvinced
>  | > that a procedure can automatically pick the evaluation points given
>  | > no information about the test function.
>  |
>  | - it seems fairly straight foreword to for +-0/1 to imply the use
>  | of the smallest value representable by an implementation as the
>  | delta value in it's calculation of a limit value its argument's
>  | value?
>
> That doesn't work in general.  Intermediate quantities in a
> calculation can overflow or underflow if the delta is too small.
>
> (define (func x) (expt (+ (/ x) (exp (/ x)) (exp (/ 2 x))) x))
>
> ;;The mathematically correct answer is e^2 = 7.3890560989306504:
>
> (limit func 0 1/40) ==> 7.3890560989306504
> (limit func 0 1/41) ==> #i0/0
> (limit func 0 1/42) ==> #f
> (limit func 0 1/43) ==> #i+/0
> (limit func 0 1/444) ==> #i+/0
> (limit func 0 1e-323) ==> #i+/0

- Yup.  However, I don't believe attempting to guess haphazardly, as
implied is required using the proposed limit function, is reasonable.

Given that the precision about any value is known in a given inexact
implementation, and correspondingly so is the resolvable domain of all
primitive functions; it seems reasonable to define a macro that is able
to determine the delta about an arbitrary point given an arbitrary
composite function, which represents the minimum deviation about that
point which should not corrupt the result due to a intermediate overflow
if possible.

Possibly something along the line of [using macro's as the expression
argument needs to be parsed to determine it's reverse operation order]:

(delta <expression> (<variable> <value>))  => <min-delta-value>

Such that hypothetically:

(delta- a (b c)) :: (- c (delta a (b c))
(delta+ a (b c)) :: (+ c (delta a (b c))
(delta x (x 0)) :: (* (+ (abs x) 1e-290) 1e-10)) => 1e-300
(delta (exp (/ x)) (x 0)) :: (/ (abs (log (delta x (x 0)))) => 0.00145..
...

Where then:

(limit  <expression> (<variable> <value>)) => <mean-limit>
(limit- <expression> (<variable> <value>)) => <lower-limit>
(limit+ <expression> (<variable> <value>)) => <upper-limit>

may compute the limit by automatically deriving a delta based upon
the composite expression directly. Where if given for example:

(expt (exp (/ x)) x) ; which otherwise yields +inf at 0, due to overflow.

It's lower (and/or upper or mean) limit may then be accurately computed:

(limit- (expt (exp (/ x)) x) (x 0)) ::
(let ((x (delta- (expt (exp (/ x)) x) (x 0))))) (expt (exp (/ x)) x)) ::
(let ((x -0.00145..)) (expt (exp (/ x)) x)) => 2.718..

```