[kaffe] Re: kaffe Digest, Vol 31, Issue 7

[Sakur]

Hi,


>
>    1. Can you tell me the arithmetic's theory (douchuan)
>
>
>
> hi
>    I don't know what does the arithmetic say!
>    The result from a is 1000, then the result from b is 6.
>    I have optimized a system for a long time, but i find out i must
> optimize all aspects, just a aspect isn't work.
>    I want to know arithmetic's theory.
>
>
>    a.
>         long endPoints = (1000 + 1000 + 1000 + 1000 + 1000) / 5;
>         if(endPoints > 6208L)
>             endPoints = 6208L;
>         long halfEndPoints = endPoints / 2L;
>         long l2 = endPoints - halfEndPoints;
>         long l3 = 1L;
>         l3 = 1000L*1000L*1000L*1000L*1000L;
>
>         f(l3 != 0L)
>             while(halfEndPoints > 0L)
>             {
>                 if(l2 * l2 * l2 * l2 * l2 > l3)
>                     endPoints = l2;
>                 else
>                     halfEndPoints /= 2L;
>                 l2 = endPoints - halfEndPoints;
>             }
>         else
>             endPoints = 0L;
>
>         System.out.println("endPoints: " + endPoints);
>
>
>
>         result :  1000


      The long type takes 64bits ,about 10^19 . Therefore there's no
overflow.
      I could see a  limit arithmetic computation from this program:
       Assume  endpoints = a ; halfendpoints = a/(2^n) (n -> Infinite)
      Obvious,from the arithmetic view, halfendpoints would be evalued as
lim halfendpoints (n->Infinite). Then the arithmetic hardware might finally
compute halfendpoints as 0 (divition computation is somehow platform
dependent) . Therefore ,endPoints would be 1000.

b.
>
>                long endPoints = (6000 + 1 + 1 + 1 + 1) / 5;
>         if(endPoints > 6208L)
>             endPoints = 6208L;
>         long halfEndPoints = endPoints / 2L;
>         long l2 = endPoints - halfEndPoints;
>         long l3 = 1L;
>         l3 = 6000L*1L*1L*1L*1L;
>
>         f(l3 != 0L)
>             while(halfEndPoints > 0L)
>             {
>                 if(l2 * l2 * l2 * l2 * l2 > l3)
>                     endPoints = l2;
>                 else
>                     halfEndPoints /= 2L;
>                 l2 = endPoints - halfEndPoints;
>             }
>         else
>             endPoints = 0L;
>
>         System.out.println("endPoints: " + endPoints);
>
>
>
>         result : 6


  Similiar to the first program:
  Assume endPoints = a , halfEndPoints = a/(2^n) (n->Infinite),in the
previous program,endPoints keeps invariable,here in this case,both endPoints
and halfEndPoints are variable.
         We can easily get the boudary value of l2 for "if(l2 * l2 * l2 * l2
* l2 > l3)" ,x^5 > l3 , the minimum value for x is 6. (5^5 < 6000,6^5 >
6000).
         That means the program result would be no more than 6. Meaningwhile
,in the loop body,l2 = a  - a/(2^n) (n->Infinite, a = l2 | l2^5>l3).
Through some analysis of the loop itself,we could find the endpoint "a "
would be decoupled every two loop turn. So let a = v/2^t (t is the turn
counts,v is our initial endpoints ,600).  l2 = v/2^t - (v/2^t) / (2^n)  ( l2
<= 6 is our desired result). Now we could compute  600/2^t - (600/2^t)/(2^n)
<= 6.  Since n tends to be infinite,we now get 600/2^t <= 6. We could know
the t value. Therefore,finally, the l2 value is 6, and then endPoints is 6,
then we get the result 6.
       Sorry, I could not describe this process clearly enough.  This
program result might vary when the hardware rounding algorithm varies.


  This is my view towards your questions.pls tell me if I made some
mistakes. thanks.

Cheers
Sakur
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://kaffe.org/pipermail/kaffe/attachments/20061213/f7e0852b/attachment-0004.htm