From: nma@12000.org   
      
   On 9/3/2022 11:25 PM, Jeff Barnett wrote:   
      
   Hello again:   
      
   > I would either   
   > give the system a fail because it is unreliable on that problem   
      
   Sorry, I do not understand the above. Suppose it returns some   
   antiderivative on one call. How is the program supposed to be it   
   failed or not?   
      
   The program has no verification on the anti-derivative that it satisfies   
   the integral. It just checkes the result and looks to see if the number of   
   terms that were not integrated is zero or not to decide if it was   
   able to integrate it fully or not.   
      
   > or I   
   > would test it for, say, a 100 or so seeds and give the number (a   
   > percent) that it gets correct.   
      
      
   So you are saying to run the same integral 100 times, each with different seed   
   (say 1,2,3,4....,100 ?) saving all the results, then do histogram and   
   pick the anti-derivative that shows up the most frequent?   
      
   And if they are all different, what to do? Say it failed or pick one by random?   
      
   Sure, I could do that, but the time this will take will be prohibitive.   
      
   I have 12,500 integrals (picked out of 85,500 integrals, since Julia can   
   only do univariate ones with constant coefficients).   
      
   Lets say each call to integrate takes 25 seconds on average (I do   
   not have the average for Julia yet as the tests are still running, it   
   could be more  or it could be much more) but looking at the terminal   
   now, some are more and some less. So have to wait to find   
   out what the average is.   
      
   Using 25 seconds per on call, this will result in 31,250,000 seconds or   
   about one year to finish just the Julia test.  So it is not practical   
   for me to do such a setup. Doing parallel processing is beyond what   
   I can do on my PC.   
      
   So I think using one seed, as long as it is documented what it is, and   
   the result is reproducible can be considered as a compromise.   
      
   This is until Julia obtains an standard symbolic integrator. I read   
   somewhere that they are working on doing that for the future.   
      
   The fact that you had to search for a   
   > seed that led to correct behavior voids the system's ability for that   
   > example. It might be that you could find a seed for each problem in the   
   > test suite that leads to correct behavior for the problem. But that   
   > doesn't make the system perfect.   
   >   
   > Basically when you are testing a system that uses a "probabilistic"   
   > approach, you need to develop scoring methods that account for that fact.   
      
   --Nasser   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)