Uncertainty and accuracy for numerical integration « Next Oldest | Next Newest »

 ▼ Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 11-28-2005, 03:52 AM A recent thread involved a redux of my "Area between two curves" challenge for RPL. James Prange posted an HP-48 solution in which the uncertainty of the input function was specified by setting the display mode. Valentin Albillo questioned the clarity of this, as opposed to the syntax of "INTEG" on the HP-71B Math ROM: Quote: If you want to specify a particular precision, why, just do it, include the desired precision as a parameter to the integration process, which is just what my BASIC version does. Remember, we're talking about someone who's trying to fathom what the code does, and changing display modes instead of explicitly specifying a desired accuracy seems much more obscure, arbitrary, and less clean to me. To which James responded, Quote: Now there's a point that I heartily agree with you on! Assuming any association between the current display mode and the desired accuracy is pure nonsense to me. Interestingly, in the 28 series, the accuracy is a parameter for the integral function, and even the order of the parameters makes more sense to me. What ever possessed them to change this for the 48 series is beyond me. A bit of background: The method of setting the display mode to specify the uncertainty of the input function to be integrated, was introduced on the original implementation of INTEG on the HP-34C, and carried over to other RPN implementations of the INTEG function: the HP-15C, HP-41C Advantage Pac, HP-32S. Although not entirely logical, it was expedient and saved a stack argument or setting function. This prompted me to consult the respective manuals to see how the input-function uncertainty for INTEG is specified on various models: 34C, 15C, 41C* Advantage Pac, 32S, 32SII, 33S, 48*, 49*: Use FIX to specify uncertainty in a particular decimal digit; use SCI or ENG to specify uncertainty in a particular significant digit. 28C, 28S: Specify uncertainty in a particular decimal digit as a numerical parameter to the INTEG function. 42S, 71B Math ROM: Specify a relative uncertainty as a per-unit fraction of the function-value magnitude, as a numerical parameter to the INTEG function. The latter (42S, 71B) approach seems to be the ideal one: flexible and scalable, without the possible discontinuities inherent to using SCI for relative uncertainty. Calculation of the estimated error is a bit more complicated. ----------------------------- Excellent and detailed technical documentation on this topic is found in the HP-34C Owner's Handbook (Section 9 and Appendix B). The same material is essentially repeated in the HP-15C Owner's Handbook (Section 14 and Appendix E). The HP-15C Advanced Functions Handbook (Section 2) contains further in-depth discussions of pitfalls and techniques for numerical integration. This material makes one appreciate the diligent effort and high quality of HP's product documentation in the late 1970's to mid-1980's. The same topics are not covered or written as well in the HP-28C and HP-42S manuals that followed shortly thereafter. -- KS Edited: 28 Nov 2005, 4:14 a.m. ▼ Valentin Albillo Posting Freak Posts: 1,755 Threads: 112 Joined: Jan 2005 11-28-2005, 06:03 AM Hi, Karl: Karl posted: "Although not entirely logical, it was expedient and saved a stack argument or setting function." Yes, but using a stack argument or setting function (i.e: STO UNC, say, similar to STO RAN#) would've been preferable in the HP-15C (and absolutely mandatory in all RPL models) to the utter preposterousness of having to set a display mode to specify the uncertainty in your integration, with the side effect of arbitrarily changing the user's display setting, which perhaps you can't determine in advance in order to restore it later, thus changing it for good, whether the user wanted it or not. That's called a side effect though I'd call it collateral damage instead. Also, some people might be tempted to excuse this unacceptable behavior by saying that, by doing this, you'll be seeing your results in the proper display setting to look only at truly significant digits, so that SCI 5 would have you looking at a result more or less exact to the 5 digits after the decimal point you're seeing displayed. But adding insult to injury the HP-15C, for example, allows you to specify a negative number of digits for SCI, down to and including -6 (!!), which will affect the uncertainty you get. Now try and argue how the "SCI -6" mode you've just set up affects the display of the results you're seeing, and how that correlates with the number of guaranteed correct digits in the result you're just looking at. How many correct digits do you get with SCI -1 ? And with SCI -6 ? How many correct digits do appear in the displayed results in said "modes" ? Nonsense. INTEGRAL( a, b, uncertainty, f(x) ) or the equivalent in RPN or RPL is the way it should've been from the start, and certainly this abomination should never have been carried on to much more capable models. Best regards from V. ▼ hugh steers Senior Member Posts: 536 Threads: 56 Joined: Jul 2005 11-28-2005, 03:20 PM it should be mentioned that the supplied uncertainty is an error measure and is not guaranteed. that’s assuming the quadrature is implemented as some form of sampling – which most numerical ones are. in fact, there should really be two parameters, an error measure and a confidence eg. the relative error or number of digits and the number of standard deviations for which this error applies. the excitement of numerical quadrature on the 34c lead the manual to make this mistake in its claim of an upper error bound. this slip-up was later corrected in the 15c manual which states the error bound is only highly probable. Edited: 28 Nov 2005, 3:41 p.m. ▼ Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 11-28-2005, 11:29 PM hugh stated, Quote: it should be mentioned that the supplied uncertainty is an error measure and is not guaranteed. that’s assuming the quadrature is implemented as some form of sampling – which most numerical ones are. The ultimate purpose of the user-supplied uncertainty/accuracy/tolerance/error (call it what you will) is to provide a quantifiable measure that indicates to the calculator how extensively it should perform its quadrature. The more samples it takes, the more accurate the estimate of the integral can become. However, if the incremental change in the integral result after additional intelligent sampling is well within the estimated error based upon the "accuracy" of the input function, then there's not much purpose in continuing the quadrature process further. On the 34C, 15C, 32S, 32SII, (and 33S), the input-function accuracy is indeed represented as an uncertainty. The user specifies the decimal digit (FIX) or significant digit (SCI/ENG) that is to be treated as uncertain. This means that the rounded value of the function displayed in that format is the closest possible to the "actual" value, but that the uncertain digit could actually be up to "half a digit" larger or smaller. An upper bound of the estimated error is calculated accordingly, as described on pp. 245-248 in the HP-15C manual, and pp. 244-247 in the HP-34C manual. On the 42S and 71B Math ROM, the user specifies an error or tolerance of the input function as a per-unit fractional value. This is probably the ideal solution. Quote: in fact, there should really be two parameters, an error measure and a confidence eg. the relative error or number of digits and the number of standard deviations for which this error applies. Looks like three "error" parameters to me! :-) Well, remember that the function being integrated might be an exact mathematical function that has no inherent measurement error or uncertainty. Moreover, to introduce sophisticated statistical analysis into the INTEG function would seem like overkill to me (and probably to most users). Quote: the excitement of numerical quadrature on the 34c lead the manual to make this mistake in its claim of an upper error bound. this slip-up was later corrected in the 15c manual which states the error bound is only highly probable. Could you specify the page numbers in the respective manuals that contain the verbiage in question? Most likely, it was a case of HP's correcting imprecise verbiage, rather than retreating from unfounded claims. Only if the integral is calculated intelligently, with samples taken in the right places, can the estimate of the integral be accurate. There is a good example of this on pp. 257-267 of the HP-34C manual, treating f(x) = xe-x, as well as a technique (subdivision of the integral) describing how to compute it properly. The same example is given in the HP-15C manual, starting on p. 250, but the "computing technique" was exported to the Advanced Functions Handbook (AFH). My favorite example is that of integrating ```f(x) = sqrt(x)/(x-1) - 1/ln(x) ``` between 0 and 1. It was originally presented in the HP Journal article from 1980 describing the INTEG function on the HP-34C. The example was later presented in the HP-15C AFH, the HP-71B Math ROM manual, and probably others... Best regards, -- KS Edited: 29 Nov 2005, 5:38 a.m. ▼ Marcus von Cube, Germany Posting Freak Posts: 3,283 Threads: 104 Joined: Jul 2005 11-29-2005, 08:26 AM Hi Karl, this is an interesting Task! Quote: My favorite example is that of integrating ```f(x) = sqrt(x)/(x-1) - 1/ln(x) ``` between 0 and 1. I tried it on several calcs I own: The Simvalley GRC-1000 is a Chinese calc which is obviously a Casio design (but not available from them.) The GRC-1000 fails on the boundary values so that I had to restrict the area to [1E-6,1-1E-6]. The integration function accepts an input parameter N which subdivides the interval in 2^N steps. So it's up to the user to guess the accuracy. There is a default for N but it is not given in the manual. "Accuracy" is awful (never better than 2 digits). Moving the boudaries closer to [0,1] quickly produces "MA Error". The Sharp EL-9200 has similar problems, I had to reduce the boundaries to [1E-9,1-1E-9] and the accuracy, even with 512 intervals, is just 2 digits. My TI-84 Plus performs better. It does not stumble over the boundary values and has a separate argument for the tolerance with a default of 1E-5. The manual does not tell anything about the algorithm and what the tolerance exactly means. The TI is fast, even with a tolerance of 1E-8! The TI Voyage 200 (and its siblings) has no means of selecting the desired accuracy, the manual tells us that 6 significant digits are the target. The boundaries [0,1] pose no problems. Calculation time depends on whether nInt or the integration symbol is used (even in approximate mode.) The TI falls back to numerical integration in either case. Both the HP 33s and HP 49g+ in approximate mode perform in a similar fashion; they probably share some code. They have no trouble with the boundaries and return the same results. The 49g is much faster than the 33s but still slower than the TI. A display setting of SCI 5 seems to produce the same results as a tolerance of 1E-6 for the TI. If I change the display setting to SCI 8, the 49g+ takes minutes to find a result. In exact mode the HP 49g+ returns minus infinity. Marcus ▼ Valentin Albillo Posting Freak Posts: 1,755 Threads: 112 Joined: Jan 2005 11-29-2005, 08:53 AM Hi, Marcus: Nice results. Do any of the machines tested come up with the correct 12-digit solution, namely 0.0364899739786+ ? By the way, though this particular integral is nice and such, Mr. Kahan did not try the hardest examples at all. One of the hardest I know of would be this one: ``` Integral between 0 and 1 of f(x) = Cos(Ln(x)/x)/x = 0.3233674316 7777876139 9370087952 1704466510+ ``` if in doubt, just try and see how many correct digits do you get. Best regards from V. ▼ Marcus von Cube, Germany Posting Freak Posts: 3,283 Threads: 104 Joined: Jul 2005 11-30-2005, 01:42 PM Hi Valentin, Quote: Do any of the machines tested come up with the correct 12-digit solution, namely 0.0364899739786+ I had an answer prepared but must have managed to *not* post it correctly :-( Here are some results: ```Model Tolerance Result ---------------------------------------------------------- TI-84 Plus 1E-13 0.03648997398 TI-86 1E-13 0.0364899739787 TI Voyage 200 N/A 0.036489973974202 HP 48G / 49g+ SCI 12 0.0364899739831 HP 33s SCI 9 0.03648997401 ---------------------------------------------------------- ``` Italic digits are correct if rounding is taken into account. The TIs are much, much faster than the HP models (about an hour for the 48G!). The Manual for the Voyage 200 (which is essentially identical to the TI-89 and TI-92Plus) claims a target accuracy of 6 digits. The results are better than that. The Casio and Sharp models weren't better than 2 significant digits. They all failed on the boundary values. This holds for the Sharp PC-E500S with its "engineering software", too. Marcus Edited: 30 Nov 2005, 2:51 p.m. Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 11-29-2005, 06:42 PM Marcus -- The ones that took 2^n or 512 steps (and failed at the endpoints) are probably implementing Simpson's Rule. That's what my old Casio fx-3600P does. Evaluation at endpoints is required by the rule, but is often problematic in practical applications. I had benchmarked a few HP calculators for this problem, several years ago. The less-advanced models (e.g., 15C, 34C, 32SII, 41C Advantage) give an answer outside the estimated solution error at FIX 5, but an answer within bounds for FIX 6. The more-advanced models (42S, 28/48/49) give an answer within bounds for the equivalent or approximation of FIX 5, and a slightly more-precise answer for "FIX 6". I did not have a 71B Math ROM at the time. -- KS hugh steers Senior Member Posts: 536 Threads: 56 Joined: Jul 2005 11-29-2005, 10:06 AM hi karl, i am not interested in the debate of how the uncertainty is input to the machine, but if you think that setting FIX will be sure to give you the same number of accurate digits you are wrong. because it’s a sampling problem, and this is what i'm trying to point out in my comments. i don’t like to use the word “certainty” or “uncertainty”. i prefer to refer to a measure of error and a measure of confidence. the problem with the word “certainty” is that it is sometimes interpreted as an error and sometimes as a confidence. really, there are three values at work here for the calculators response; its approximation, its estimate of the error and its confidence. i'm saying to have full control over the approximation, you need to have input both an error measure as a tolerance and also a confidence. let me give you an example, consider the polynomial, f(x) = [(256x-11)(256x-81)(256x-175)(256x-245)(32x-5)(32x-27)(2x-1)]^2 now, integral(f(x), 0, 1) = 762676910510443067+2224/4095 however, put this into an hp15c and select FIX 9 and integrate between 0 and 1, and you get 0.000000000 with an “error” of 0.000000001. this is clearly wrong. in fact its completely wrong. what went wrong here?? the problem was that there is no means to input confidence and the calculator got itself pretty confident when it figured the function was zero at all sample points and stopped. remember i've already input the error tolerance as FIX 9. if i could enter a confidence as well, maybe i could persuade it to perform a few more samples after which it would find some non-zeros and start the job proper. also fyi, here are the references you asked for, the hp34c owners handbook, p209 (footnote) Quote: ...the algorithm in your hp34c computes an “upper bound” on this difference, which is the uncertainty of the approximation. bla bla… This means that while we don’t know the exact difference between the actual integral and its approximation, we do know that the difference is no bigger than 0.0001 but later in the 15c owner’s handbook, p201 (similar footnote) Quote: … But the algorithm in the hp15c estimates an “upper bound” on this difference, which is the uncertainty of the approximation. bla bla... This means that while we don’t know the exact difference between the actual integral and its approximation, we do know that it is highly unlikely that the difference is bigger than 0.0001 happy hacking. ▼ Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 11-29-2005, 06:29 PM hi hugh do you have a shift key on your keyboard?? there's not enough effort in your typing, or formulation of your thoughts. Quote: i am not interested in the debate of how the uncertainty is input to the machine, but if you think that setting FIX will be sure to give you the same number of accurate digits you are wrong. When did I say that (whatever it means)? Quote: i don’t like to use the word “certainty” or “uncertainty”. i prefer to refer to a measure of error and a measure of confidence. the problem with the word “certainty” is that it is sometimes interpreted as an error and sometimes as a confidence. really, there are three values at work here for the calculators response; its approximation, its estimate of the error and its confidence. These sound like three output values. Quote: i'm saying to have full control over the approximation, you need to have input both an error measure as a tolerance and also a confidence. If applied to the input function, it sounds like "fuzziness", e.g., "The actual value of function will be within 0.7% of the calculated value, but I'm only 35% confident of that..." What is the calculator supposed to do with that? Quote: ```f(x) = [(256x-11)(256x-81)(256x-175)(256x-245)(32x-5)(32x-27)(2x-1)]^2 ``` now, integral(f(x), 0, 1) = 762676910510443067+2224/4095 however, put this into an hp15c and select FIX 9 and integrate between 0 and 1, and you get 0.000000000 with an “error” of 0.000000001. this is clearly wrong. in fact its completely wrong. what went wrong here?? Well, I evaluated the function, but didn't try to integrate it. The function values f(x) routinely exceed 1010 (and even 1012) over most the region of integration, with roots f(x)=0 scattered at points in between. I couldn't expect what result would be obtained. Quote: the problem was that there is no means to input confidence and the calculator got itself pretty confident I guess the calc came equipped with a lifetime supply of confidence, built right in! :-) Quote: ...the algorithm in your hp34c computes an “upper bound” on this difference, ... we do know that the difference is no bigger than 0.0001 ... the algorithm in the hp15c estimates an “upper bound” on this difference, ... we do know that it is highly unlikely that the difference is bigger than 0.0001 The statement in the 15C manual is more precise: it acknowledges that the upper-bound estimate of integral error is contingent upon the ability to evaluate the integral intelligently. They knew full well that poor selection of limits by the user could preclude that, as evidenced by the example of integral (f(x) = xe-x from 0 to 1). -- KS ▼ hugh steers Senior Member Posts: 536 Threads: 56 Joined: Jul 2005 11-29-2005, 08:13 PM hello again, perhaps i'm not being clear enough. i'm suggesting that any meaningful measure of the error in a sampling problem like numerical quadrature requires a measure of the confidence. to be clear, there are two other numbers than the resultant approximation. these are an estimate of the error and the measure of confidence. now depending on your implementation, these two values can be either input, output or both. in the case of hp you have only an input of the error tolerance by indirect means and you couldn’t specify the confidence. consequently, this can lead to bogus results (eg. previous example). alternatively, the confidence could be an output value. for example, my polynomial is zero at the first 7 sample points chosen by the hp algorithm. that’s not really much confidence in the function being zero everywhere. thus its statement of the error as 10^-9 is highly uncertain – but it doesn’t tell you this. for my example, if you dont like the large numbers, you could simply scale the coefficients down by dividing them all by 100 or something like that to bring it into line. i’d like to restate my main thesis for clarity; the upper bound estimate given by the hp algorithm is not just contingent on the ability to evaluate the integrand but is MATHEMATICALLY MEANINGLESS without reference to a properly defined statistical confidence which is absent in their analysis. in the hp qualification of their error estimate, what precisely does the phrase “highly unlikely” actually mean. in point of fact, you are never assured the accuracy of *any* of the resultant digits irrespective of the given error estimate. happy hacking. Edited: 29 Nov 2005, 8:23 p.m. ▼ Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 11-30-2005, 02:48 AM hello, hugh -- Quote: perhaps i'm not being clear enough. i'm suggesting that any meaningful measure of the error in a sampling problem like numerical quadrature requires a measure of the confidence. to be clear, there are two other numbers than the resultant approximation. these are an estimate of the error and the measure of confidence. now depending on your implementation, these two values can be either input, output or both. Well, I think that you'd better choose whether confidence should be an input or an output. If it is an input, the user is virtually compelled to be a statistician just to compute a numerical definite integral. This would not be what H-P had in mind. Quote: in the case of hp you have only an input of the error tolerance by indirect means and you couldn’t specify the confidence. The HP-42S and HP-71B Math ROM let the user specify a numerical value of calculated input-function tolerance as a per-unit fraction. The "actual" value of the input function is assumed with 100% confidence to be within this margin. Quote: my polynomial is zero at the first 7 sample points chosen by the hp algorithm. that’s not really much confidence in the function being zero everywhere. thus its statement of the error as 10^-9 is highly uncertain – but it doesn’t tell you this. So that's where it came from! A contrived function that deliberately deceives the algorithm. Based on only seven samples of zero, what else would or could the algorithm tell you? This illustrates why the Nyquist minimum-sampling rate for correct reconstruction of a waveform is more than twice the highest frequency component. What if a pure sinusoidal waveform were sampled exactly at each zero crossing? The calculated rms value and frequency content would be zero -- a clearly erroneous result. Quote: the upper bound estimate given by the hp algorithm is not just contingent on the ability to evaluate the integrand but is MATHEMATICALLY MEANINGLESS without reference to a properly defined statistical confidence which is absent in their analysis. in the hp qualification of their error estimate, what precisely does the phrase “highly unlikely” actually mean. in point of fact, you are never assured the accuracy of *any* of the resultant digits irrespective of the given error estimate. Well, gosh. Is a correct answer -- which INTEG will give reliably -- generated by a reasonable and methodical process ever "mathematically meaningless"? The HP-34C manual that you have contains much discussion about user responsiblities in posing the integration problem. If the function is flaky, the user should structure the problem so that the calculator can handle it properly. What answer do you get if you integrate the function in sections, between each of its root values of zero? (Use SCI or ENG). I got 2.80456*1017 with estimated error 6.61428*1011 for the first interval of 0 to 11/256 (= 0.0429688), using SCI 5. That seems reasonable to me. Maybe you could do the other seven intervals... -- KS Edited: 30 Nov 2005, 3:11 a.m. ▼ hugh steers Senior Member Posts: 536 Threads: 56 Joined: Jul 2005 12-02-2005, 11:55 AM hi karl, you are right. the example is contrived to be exactly zero at the 7 sample points. if you break it up at all, even into two arbitrary halves, say, you will then get the correct answer from the calculator. this is what you have shown. Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 11-28-2005, 05:30 PM Hello again, Valentin -- You stated, Quote: Yes, but using a stack argument or setting function (i.e: STO UNC, say, similar to STO RAN#) would've been preferable in the HP-15C (and absolutely mandatory in all RPL models) to the utter preposterousness of having to set a display mode to specify the uncertainty in your integration, with the side effect of arbitrarily changing the user's display setting, which perhaps you can't determine in advance in order to restore it later, thus changing it for good, whether the user wanted it or not. Certainly, from the standpoint of mathematical "directness", it is not ideal to equivalence a display mode to the uncertainty/tolerance/accuracy/error (call it what you will) of an input function. "Utter preposterousness", though, seems rather harsh. Consider the practical implications of adding a third numerical input to a function on a calculator having a fixed 4-level stack and no menus. The argument would have to be placed and recalled from its own storage register, or on the stack, as you correctly stated. If the argument were placed in its own storage register, a place on the keyboard would be needed for it. There just weren't any spare locations on the 34C or 15C keyboard. Moreover, what if the calculator did not prompt for the uncertainty value, or require it in order to complete the INTEG command? (Consider INTEG in a program.) The user would then run the risk of unwittingly running INTEG with a poorly-matched uncertainty value, thus obtaining inaccurate results, and being none the wiser. If the argument were placed on the stack, that would make three input stack arguments, which would violate what might have been an HP 4-level RPN design principle -- "no function shall require more than two input arguments from the stack, or shall place more than two results onto the stack." Users may find it difficult to remember where the third argument should go -- in the z-level or x-level. Getting it wrong would cause incorrect results -- after waiting up to several minutes for them. Moreover, the third argument could not be preserved on the stack (as the two limits of integration are). FIX/SCI/ENG give a visible indication of input-function uncertainty, and the mode is static. The "special storage register" approach would have one subsequently-developed analogy -- the "FN=" command on the 32S and 32SII. I admit to having solved or integrated (or attempted to) the wrong program after not having specified the correct one with "FN=". ("FN=" was necessary on the 32S/32SII when the identifier completing SOLVE or INTEG became the variable, not the program label, as on the 34C and 15C.) I can think of only one exception to the "two stack inputs, two stack outputs max" rule on RPN models -- "STO g {matrix ID}" on the HP-15C, which has three stack inputs. I admit to having re-consulted the manual to use that one correctly... Finally, if one numerical argument for input-function uncertainty were to be input, it ought to be the "ACC" value of the 42S, or the error tolerance of the 71B Math ROM. Since the 42S has a named and menu-displayed variable "ACC" for it, and the 71B uses argument-list checking, this input argument is handled well on those models. The point of my short essay was that HP thought through the details and practical implications of doing things a certain way on their calculators, considering how the typical user would utilize them. They didn't make very many mistakes, and -- all things considered -- I don't think they made one here, either. Quote: But adding insult to injury the HP-15C, for example, allows you to specify a negative number of digits for SCI, down to and including -6 (!!), which will affect the uncertainty you get. Now try and argue how the "SCI -6" mode you've just set up affects the display of the results you're seeing, and how that correlates with the number of guaranteed correct digits in the result you're just looking at. How many correct digits do you get with SCI -1 ? And with SCI -6 ? How many correct digits do appear in the displayed results in said "modes" ? I don't quite follow this. I see no mention of negative arguments to FIX/SCI/ENG in my HP-15C manuals. The user cannot successfully enter [SCI][CHS][6] or [SCI][6][CHS], and [SCI][I] with a negative value in the I-register seems to yield the equivalent of [SCI][0]. Quote: ...INTEGRAL( a, b, uncertainty, f(x) ) or the equivalent in RPN or RPL is the way it should've been from the start, ... Well, I disagree, for the reasons stated above. (This applies only for the models without static menus or alphanumerics -- 34C, 15C, 32S, 32SII). Practical considerations must trump ultra-orthodox mathematical purity, in my book, as long as computational accuracy is not compromised. It's good to do things the "right and rigorous way" and to give users maximum flexibility wherever possible, but the tool must have the necessary capabilities in place first. Quote: ...and certainly this abomination should never have been carried on to much more capable models. On the 42S, it wasn't. But, the 42S had the named variables, static menus, and more computing power to incorporate "ACC" properly. I agree with you (and James Prange) that the 48/49 should have had "ACC" (or equivalent) as a stack argument for INTEG. Best regards, -- KS Edited: 29 Nov 2005, 5:13 a.m. ▼ Valentin Albillo Posting Freak Posts: 1,755 Threads: 112 Joined: Jan 2005 11-29-2005, 06:17 AM Hi, Karl: Karl posted: ""Utter preposterousness", though, seems rather harsh." Not to me. Having a display mode control a parameter for numerical integration is utterly preposterous. Specially if you're using software not written by yourself that all of a sudden changes your display format for its own purposes and then doesn't restore it to the setting you preferred (because it can't). What a nuisance ! "If the argument were placed in its own storage register, a place on the keyboard would be needed for it. There just weren't any spare locations on the 34C or 15C keyboard. Yes they were. In the case of the HP-15C, for instance, you could have STO INTEG, similar to STO #RAN, say. The combination STO INTEG wasn't used for anything, so it was free for this purpose. I'm sure this same sequence could be used for the HP-34C as well. Further, RCL INTEG would recall to the X-register the uncertainty. This would be even better when using INTEG programmatically, as you would be able to manipulate the uncertainty as a *value* with any arithmetic or mathematical functions, such as: ``` X<=0? enough accuracy ? GTO C yes, go on RCL INTEG no, recall uncertainty 2 / halve it STO INTEG specify new uncertainty GTO B recalculate the integral ``` Just try and do the same with 'display modes' and then tell me what you think it's the logical, natural way and what's the preposterous way. "Moreover, what if the calculator did not prompt for the uncertainty value, or require it in order to complete the INTEG command? (Consider INTEG in a program.) The user would then run the risk of unwittingly running INTEG with a poorly-matched uncertainty value, thus obtaining inaccurate results, and being none the wiser." Karl, please, we're talking about *HP* calculators of the past, which were bought mainly by knowledgeable engineers and very bright people in general, what with those prices ! So, some brains on the part of the user were taken for granted. Your argument applies equally well to any and all functions requiring some inputs on the stack, and none of them prompted the user as far as I know. Say, for instance, rectangular <-> polar conversions. What if you forgot to include the theta value in Y ? Well, you wouldn't get your results, that's what, and you'd learn how to do it properly, and that's all. Frankly, I can't see what's difficult to remember about the stack sequence: ``` T: uncertainty Y: b X: a ``` being set up before pressing INTEG. Or any other other you deem more natural. "If the argument were placed on the stack, that would make three input stack arguments, which would violate what might have been an HP 4-level RPN design principle -- "no function shall require more than two input arguments from the stack, or shall place more than two results onto the stack." Your research is incomplete or your memory is faulty, there are quite a number of exceptions, including the one you mention later. Want another very obvious one? That would be the results of SOLVE, if you care to have a look at the manuals: upon termination, SOLVE places the computed root in X, the previous estimate in Y, and the computed value of your function at the computed root in Z. That's *three* results for you. Also, what's the point in not using three levels for inputs to INTEG on the HP-34C or HP-15C ? Because none of the stack contents makes it alive to your f(x), matter of fact INTEG and SOLVE fill up all 4 stack levels with the current value of X, for your f(x) to act upon it. So all previous contents are utterly lost. And it goes without saying than upon termination, the initial stack contents before calling SOLVE/INTEG can't be saved at all, not even one level, because your f(x) computation would be likely to use them all, right ? In other words, once you call INTEG/SOLVE, your original stack is absolutely obliterated, so you can use two registers for parameters, or three, or all four, it makes no difference, none will survive when your f(x) is called, not to mention when the process terminates. "Users may find it difficult to remember where the third argument should go -- in the z-level or x-level. Getting it wrong would cause incorrect results" I can paraphrase your statement word for word using SOLVE instead and a lot of other stack-using commands. In the world of stack-based RPN, there are a number of things you should remember, and you eventually do, we're talking engineers and power users here. And after all, why do you think HP included the "stack-syntax" of a number of commands (such as polar <-> rectangular) in the back labels ? Having the uncertainty in the stack would be consistent with this as well. "They didn't make very many mistakes, and -- all things considered -- I don't think they made one here, either." I fully disagree, they did. And they did carry this nonsense to INTEG in advanced RPL models ! Unbelievable ! " I don't quite follow this. I see no mention of negative arguments to FIX/SCI/ENG in my HP-15C manuals." Another example of either faulty memory or incomplete research. Have a look at the big footnote on the subject, which is at page 247 in the HP-15C's Owner's Handbook, at least it is in my Rev. G manual. "It's good to do things the "right and rigorous way" and to give users maximum flexibility wherever possible, but the tool must have the necessary capabilities in place first." If by "the tool" you mean the HP-15C or HP-34C, they certainly had the necessary capabilities, namely a 4-level stack, which could easily accommodate three parameters for INTEG, and/or a prefix-capable keyboard, which could accommodate STO INTEG and RCL INTEG easily. And if you're referring to RPL models, with unlimited stack levels, it goes without saying that they could (and should!) too. Best regards from V. Edited: 29 Nov 2005, 6:20 a.m. ▼ Arnaud Amiel Senior Member Posts: 362 Threads: 30 Joined: Jul 2005 11-29-2005, 06:27 AM Quote:and then doesn't restore it to the setting you preferred (because it can't). RCLF and STOF are here for that purpose. The following program should not alter your calc in any way. ```<< RCLF 5 FIX STOF>> ``` Arnaud ▼ Valentin Albillo Posting Freak Posts: 1,755 Threads: 112 Joined: Jan 2005 11-29-2005, 06:33 AM Hi, Arnaud: "RCLF and STOF are here for that purpose. The following program should not alter your calc in any way. " You don't suppose for a moment that I don't know about them, do you ? The problem is that RCLF and STOF are particular functions present in a particular model or ROM, they can't be found on the HP-34C or HP-15C, which are the models where INTEG/SOLVE were pioneered, nor are there equivalent functions or capabilities. Best regards from V. ▼ Arnaud Amiel Senior Member Posts: 362 Threads: 30 Joined: Jul 2005 11-29-2005, 09:29 AM Sorry, I was confused and should have looked at the subject and the poster... I will delete the message if requested. Arnaud ▼ Valentin Albillo Posting Freak Posts: 1,755 Threads: 112 Joined: Jan 2005 11-29-2005, 10:06 AM Hi, Arnaud: Arnaud posted: "I will delete the message if requested." I think it would be better to leave it posted. Though not relevant for this topic, it might be the case that someone would find it useful to know that they can store and later recall some flags this way. Best regards from V. Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 11-29-2005, 05:31 PM Hi, Valentin -- I see your points, but remain unswayed in my convictions regarding this subject. I'll continue to discuss the specific points, but first, there's a more general point I'd like to make: You and I both agree that the HP-15C was an utterly remarkable achievement of engineering design -- an extremely sophisticated tool that was nonetheless very accessible and straightforward to use. This was achieved, I believe, because the machine was so well organized, logical, and intuitive. You have emphasized the importance of intuitiveness in previous posts, and I heartily concur. Even though the manual was extensive, once a user familiarized himself, it was seldom needed thereafter -- even for the advanced functions. The rare items that are not very intuitive on the HP-15C are the ones that get the most questions from users in this Forum, i.e.: "How do I get out of Complex Mode?" [g CF 8]; "How do I change the comma to a decimal point?" [ON/.] That being said, there's always a clever way to do things, and sometimes these must be employed when the more-direct way isn't quite possible. However, doing things "cleverly" but not intuitively may lead users astray, and leave them frustrated or dismayed. Keeping that theme in mind, here are my responses: Quote:Having a display mode control a parameter for numerical integration is utterly preposterous. ... What a nuisance ! That's a better term, I think: "nuisance", or "annoyance". Display mode is of interest for interactive work, and the user can reset it if needed. It's nice when this is a 3-keystroke combination (e.g., HP-15C) instead of 4 (HP-32SII) or 5 (HP-42S). I use FIX/SCI/ENG frequently. Quote:In the case of the HP-15C, for instance, you could have STO INTEG, similar to STO #RAN, say. The combination STO INTEG wasn't used for anything, so it was free for this purpose. OK, here's where "intuitiveness versus cleverness" comes into play. STO RAN # is intuitive: "Store x-register value as the seed for next random number". STO RESULT is intuitive: "Store matrix defined by descriptor in x-register to the designated 'result' matrix." STO n, STO I, STO (i), STO MATRIX {}, etc. are all intuitive. Now, STO Syx ("INTEG") would be, what -- "Store the calculated integral"? (Probably wouldn't want to unwittingly use that stored value as the input-function error for the next integral.) What if the user mistakenly hit [STO][INTEG], then wondered why subsequent calculated integrals were so coarse? Sure, STO INTEG would have been a clever way to provide a storage location for a parameter, but it would also provide a potential pitfall for users, even the knowledgeable and very bright ones. How about placing the tolerance/accuracy on the stack? Well, some users may not be particular about specifying the value, preferring to use a reasonable default. That approach won't work if the value is taken from the stack, because its omission will almost certainly cause garbage results. However, a FIX/SCI/ENG display setting is always in effect, and is plainly visible in interactive ("RUN") mode. Settings favored by most users will yield a reasonably accurate estimation of the integral, when interpreted as an input-function uncertainty. (For example, FIX 5 says that the uncertainty of f(x) is less than 0.000005 at all points.) Quote:Say, for instance, rectangular <-> polar conversions. What if you forgot to include the theta value in Y ? Well, you wouldn't get your results, that's what, and you'd learn how to do it properly, and that's all. Again, intuitiveness: Any competent user of R->P or P->R conversions knows that they require two inputs and provide two outputs. A diagram and stack table is provided on the back plate to help users get the order correct. The tables also provide references for multi-output functions that are not entirely intuitive. About those tables on the back plate: Wouldn't it make more sense for "L.R." to also return the correlation coefficient "r" (instead of "y-hat, r" doing so? But that would return three results for a function that required no stack inputs, pushing more of the user's data off the stack. And, notice that no function requires three stack inputs or produces three stack outputs. A design principle, maybe? Quote:Frankly, I can't see what's difficult to remember about the stack sequence: T: uncertainty Y: b X: a ... Also, what's the point in not using three levels for inputs to INTEG on the HP-34C or HP-15C ? Because none of the stack contents makes it alive to your f(x), matter of fact INTEG and SOLVE fill up all 4 stack levels with the current value of X, for your f(x) to act upon it. So all previous contents are utterly lost. And it goes without saying than upon termination, the initial stack contents before calling SOLVE/INTEG can't be saved at all, not even one level, because your f(x) computation would be likely to use them all, right ? The above is not entirely correct. The intuitive user procedure that was implemented (and printed on the keyboard face as Syx) is as follows: lower limit (a) [ENTER] upper limit (b) [INTEG] {user-fcn label} yielding stack contents of ```level input output t -- a z -- b y a integ. error x b integral ``` Although the INTEG and SOLVE functions do overwrite a and b on the stack, INTEG restores them upon completion. This is handy for reference, and for proceeding to the next part of a subdivided integral. There's no room to retain the user-function accuracy on the stack. Quote: SOLVE places the computed root in X, the previous estimate in Y, and the computed value of your function at the computed root in Z. That's *three* results for you. OK, there's an example I'd forgotten about. The "extra" values in Y and Z are useful for evaluating the quality of the solution in X. Since SOLVE is an advanced function that overwrites the input stack, it is not an issue to return three arguments, and it needs only two input arguments, in either order. "Two input/output agruments max" was an apparent principle, not a rule, and I'm sure there are other exceptions. I didn't scour the manuals to find them. Quote: Have a look at the big footnote on the subject (regarding negative arguments to SCI and ENG), which is at page 247 in the HP-15C's Owner's Handbook, at least it is in my Rev. G manual. Ah-ha! I looked right over it earlier, but there it is on p. 247 in my Rev. C and Rev. G manuals. "Big footnote"? That's fine print, man! :-) There may be unconventional applications for the capability of negative-valued indirect arguments to SCI and ENG for purposes that have no application for display format, but I think it's completely counterintuitive and minimally useful, and should have been omitted. Quote: If by "the tool" you mean the HP-15C or HP-34C, they certainly had the necessary capabilities, namely a 4-level stack, which could easily accommodate three parameters for INTEG, and/or a prefix-capable keyboard, which could accommodate STO INTEG and RCL INTEG easily. I did, but I firmly believe in this colloquial expression, which is probably universal: "Just because you can, doesn't mean you should." Due to potential pitfalls of implementation that I described, for those models (as well as for the 32S and 32SII), the numerical "accuracy" parameter would not have been a sound idea. Quote: And if you're referring to RPL models, with unlimited stack levels, it goes without saying that they could (and should!)... I agree on that point. Different story for the RPL-based models, the HP-71B Math ROM, and the HP-42S, which had better-suited operating paradigms for that purpose. Best regards, -- KS Edited: 30 Nov 2005, 2:13 a.m. ▼ Valentin Albillo Posting Freak Posts: 1,755 Threads: 112 Joined: Jan 2005 11-30-2005, 05:27 AM Hi again, Karl: Just a few comments, as it seems we agree to (politely) disagree: Karl posted: "I see your points, but remain unswayed in my convictions regarding this subject." The bad thing about personal convictions is that they aren't necessarily backed up by rational, objective facts and can't be used as arguments in any rational discussion. "Even though the manual was extensive, once a user familiarized himself, it was seldom needed thereafter -- even for the advanced functions." I disagree. I find myself having to reach for it continuously to find out whether a particular matrix operation leaves its results in the result matrix or not and if so, if said result matrix can be one of the operands or not and if so, if the allowed operand is the matrix in X or the matrix in Y or both. Not to mention the effect of such convoluted matrix operations as the ones invocated by Cy,x and Py,x, which perform matrix manipulations intended to help when dealing with complex matrices. Also, STO and RCL by row/col are usually difficult to remember, etc, etc. Trust me on this, Karl, I can issue 15 questions about HP-15C operations right now, and you'd need to have a look at the manual to answer most of them, despite the 15C's alleged "intuitiveness". "The rare items that are not very intuitive on the HP-15C are the ones that get the most questions from users in this Forum, i.e.: "How do I get out of Complex Mode?" [g CF 8]; "How do I change the comma to a decimal point?" [ON/.]" Nonsense. These are the kind of questions that absolutely newbies to the HP-15C (or Voyagers in general) would ask. The real difficult questions never arise because these newbies can never think of them in the first place, and expert users actually do RTFM instead of asking them online. "Now, STO Syx ("INTEG") would be, what -- "Store the calculated integral"?" I'm more in favor of placing the uncertainty in the stack, not to specify it with a STO INTEG command. I only mentioned this as a refutation of your statement that there were no free locations in the keyboard for such a function, remember ? You were wrong, right ? Nevertheless, an hypothetic STO INTEG command would be much more intuitive than, say, Cy,x or Py,x applied to matrices, to name a few non-intuitive matrix key sequences. "Ah-ha! I looked right over it earlier, but there it is on p. 247 in my Rev. C and Rev. G manuals. "Big footnote"? That's fine print, man! :-) " Who's talking about font size ? A five line footnote is a big footnote by every standard. "There may be unconventional applications for the capability of negative-valued indirect arguments to SCI and ENG for purposes that have no application for display format, but I think it's completely counterintuitive and minimally useful, and should have been omitted." But they're there, and it adds a good measure of counterintuitiveness, unexpected side effects, and sheer "WTF?" to the whole business of specifying uncertainty by setting display modes. I'm sorry if this spoils a little your point but that's the way it is implemented and there's no point trying to dismiss reality when it doesn't fit with one's convictions. That said, it's been an interesting thread and I appreciate your point of view, of course. Thanks and best regards from V. ▼ Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 12-02-2005, 02:30 AM ... but I have sound counterpoints/rebuttals for every one of your points in the last post! :-) OK, as you wish -- no further discussion about it. I still support H-P's approach for input-function tolerance to INTEG in the 34C/15C/41C Advantage as a practical and adequate approach, given the limitations of those devices. Best regards from Karl James M. Prange (Michigan) Posting Freak Posts: 1,041 Threads: 15 Joined: Jan 2005 12-06-2005, 03:28 AM With Classic RPN's four-register stack, an extra parameter for the integration command would be a problem, so checking the display mode to set an error tolerance has some excuse. But what about the RPL models? They can have a very deep stack, so it seeems to me that there should be no real problem with making the error tolerance a parameter for the integration command. A complication here is that with RPL, integration can be either numeric or symbolic, and with symbolic integration, no error tolerance is needed. But any RPL command needs the same number of arguments, regardless of how it's being used, and the development team chose to use just one command for both numeric and symbolic integration. I looked in Bill Wickes's Insights books for some clues about why things are the way they are. In the 28 series, for symbolic integration,the arguments are as follows: ```3: integrand (an algebraic) 2: variable name (a name) 1 degree (a real integer) ``` But for numerical integration, the arguments are like this: ```3: integrand (a procedure, algebraic or program) 2: { name lower upper} (a list) 1: accuracy factor (a real number) ``` Or as a variation of numeric integration: ```3: integrand (a program) 2: {lower upper} (a list) 1: accuracy factor (a real number) ``` In that last example, instead of looking for a name for the variable of integration, the values are kept in stack level 1, so it's faster. Note that integration in the 28 series always takes three arguments, although the arguments vary, depending on what you're doing. For the 48 (and 49) series, this was changed. The arguments are always the same, and the integrand can only be an algebraic; it can't be a program, and instead of supplying the accuracy factor as a parameter in the arguments, the current display mode is checked. The arguments are as follows: ```4: lower (a real number) 3: upper (a real number) 2: integrand (an algebraic) 1: variable name (a name) ``` Personally, I prefer the way it's done on the 28 series. Regarding the error tolerance, quoting Bill Wickes from HP 48 Insights Part II: Problem-Solving Resources: Quote: The numerical evaluation of [integral symbol] produces a series of increasingly accurate estimates of the integral, derived from sampling intervals that are halved at each iteration. The process terminates when three successive iterations differ by an amount less than an error tolerance that you specify, or after a maximum of sixteen iterations have produced no apparent convergance (at this point the integrand has been evaluated 65535 times). The error tolerance is determined by the current real number display setting: n FIX (or SCI or ENG) specifies an error tolerance of [Epsilon] = 10-n. This in turn relates to the probable error in the numerical integral: ``` error [less than or equal] [Epsilon][integral]|f(x)|dx. ``` Quote: If the integration results have not converged after sixteen iterations, the number -1 is stored in IERR. The value returned to the stack is the last estimation of the integral. I presume that when numerical integration is successful, the value stored in IERR is based on how the estimates of the integral are converging, but I don't know the algorithm used for this. I think it worth noting that having three successive iterations differ by an amount less than the specified error tolerance doesn't guarantee that the last estimate differs from the actual value of the integral by less than the specified error tolerance. By the way, scans of the Insights books, as well as HP 41/HP 48 Transitions are available on the latest MoHPC CD set / DVD. For anyone who wants a deeper look into why RPL is the way it is and how to use it effectively, I highly recommend the Insights books. Having never used a 41 series, I haven't read Transitions, but presumably it's written for those accustomed to Classic RPN who want to learn RPL. Regards,James ▼ Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 12-07-2005, 02:34 AM James -- Thank you for the informative response regarding integration tolerance, and for clearing some things up about numerical integration on RPL-based machines. Your response would have been helpful for my first RPL "challenge" in late 2003, when I didn't know how to integrate a function defined as a program (rather than as an expression) on an HP-48G. I got only one uninformative reply. You say that it is possible on the HP-28C/S, but not on the 48/49. Quote: With Classic RPN's four-register stack, an extra parameter for the integration command would be a problem, so checking the display mode to set an error tolerance has some excuse. There is room on the classic 4-level RPN stack for an input accuracy argument, and it wouldn't matter even if all four stack levels were filled with input variables. This is because INTEG fills the stack with the present value of the input variable to the user-defined program, which might use all four stack levels. However, I believe that to include the function accuracy on the RPN stack as an input would have been unsound, due to potential pitfalls to the user. (Valentin disagreed with me, but I am unconvinced. You may read the posts in this same thread for this discussion.) The fundamental difference between the RPL stack and the RPN stack (besides depth) is that the RPL stack objects have specific object types, which the calc can check. Thus, if the user omits the function tolerance on the lowest HP-28 stack level as input to INTEG, the calc knows to return an error (or alternatively to use a default tolerance). INTEG on the RPN-based 34/15/41/32/33 models, however, take only floating-point inputs from the stack. If the tolerance is not placed on the stack, unrelated stack contents would be used as input arguments, and possibly the stack contents would be used for the wrong input variables. I also prefer the HP-28 stack-argument syntax for INTEG; menus are better to use interactively on the 48/49 models. -- KS ▼ James M. Prange (Michigan) Posting Freak Posts: 1,041 Threads: 15 Joined: Jan 2005 12-18-2005, 06:54 AM Hi Karl, Quote: Thank you for the informative response regarding integration tolerance, and for clearing some things up about numerical integration on RPL-based machines. You're welcome. Quote: Your response would have been helpful for my first RPL "challenge" in late 2003, when I didn't know how to integrate a function defined as a program (rather than as an expression) on an HP-48G. I got only one uninformative reply. I guess that I thought that Veli-Pekka's response was informative and helpful; he was referring to "user-defined functions". Or maybe I didn't notice your question, or maybe I noticed but didn't find the time to reply. Quote: You say that it is possible on the HP-28C/S, but not on the 48/49. Unfortunately (in my opinion), that seems to be the case, at least for numerical integration. The 49 series adds a few more commands for integration, but I think for symbolic integration only. Although the integrand can't be a program on the 48/49, this can be worked around. Let me review some things about UserRPL. Things that an RPL model can do can be called "operations". Examples of operations include disabling last stack saves, the ROOT command, and the SIN function. Disabling last stack saves can be done from menu 69 (so it is an operation), but can't be done from within a UserRPL program, so it's not a "command" (or a "function"). ROOT can be used (with postfix notation) in a program, so it's a "command" (as well as an "operation"), but it can't be used in an algebraic object, so it's not a "function". SIN can be used in an algebraic with the prefix syntax SIN(X), so it's a "function", and it can also be used in a program using the postfix syntax X SIN , so it's also a "command" (as well as an "operation"). All functions can also be used as postfix commands, although the documentation calls them functions. Some functions require the prefix syntax, such as SIN(X), when used in an algebraic, others require an infix notation, such as A+B, when used in an algebraic. But what to do when an algebraic is wanted, or even required (such as for the integrand argument for integration), but a command that we'd like to use in the algebraic isn't a function? We can work around the limitation by making our own UDF (user-defined function), that we can use with prefix syntax, such as F(x,y,z), within an algebraic, or for that matter, with postfix syntax such as x y z F. When used as a postfix command, a UDF takes it's arguments from the stack and binds the values as named local variables that can be used in the "defining procedure", which is either an algebraic or a program. When used within an algebraic, a UDF take it's arguments from a comma-separated (or period-separated, if the "fraction mark" is a comma) or semicolon-separated, parenthetical argument list instead of from the stack. The following assumes that the "fraction mark" is a period. Suppose that I want the (3-dimensional) distance between points [x1 y1 z1] and [x2 y2 z2]. I can write a UDF using an algebraic procedure as follows: ```%%HP: T(3)A(D)F(.); \<< \-> x1 y1 z1 x2 y2 z2 '\v/(SQ(x2-x1)+SQ(y2-y1)+SQ(z2-z1))' \>> 'F3DISTA' STO ``` Now, either 'F3DISTA(0,0,0,3,4,12)' EVAL or the sequence 0 0 0 3 4 12 F3DISTA returns 13. I could do much the same using a program for the defining procedure: ```%%HP: T(3)A(D)F(.); \<< \-> x1 y1 z1 x2 y2 z2 \<< x2 x1 - SQ y2 y1 - SQ + z2 z1 - SQ + \v/ \>> \>> 'F3DISTP' STO ``` Suppose that I want to sum the cubes of the numbers within a range. I can write a UDF as follows: ```%%HP: T(3)A(D)F(.); \<< \-> l h \<< 0. l h FOR n n 3. ^ + NEXT \>> \>> 'FSCUBES' STO ``` Now 'FSCUBES(2,5)' EVAL returns 224. Of course the sequence 2 5 FSCUBES also returns 224. Here's a UDF that takes the square root of a number less than 1, and squares a number equal to or greater than 1, although I don't know why anyone would want to do that. ```%%HP: T(3)A(D)F(.); \<< \-> x \<< x DUP 1. IF < THEN \v/ ELSE SQ END \>> \>> 'FSQSQR' STO ``` Now 'FSQSQR(.25)' EVAL returns .5, and 'FSQSQR(5)' EVAL returns 25. ROOT seem to be a particularly difficult case. The arguments for ROOT can be any of the following: ```3: procedure (program or algebraic) 2: global name 1: guess or guesses. (1 number or a list of 1, 2, or 3 numbers) ``` At first glance, it looks as if we could simply define an function, named say, 'FROOT', that we could use in an algebraic using the syntax FROOT(procedure,global name,guess). The first complication is that a prefix function argument list can't include a program, so the first argument will have to be an algebraic (we may have to make another user-defined function for the first argument). The next is that a prefix function argument list can't include a quoted name, so we have to be sure that the name doesn't already exist (otherwise the contents instead of the name of the variable would be used). Finally, the last argument can be 1, 2, or 3 guesses, and list delimiters can't be used within a prefix function argument list. To work around that last argument, I'll make three separate UDFs: ```%%HP: T(3)A(D)F(.); \<< \-> p n g \<< p n g ROOT \>> \>> 'F1ROOT' STO %%HP: T(3)A(D)F(.); \<< \-> p n g1 g2 \<< p n g1 g2 2. \->LIST ROOT \>> \>> 'F2ROOT' STO %%HP: T(3)A(D)F(.); \<< \-> p n g1 g2 g3 \<< p n g1 g2 g3 3. \->LIST ROOT \>> \>> 'F3ROOT' STO ``` Now, suppose that I want to find the root near 3 of the function SIN(X), in RAD mode. I can do any of the following: ```RAD HOME 'X' PURGE 'F1ROOT(SIN(X),X,3)' EVAL RAD HOME 'X' PURGE 'F2ROOT(SIN(X),X,3,4)' EVAL RAD HOME 'X' PURGE 'F3ROOT(SIN(X),X,2,3,4)' EVAL ``` Any of the above will return 3.14159265359. Of course, if the calculator is already in Radians mode, then RAD can be omitted, and if I know that 'X' won't be found on the current path, I can omit the HOME 'X' PURGE part of the sequence. Note that a new 'X' will be stored in the home directory. In the above, I stored the UDFs as global variables, but note that I can also store them as local variables. For example: ```%%HP: T(3)A(D)F(.); \<< RCLF PATH RAD HOME 'X' PURGE \<< \-> p n g1 g2 g3 \<< p n g1 g2 g3 3. \->LIST ROOT \>> \>> \-> f3root \<< 'f3root(SIN(X),X,2,3,4)' EVAL \>> EVAL STOF \>> 'F3LROOT' STO ``` Here, the UDF is f3root, and F3LROOT will return 3.14159265359, and overwrite any variable 'X' in the home directory. It also restores the original directory and angular unit mode. In the 49 series, at least with recent ROMs, the PUSH and POP commands can be used to save and restore the current flags and directory. Of course, I don't have to store all of the arguments to a command in the UDF as local variables, although at least one argument has to be a local variable for the program to be a UDF. For example: ```%%HP: T(3)A(D)F(.); \<< \-> g \<< 'SIN(X)' 'X' g ROOT \>> \>> 'F1SINROOT' STO ``` Now, 'F1SINROOT(3)' EVAL returns 3.14159265359, 'F1SINROOT(6)' EVAL returns 6.28318530718, 'F1SINROOT(9)' EVAL returns 9.42477796077, and so on. All of these overwrite any variable 'X' in the current directory. Since I can quote X in the program, the 'X' PURGE isn't needed. I hope that helps. I wrote above that disabling last stack saves isn't a command, but on the 49 series, the KEYEVAL command offers a way to make many operations programmable. Exceptions are operations that require holding down the ON key while pressing another key. I've sometimes wished for KEYEVAL on the 28 and 48 series. Of course, SysRPL makes possible many things, and SysRPL entry points can be called from UserRPL with the commands SYSEVAL, LIBEVAL, and FLASHEVAL. But use these with care, as it's easy to cause a memory clear by improper use. Quote: There is room on the classic 4-level RPN stack for an input accuracy argument, and it wouldn't matter even if all four stack levels were filled with input variables. This is because INTEG fills the stack with the present value of the input variable to the user-defined program, which might use all four stack levels. However, I believe that to include the function accuracy on the RPN stack as an input would have been unsound, due to potential pitfalls to the user. (Valentin disagreed with me, but I am unconvinced. You may read the posts in this same thread for this discussion.) Okay; my 12C and 16C don't seem to include integration and I really don't care to read all of the documentation for other Classic RPN models, so I shouldn't've even commented on that issue. Quote: The fundamental difference between the RPL stack and the RPN stack (besides depth) is that the RPL stack objects have specific object types, which the calc can check. And in fact, every built-in UserRPL command that requires any argument checks that the number of arguments required is available, then checks the types of these arguments and proceeds appropriately. If arguments that it can use aren't available, then it will error out. Quote: Thus, if the user omits the function tolerance on the lowest HP-28 stack level as input to INTEG, the calc knows to return an error (or alternatively to use a default tolerance). INTEG on the RPN-based 34/15/41/32/33 models, however, take only floating-point inputs from the stack. If the tolerance is not placed on the stack, unrelated stack contents would be used as input arguments, and possibly the stack contents would be used for the wrong input variables. Which brings up another difference. With Classic RPN, all of the stack registers are always available; even after clearing, they're zero-filled. On an RPL model, after clearing the stack, the stack levels simply don't exist, and attempting to use a non-existent level will cause an error. Another difference is that typically, more stack levels are displayed on the RPL models. As far as I know, the Classic RPN models display at most two registers, so what's in the other registers isn't so obvious. Regards,James Edited: 18 Dec 2005, 7:54 a.m. ▼ Karl Schneider Posting Freak Posts: 1,792 Threads: 62 Joined: Jan 2005 12-19-2005, 11:47 PM Hi, James -- Thank you for making the effort to post such a detailed response. I'll quite likely try a few of those ideas, for the sake of experimentation... Regards, -- KS

 Possibly Related Threads... Thread Author Replies Views Last Post Integration question and "RPN" mode comment Craig Thomas 16 1,460 12-05-2013, 02:32 AM Last Post: Nick_S HP Prime numerical restrictions? Alasdair McAndrew 4 393 11-16-2013, 05:32 PM Last Post: Alasdair McAndrew HP Prime numerical precision in CAS and HOME Javier Goizueta 5 601 11-16-2013, 03:51 AM Last Post: Paul Dale WP34s integration trapped in infinite loop Bernd Grubert 25 1,644 10-17-2013, 08:50 AM Last Post: Dieter HP Prime integration Richard Berler 1 301 10-06-2013, 10:52 PM Last Post: Helge Gabert How much accuracy does one actually need? Matt Agajanian 23 1,405 08-26-2013, 12:46 PM Last Post: Kimberly Thompson [HP-Prime] AMBIGUITY between Numerical Calculation (HOME) and Numerical/Symbolic Calculation (CAS mode) CompSystems 2 341 08-18-2013, 07:06 PM Last Post: CompSystems OT: My brain is failing me again. Help with numerical / mechanical problem required. Harald 4 443 07-01-2013, 10:31 AM Last Post: Harald integration on 39gII emulator Wes Loewer 29 2,015 06-07-2013, 05:58 PM Last Post: Chris Smith WP-34S Integration Richard Berler 15 1,096 03-08-2013, 02:29 AM Last Post: Walter B

Forum Jump: