home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #27 / NN_1992_27.iso / spool / sci / math / symbolic / 3037 < prev    next >
Encoding:
Text File  |  1992-11-19  |  8.2 KB  |  221 lines
  1. Newsgroups: sci.math.symbolic
  2. Path: sparky!uunet!pipex!warwick!bham!ibm3090.bham.ac.uk!PEARCES
  3. From: PEARCES@IBM3090.BHAM.AC.UK
  4. Subject: Re: Eliminating zeroes ...MAPLE
  5. Sender: usenet@rs6000.bham.ac.uk (USENET News Service)
  6. Message-ID: <924419124443@ibm3090.bham.ac.uk>
  7. Date: Thu, 19 Nov 1992 12:44:43 GMT
  8. Organization: The University of Birmingham, United Kingdom
  9. Lines: 210
  10.  
  11. Newsgroups: sci.math.symbolic
  12. Path: bham!warwick!pipex!bnr.co.uk!bnrgate!nott!torn!watserv2.uwaterloo.ca!watdragon.uwaterloo.ca!daisy.uwaterloo.ca!katherle
  13. From: katherle@daisy.uwaterloo.ca (Kate Atherley)
  14. Subject: Re: Eliminating zeroes from multi-valued expressions in MAPLE
  15. Message-ID: <BxvFIK.Lup@watdragon.uwaterloo.ca>
  16. Sender: news@watdragon.uwaterloo.ca (USENET News System)
  17. Organization: University of Waterloo
  18. References: <924816194818@ibm3090.bham.ac.uk>
  19. Date: Tue, 17 Nov 1992 17:35:08 GMT
  20. Lines: 167
  21. ===============================================================================
  22.  
  23. In article <924816194818@ibm3090.bham.ac.uk> PEARCES@UK.AC.BHAM.IBM3090 writes:
  24. >I`m a MAPLE user with a big problem.
  25. >The following expression has
  26. >zeroes at phi_d := {.9807315053, 2.160861149}.
  27. >
  28. >            162265091            2    446229  1/2
  29. >   (223 (- ----------- sin(phi_d)  + --------)
  30. >               4000                     11
  31. >
  32. >                162265091            2    7689337  1/2
  33. >      + 100 (- ----------- sin(phi_d)  + ---------)   )
  34. >                   4000                      85
  35. >
  36. >      ^ 2
  37. >Does anyone know how to find the function left after
  38. >eliminating each pole. My MAPLE procedure fails to work properly
  39. >even if I only wish to evaluate the value of the expression at each
  40. >pole when the pole has been removed. Simple dividing the expression
  41. >by an (phi_d-0.98073...) and taking the limit of the resultant expression
  42. >as phi_d approaches 0.98703.... Doesn`t work in MAPLE either.
  43.  
  44. Although Maple's solve() function does return the roots you give (in
  45. exact rational form until you apply evalf()), these are, in fact, not
  46. roots of your function.  They are spurious roots introduced by squaring.
  47.  
  48. The problem is that the expression goes complex near Pi/2.  This is why
  49. the spurious roots appear.  And where the expression is real, it is on the
  50. order of 10^10.  Thus there are no real roots to your expression, which
  51. explains why such things as limit have difficulty when you try to divide
  52. out the alleged roots near .98 and 2.16.
  53.  
  54. Here is a maple session showing some of the details:
  55.  
  56.  
  57.     |\^/|      MAPLE V
  58.  .._|\|   |/|_.  Copyright (c) 1981-1990 by the University of Waterloo.
  59.  \  MAPLE  /   All rights reserved.  MAPLE is a registered trademark of
  60.  <____ ____>   Waterloo Maple Software.
  61.       |        Type ? for help.
  62. # Increase Digits to protect against cancellation problems
  63. > Digits:=40:
  64.  
  65. # Define the subexpressions
  66. > p1 := phi_d -> -162265091/4000*sin(phi_d)^2+446229/11;
  67.                                                       2
  68.             p1 := phi_d -> - 162265091/4000 sin(phi_d)  + 446229/11
  69.  
  70. > p2 := phi_d -> -162265091/4000*sin(phi_d)^2+7689337/85;
  71.                                                       2
  72.             p2 := phi_d -> - 162265091/4000 sin(phi_d)  + 7689337/85
  73.  
  74. # Here the original problem:
  75. > p := (223*p1^(1/2) + 100*p2^(1/2))^2;
  76.                                      1/2         1/2 2
  77.                          p := (223 p1    + 100 p2   )
  78.  
  79. # Maple's attempt to find roots of p (but they are not roots)
  80. > solve(p(phi_d));
  81.                             %1, %1, Pi - %1, Pi - %1
  82.  
  83.                                                               1/2
  84. %1 :=     arccos(1/70912927803729 1556855523643604433146349441   )
  85.  
  86. > evalf(["]);
  87.                 [.9807315051080000303322044017505411924602,
  88.  
  89.                     .9807315051080000303322044017505411924602,
  90.  
  91.                     2.160861148481793208130438981528961691737,
  92.  
  93.                     2.160861148481793208130438981528961691737]
  94.  
  95. # Get the roots of the first piece
  96. > solve(p1(phi_d));
  97.                180                  1/2              180                  1/2
  98.   - arcsin(---------- 98331022495090   ), arcsin(---------- 98331022495090   )
  99.            1784916001                            1784916001
  100.  
  101. > evalf(["]);
  102.                  [-1.570772657184545921339569766375277706391,
  103.  
  104.                      1.570772657184545921339569766375277706391]
  105.  
  106. # Periodicity gives another (family of) roots
  107. > evalf(Pi-"[2]);
  108.                    1.570819996405247317123073616904225177806
  109.  
  110. # How far apart are they?
  111. > "-""[2];
  112.                     .000047339220701395783503850528947471415
  113.  
  114. # Get the roots of the second piece
  115. > solve(p2(phi_d));
  116.                                20                      1/2
  117.                   - arcsin(---------- 42422172913178678   ),
  118.                            2758506547
  119.  
  120.                                  20                      1/2
  121.                       arcsin(---------- 42422172913178678   )
  122.                              2758506547
  123.  
  124. # No real roots:
  125. > evalc(evalf(["]));
  126.             [ - 1.570796326794896619231321691639751442099
  127.  
  128.                   - .9564233764000061305075721869855452404189 I,
  129.  
  130.                 1.570796326794896619231321691639751442099
  131.  
  132.                      + .9564233764000061305075721869855452404189 I]
  133.  
  134. > p1(Pi/2);
  135.                                     -1/44000
  136.  
  137. > evalf(");
  138.                  -.00002272727272727272727272727272727272727273
  139.  
  140. > p2(Pi/2);
  141.                                    3392963053
  142.                                    ----------
  143.                                       68000
  144.  
  145. > evalf(");
  146.                    49896.51548529411764705882352941176470588
  147.  
  148. > p1(Pi);
  149.                                      446229
  150.                                      ------
  151.                                        11
  152.  
  153. > evalf(");
  154.                    40566.27272727272727272727272727272727273
  155.  
  156. > p2(Pi);
  157.                                     7689337
  158.                                     -------
  159.                                        85
  160.  
  161. > evalf(");
  162.                    90462.78823529411764705882352941176470588
  163.  
  164. > p(Pi/2);
  165.                / 223         1/2                   1/2      1/2\2
  166.                |----- I 44000    + 1/680 3392963053    68000   |
  167.                \44000                                          /
  168.  
  169. # This is about as small as the function gets
  170. > evalc(evalf("));
  171.                                                            9
  172.                .4989651537227366310160427807486631016040*10
  173.  
  174.                     + 47494.53383446247774655548050782504198492 I
  175.  
  176. > p(Pi);
  177.                  /223       1/2   1/2    20         1/2   1/2\2
  178.                  |--- 446229    11    + ---- 7689337    85   |
  179.                  \ 11                    17                  /
  180.  
  181. > evalf(");
  182.                                                              10
  183.                  .5623743076386678984956221653763304287514*10
  184.  
  185. > quit
  186.  
  187. Kate (with thanks to Dave Hare and Greg Fee)
  188. Waterloo Maple Software Technical Support
  189. support@maplesoft.on.ca
  190. First of all may I express my utmost thanks to Kate et al.
  191. Unfortunately the above does not help me with my problem that much.
  192. Therefore I will try to explain it more fully.
  193. Sadly this will mean using terms and concepts with which I am still
  194. as yet not fully comfortable.
  195.  
  196. Firstly my original expression contains square roots.
  197. These are multi-valued and hence we have 2 Rieman sheets for the
  198. rooted parts of the expression.
  199. Since there are 2 of these does this mean that the expression without
  200. the ^2 has 4 Rieman sheets and after squaring this expression
  201. has 2?
  202. I have worked out by hand that the `spurious' roots quoted above
  203. correspond to the expression when we choose the negative root
  204. for one of the square roots and the positive for the other.
  205. This would mean that the `spurious' roots are on a different Rieman
  206. sheet to that normally evaluated by MAPLE.
  207. It is this situation I am most interested in since it has physical
  208. significance in the problem I am tackling.
  209.  
  210. So the question in a nut shell is how to change the original expression
  211. so that it corresponds to the `spurious' roots and then eliminate the
  212. zero to find the remaining function (or just its value at the zero
  213. if this is not possible).
  214. Since this is to form part of a problem solving system
  215. I need a routine to do this automatically.
  216. Any further help would be greatly appreciated.
  217. Yours Gratefully,
  218. Stephen Pearce.
  219. P.S. I am using MAPLE 4.2 on an IBM3090 and so did not fully understand
  220. the MAPLE V syntax in the last message.
  221.