HP Forums

Full Version: rpn stack drop
You're currently viewing a stripped down version of our content. View the full version with proper formatting.

I am relatively new to rpn, but after having used the hp48, I wonder why such calculators as the 15c or 32s don't do stack drop when you perform a clx.

I believe the consensus you will find here is that the 3rd Generation Calculators (28s, 48g, 50g) are not pure RPN, rather RPL. See this recent thread for more discussion. This is one of many in recent months. Hope this helps.

The short answer is that CLX is not DROP. On the RPN models, the X register (level 1 in RPL-speak) is where digits are entered. When data enttry is begun, the X register is normally pushed on the stack, but see below for exceptions. On RPN machines, if you are entering digits (or alpha data on the 41/42), the back arrow key deletes your last character and backspaces. If you are not entering digits, then CLX (for CLear X) is executed. If CLX has just been entered, then stack lift is disabled. So I can delete the X register value and key a new one without pushing the T register (level 4 in RPL) into the bit bucket. On the RPL models, there is an entry line separate from the stack. The back arrow works the same way when entering data. But on all RPL models except the 28C and 28S, back arrow executes DROP when not in data entry mode.

Why the differences? I think its probably more useful to ask why RPL changed the preexisting RPN conventions. If you think about the mechanics of RPL, most operations take operands from the stack and consume them, i.e. they remove the operands from the stack as they are used. The idea seems to be that all operations with the stack are explicit and consistent. So one function that doesn't drop the stack is DUP, which is what the enter key does when not in RPN mode, or a true enter when in data entry mode. In both cases, there is no implicit manipulation of the stack. But RPN models don't have an extra data entry register. Data goes implicitly into level one, or the X register. The inconsistent stack lift behavior is dictated by the four level stack; you don't want to lose T if you don't have to. The RPL stack can grow arbitrarily, so there is no need for this stack conserving behavior. Also, the RPL stack is far more central than the RPN stack. The former can hold any object, so behavior with respect to the stack needs to be more consistent. The mechanics of the RPN stack are dictated by limited memory and conventions developed for the HP9100 and the HP35.

So the answer to your question is CLX is not DROP, and CLX came first.

Regards,
Howard

(Edited to remove trailing stuff I didn't intend to post)


Edited: 17 June 2007, 1:53 p.m.

I understand that rpn and rpl don't work the same way.

But stack drop on clx is useful. It seems stupid to just put a zero instead of dropping the stack.

Let's say you enter two numbers "2" and "3". You then decide that you don't need 3, so you clx. If the stack drops, then you can do single argument functions on 2 like sine, or sqrt. If instead you want to enter another number, "4" instead of performing a function on "2", then the stack lifts.

So dropping the stack with clx is more functional, and makes more sense. To me it seems pretty annoying to have to do a rolld or x<>y after doing a clx.

It just seems like a silly oversight on otherwise refined machines.


Edited: 17 June 2007, 4:50 p.m.

Keep in mind that RPN stacks are fixed four-register stacks that alway contain values. By contract, RPL stacks are dynamic. They can contain zero (that is, they are empty) or more values. So Clx with an RPN stack replace the old contents of X with 0 and sets the entry mode flag, since the RPN stack is fixed. This means that when you key in a number right after Clx, your input replace the 0 created by the Clx. If you perform an operation right after Clx, the calculator uses the 0 as the argument for the function.

Namir

Quote:

But stack drop on clx is useful. It seems stupid to just put a zero instead of dropping the stack.


I think which you prefer has a lot to do with which you learned first. A lot of us here cut our teeth on the old machines. To me, the CLX behavior is the natural one. But, to each his own.


Quote:

To me it seems pretty annoying to have to do a rolld or x<>y after doing a clx.


It just doesn't bother me, since that's what I expect. If it's too annoying for you, then I suggest you stick to the RPL machines.

Quote:
It just seems like a silly oversight on otherwise refined machines.

Yeah, too bad they didn't think of that in 1972.

Regards,

Howard

yes, but instead, they can simply drop the stack, but instead of replacing the value, then it can simply push the stack.

Like

t: 0
z: 0
y: 2
x: 3
then a clx leaves:
t: 0
z: 0
y: 0
x: 2

at which point you can do sine cos sqrt etc. on the 2.
But if you want to enter another number, then the following will occur:

t: 0
z: 0
y: 2
x: 4


instead, the 15c does this after a clx:

t: 0
z: 0
y: 2
x: 0
How does this help? To do a function on 2, you must
either rdn or x<>y.

But I reiterate, in order to make the clx stack drop effective, though, you also have to make the stack push when you enter another number, as opposed to doing a function, which will operate on the 2.

I guess the assumption is that if you have cleared the last value in X, you intend to replace it with another. That's why stack lift is disabled after CLX. (And not otherwise. i.e. RDN<key numbr> doesn't overwrite the X value, but pushes it back to Y) If I want a new operand in X, I just key it in. If I do want to operate on Y, and assuming X isn't bogus, I will X<>Y, do the operation and X<>Y again.

This is all pretty silly. The calculators do what they do, and no amount of discussion on our part will change that. Plus it's a matter of taste which you prefer. Why argue about it?

Regards
Howard

Edited: 17 June 2007, 5:21 p.m.

I don't want to argue, I just want to be understood.

The whole idea is that with stack drop/stack push, you CAN enter a new value, because it PUSHES the stack, but does not overwrite the former y.

But the convenient things is that you can ALSO perform a function on the former y register contents because it dropped into the x.
Because only when you enter a new number does the stack push.

Quote:
I understand that rpn and rpl don't work the same way.

But stack drop on clx is useful. It seems stupid to just put a zero instead of dropping the stack.

Let's say you enter two numbers "2" and "3". You then decide that you don't need 3, so you clx. If the stack drops, then you can do single argument functions on 2 like sine, or sqrt. If instead you want to enter another number, "4" instead of performing a function on "2", then the stack lifts.

So dropping the stack with clx is more functional, and makes more sense. To me it seems pretty annoying to have to do a rolld or x<>y after doing a clx.

It just seems like a silly oversight on otherwise refined machines.


My new RPN calc project has (I think) the best of both worlds here.
CLRx clears the currently entered number in the Xreg and prevents stack lift when you next enter the digit. But if you press CLRx a second time (when Xreg is 0) then the stack gets dropped.

I think it's a very sensible way to do it so that's how I implemented it in my design.

Dave.

Stefan --

Quote:
Let's say you enter two numbers "2" and "3". You then decide that you don't need 3, so you clx. If the stack drops, then you can do single argument functions on 2 like sine, or sqrt. If instead you want to enter another number, "4" instead of performing a function on "2", then the stack lifts.

So dropping the stack with clx is more functional, and makes more sense. To me it seems pretty annoying to have to do a rolld or x<>y after doing a clx.


As Namir explained, the stack has a fixed depth of four elements, so a "dropped" value would be replaced by something, one way or another.

If "you then decide that you don't need (the) 3", and don't want to replace it with something else, the best thing to do is roll down (RDN), which will place the unwanted value on the top of the stack (t-register) and drop the 2 to the x-register, so that operations can be performed. Stack-lift will remain enabled for entry of a new value to the stack -- which would push the unwanted value off the top of the stack.

If the 3 is simply to be replaced by a different value in the x-register, then CLx or DROP followed by the new value work equally well because CLx disables stack-lift: The new value, whether entered from the keyboard or recalled from memory, overwrites the place-holding zero in the x-register.

Quote:
(From your subsequent post): I don't want to argue, I just want to be understood.

A "words of wisdom" wall poster I've seen has the following statement:

"Seek first to understand, then to be understood."

:-)

Trust us -- these things were "thoroughly thought through" when implemented on the original HP-35 in 1972, and were slightly refined for successor RPN-based models.

-- KS


Edited: 18 June 2007, 1:48 a.m. after one or more responses were posted

Quote:

If "you then decide that you don't need (the) 3", and don't want to replace it with something else, the best thing to do is roll down (RDN), which will place the unwanted value on the top of the stack (t-register) and drop the 2 to the x-register, so that operations can be performed. Stack-lift will remain enabled for entry of a new value to the stack -- which would push the unwanted value off the top of the stack.



That's what I mean. They should do an automatic rdn, instead of the user having to do it.

I guess my saying that in the first place could have avoided confusion.

Edited: 17 June 2007, 6:35 p.m.

Why not just drop stack the first time?

Quote:
They should do an automatic rdn, instead of the user having to do it.

Leaving the stack unchanged after CLX makes perfect sense to me. Dropping the stack would change the contents of the Y and Z registers. The purpose of CLX is to clear the X register (hence the name), so why should it affect other registers? The way the HP48 does it has always seemed a little strange to me, but at least the key is labeled DROP to indicate what it does. If I want the stack to drop on a genuine RPN machine, I'll use RDN to do it; there's no need for the calculator to do it for me, and I'd prefer that it leave the choice up to me rather than trying to guess what I want.

I initially found it distracting on the two line screen to constantly have everything move up and down the stack every time. Seemed much neater to simply clear the Xreg, after all, you started entering a number for a reason. I figured that you would more often want to simply clear an incorrect keystroke or number than clear the operation by dropping the stack.

But it's all subject to change, after I use it for some time I might find it better to simply drop the stack, or even have it as a user definable option.

Dave.

But stack drop with stack push does not affect the user in any way except to give more options, that is, to give the user the option of performing functions on the previous contents of the y register instead of leaving a useless zero.

Bill Wickes wrote an article called "hp41 to hp48 transitions" where he talks about this exact issue. He said clx leaves a zero because of a psychological issue:

"many people, especially if they're used to algebraic calculators (which typically require you to press the clear key to start new calculations), like the sense of a "clean slate" suggested by a zero."

Personally I don't think a psychological reason is good enough. Functionality needs to take precedence. And for me it's not a psychological reason, because I don't like it that way. Nor do I like algebraic syntax.

Here's an analogy:
If you're going to use psychological reasons to design a calculator, you might as well get rid of rpn, because there are plenty of people who prefer algebraic entry to RPN out of ignorance. By ignorance, I mean, they've simply never tried using RPN.


Edited: 17 June 2007, 9:30 p.m. after one or more responses were posted

On programmable models, using CLx to get a zero in the X register is very common. So it isn't completely useless...

- Pauli

If all you want is a zero, then it's just as easy to press the zero key.

Stefan --

Quote:

I guess my saying that in the first place could have avoided confusion.

Carefully reasoning your statements is conducive to being understood.

Quote:

They should do an automatic rdn, instead of the user having to do it.

I generally oppose the idea of software/firmware doing things that I neither requested nor wanted. It's one of the primary complaints against Microsoft products.

Quote:

But stack drop with stack push does not affect the user in any way except to give more options.

The RPN stack is of fixed depth. What would fill behind a "dropped" element? If CLx always performed a "clear x-register" followed by RDN, then a zero would be placed in the t-register.

The previous t-register may have been wanted, because RPN will retain the t-register contents for operations that produce one result from two inputs (e.g., arithmetic "+"):

reg  before   "+"  after   
t 1.00 1.00
z 2.00 1.00
y 3.00 2.00
x 4.00 7.00

This feature is handy for constant arithmetic, or evaluation of polynomials by Horner's Method (described in the manuals for the RPN HP-15C amd HP-34C), as an endless supply of a value can be automatically produced if desired.

Quote:

If all you want is a zero, then it's just as easy to press the zero key (instead of using CLx).

Ah, but that will push the stack, leaving the unwanted value between the zero and the previous "stack y" value.

Also, as Howard said: RPN and its "CLx" are what they are, and they preceded (by 14 years) RPL and its "DROP", which are different but not necessarily better in the opinions of many.

Please take that wall-poster saying to heart. You seem wont to debate and express your own positions, instead of investigating and examining the explanations of others who made the efforts.

-- KS


Edited: 17 June 2007, 10:19 p.m.

My point in quoting William Wickes is that I have done research, and the designer of the HP 48 knows the origins of the clx better than you do, I'm willing to bet.

He says that the absence of stack drop with a clx comes from a psychological hang up of algebraic calc users.

And as far as the stack thing goes, stack drop would do the same thing as addition as far as the t register goes, so the duplication of the t would occur. I was mistaken, when I said its the same as rdn.

You said:

"I generally oppose the idea of software/firmware doing things that I neither requested nor wanted. It's one of the primary complaints against Microsoft products. "

Well the T register duplicates when the stack is full without you asking it to do that and the calc realocates matrix memory and registers when you have not asked it to do so. The 15c does many useful things that you don't ask it to do. Doing a stack drop when you clx would be another usefull thing.

Edited: 17 June 2007, 10:49 p.m.

Quote:

But stack drop with stack push does not affect the user in any way except to give more options, that is, to give the user the option of performing functions on the previous contents of the y register instead of leaving a useless zero.

Bill Wickes wrote an article called "hp41 to hp48 transitions" where he talks about this exact issue. He said clx leaves a zero because of a psychological issue:

"many people, especially if they're used to algebraic calculators (which typically require you to press the clear key to start new calculations), like the sense of a "clean slate" suggested by a zero."


And what is wrong with that?
There is actually some logic in that. Remember, a *human* is operating the calculator, not a machine. If the CLRX key helps the person with their thinking when doing calculations then CLRX can become a *good* design feature.

Quote:
Personally I don't think a psychological reason is good enough. Functionality needs to take precedence. And for me it's not a psychological reason, because I don't like it that way. Nor do I like algebraic syntax.

Here's an analogy:
If you're going to use psychological reasons to design a calculator, you might as well get rid of rpn, because there are plenty of people who prefer algebraic entry to RPN out of ignorance. By ignorance, I mean, they've simply never tried using RPN.


Not so.
I know many people who have (seriously) tried RPN and simply don't like it. Likewise I also know people who grew up with RPN but have switched to Algebraic.
Just as there are Algebraic users who try RPN and then make the switch.

It *always* comes down to an individuals preference which is a "psychological" matter. Any argument of RPN vs Algebraic, or RPN vs RPL, or *insert whatever you like here* will always be a moot point.

Calculators are used my humans, and humans are psychological in nature. Ignoring that in the design of any product is not always the right way to go.

Dave.

For what it's worth, I prefer RPL to Classic RPN, and CLx just clearing register x without dropping the stack makes sense to even me.

Okay, maybe also including a DROP command on a Classic RPN model might've been useful, but the designers chose not to do so.

Regards,
James

Edited: 18 June 2007, 12:16 a.m.

Quote:

Bill Wickes wrote an article called "hp41 to hp48 transitions"


If you read that book, then you know that William Wickes designed RPL. Of course he's going to prefer the way RPL does it. He wrote it! Plus, meaning no disrespect for Dr. Wickes, he wasn't speaking with the authority of someone who had been around in 1972 when the design of the RPN stack was created. He rose to prominence in the late 1970's, as one of the folks most responsible for synthetic programming on the HP41. He was the first to put together a complete description of SP. I learned SP from his book in 1984. I don't believe he was working for HP even then. He was hired as a leading light in the HP calculator community to design the next generation of calculators. So that was probably in 1985 or so.

Anyhow, your statement below that Doctor Wickes "knows the origins of the clx better than you do, I'm willing to bet," is factually dubious and rude. We have a nice, collegial atmosphere here. We have vigorous debate, but without personal statements like "better than you do." I recommend you look into some of the archives to see how those are handled.

Howard

Stefan,

RPN is a language used in pocket calcs for 35 years now, and it stayed consistent. RPL is *another* language, though similar in many aspects. You are free to like or dislike one of them or any other. However, IMHO your personal preference will not change RPN no matter how long you will argue. There may be good reasons for this.

Found the messages of James and Howard just after posting. So, these 3 posts were written in parallel, 2 of them by very experienced members of this forum. Think!

Edited: 18 June 2007, 12:30 a.m.

Quote:
But stack drop with stack push does not affect the user in any way except to give more options, that is, to give the user the option of performing functions on the previous contents of the y register instead of leaving a useless zero.

Yes, it certainly does affect the user in other ways. For instance, if I write a program that depends on certain things being in certain registers, and issue a CLX, then I can count on everything in the registers other than X remaining exactly as they were. Under your plan, I'd need to take extra steps to put things back like they were before the CLX was executed, which is silly for a command whose only purpose is to alter one specific register. Even when I'm just entering things manually from the keyboard, I have to keep a mental picture of the stack and where everything is. The less often things move around, the easier it will be to keep track of where they are.

Quote:
Bill Wickes wrote an article called "hp41 to hp48 transitions" where he talks about this exact issue.

I have a great deal of respect for Bill Wickes; however, I'd have even more respect for him if he had stuck to extending and improving RPN rather than transforming it into RPL. As much as I love my 48GX, I'd like it a lot more if it worked more like my even more beloved 41CX.

Consistent but wrong.... where have I heard that before?

Quote:
My point in quoting William Wickes is that I have done research, and the designer of the HP 48 knows the origins of the clx better than you do, I'm willing to bet.

Huh? That's a non sequitur, but as Howard and others have already responded, I'll let it pass...

Quote:
He says that the absence of stack drop with a clx comes from a psychological hang up of algebraic calc users.

I say that CLx "zeroes out" the x-register and leaves others unmodified is that the stack depth is fixed at four elements, requiring that some placeholder fill in for a "deleted" element. What better than zero -- blanks?

Quote:
Well the T register duplicates when the stack is full without you asking it to do that

No, the t-register generally retains its stored value, until some stack-lifting operation replaces that value with the previous contents of the z-register, or RDN replaces the value with the contents of the x-register.

One exception to that is the numerical-integration function ("INTEG") offered on the HP-34C, HP-15C, HP-32S/SII, and HP-33S. On the HP-34C and HP-15C, INTEG (and SOLVE) as a convenience will automatically load the stack with the latest input value of the variable of integration or rootfinding, prior to each execution of the program defining the user's function. This is OK, because these special functions are designed to "process" only one variable. Other necessary inputs to the user's function can be retrieved from storage registers.

Upon completion of INTEG, each of these models will return four values to the stack:

t    lower limit (restored from input)
z upper limit (restored from input)
y estimate of maximum error
x estimate of integral

This also is OK, because the original stack contents when INTEG was invoked had been repeatedly overwritten anyway...

Quote:
and the calc realocates matrix memory and registers when you have not asked it to do so.

I don't quite understand that statement. It's not true of the HP-15C, which has only manual memory allocation. The HP-15C will utilize free registers from the "pool" as necessary to store a matrix result, but that is perfectly acceptable.

The HP-11C and HP-34C -- which lack matrix functionality -- will automatically delete data registers as necessary to accommodate more programming instructions entered by the user, but I don't consider that a desirable attribute.

Quote:
The 15c does many useful things that you don't ask it to do.

I do agree with that statement. Those are thoughtful features which never cause the user consternation, as opposed to irritating distractions.

Please see above for an example.

Quote:
Doing a stack drop when you clx would be another usefull thing.

I vehemently disagree with that, and if you don't understand why, you weren't earnestly reading the responses from me and others. Why do you keep hammering away at this issue, which was certainly significant to product design, but is rather trivial in the grand scheme of things? Is it because you enjoy the argument and seek to be understood before all else?

-- KS

in RPN:

DROP = CLx +

-- Antonio

Edited: 18 June 2007, 3:42 a.m.

That is brilliant. Thanks Antonio!

Regards,
Howard

Quote:
DROP = CLx +

hmmm.... not considering the LastX, that is.

Hi, K. Stefan Jansson:

K. Stefan Jansson posted:

    "I wonder why such calculators as the 15c or 32s don't do stack drop when you perform a clx."

      In the HP-15C, CLX is used to allow you to independently modify/clear the real and/or imaginary parts of a complex value in the X register without disturbing the rest of the stack. By using it, you can: conveniently alter one without altering the other,
      clearing just the real part or just the imaginary part, enter or modify a complex number in the X-register without disturbing the rest of the stack (not possible in the HP42S, for instance), and recall a complex number from storage registers into X without disturbing the rest of the stack:

      These useful opertations wouldn't be possible if CLX did a stack drop (or would be much more convoluted), and would thus require some other specific functionalities instead in order to be able to achieve the aforementioned purposes.

      All of this is thoroughly discussed in pages 125-130 (six pages nos less !) of the HP-15C Owner's Handbook.

Best regards from V.


Edited: 18 June 2007, 6:46 a.m.

Hi, Stefan;

The HP17BII and the HP19BII are two examples of calculators with variable size RPN stack (in RPN mode, in this case). They actually have as many stack levels as arguments you enter, in a maximum of four. If you clear the stack, only the X-register exists. For example, if you enter 2 and 3, either [Rv] (roll-down) or [x<>y] (X-exchange-Y) cause exactly the same effect, showing 2 or 3 each time they are pressed. In any case, CLX will actually replace the X-register contents for 0 (zero), but will not cause the stack to 'drop it out'.

I am not sure if there are other RPN calculators that do so. Maybe the HP17BII+, could not test.

Cheers.

Luiz (Brazil)

Edited: 18 June 2007, 7:05 a.m.

OK Thor, one point for you! But with such a pass ...

What I did mean was: RPN started the scientific pocket calc and got a lot of competition in the following years. So if there had been anything wrong with CLx, it would have been corrected in the early years for sure. See x^y for example.

Hi, Antonio --

DROP = [CLx][+] or [CLx][-]

Indeed, I belatedly thought of this last night after I'd logged out as a solution to the functionality that Stefan seemed to favor. Your post would have beaten mine even had I gotten back to it.

I've used this sequence to "purge" a value from the x-register while preserving the t-register for replication. However, CLx should not perform in that manner for reasons already stated.

-- KS

Good point Luiz.

To further clarify:

on the 17bii, if you [shift] [clear data] the stack empties and grows to suit your needs as Luiz stated above.

Hoever, note that stack lift and drop are considered: so that if you do:

4
[ENTER]
5
x

the resulting stack will be:

t {not exist}
z {not exist}
y {not exist}
x 20

During the operation, you used the y-register, but it dropped back to the X-register.

Simliarly, if you do

3
[enter]
2
[enter]
1
+
X

you will get 9, and no stack.

You can tell that the stack is non-existent because roll-down does not bring any zeroes or other numbers.

However, once you actually use the t-register, then the stack becomes a standard 4-register stack--it will not collapse, and all further operations will function as a 4-level stack as usual.

Edited: 18 June 2007, 1:11 p.m. after one or more responses were posted

>>>I am not sure if there are other RPN calculators that do so. Maybe the HP17BII+, could not test.<<<

Luis:

My 17BII+ S/N: CN333015xx behaves like my 19BII.

Bob

Bill:

I think you mean:

3
[enter]
2
[enter]
1
+
X

Bob

Actually, Bill Wickes wrote a book named HP 41/HP 48 Transitions. A scanned .PDF copy of it is available on the current HP Museum CD-ROM set / DVD-ROM.

Although I certainly have a great deal of respect for Bill Wickes, I'm surprised at that statement from him. I suppose that "starting with a clean slate" might be a reason for some to use the CLX key, but I'd be surprised if that were a common practice for most Classic RPN users. Certainly this "use" of CLX had never occurred to me. After all, pressing CLX as the start of a new problem simply means that a zero in register X will be replaced (without changing anything else) instead of whatever already happens to be in register X being replaced (discarding the contents of T and lifting the contents of the previous X, Y, and Z to Y, Z, and T). Certainly if the user cares about the contents of Y, Z, or T, then he's going to take care of that. Why waste the extra CLX keystroke?

If one really wants to "start with a clean slate", then CLST (on a 41) would seem to me a more reasonable choice, as it loads zeros into all stack registers, possibly saving the user the trouble of pushing zeros into all of them. Of course, depending on the model and what the user intends to do next, there may be other areas (such as statistics data) that the user may want to clear for a "clean slate".

Using CLX seems to me analogous to using the CE key instead of the C key on on an algebraic entry model. Certainly using CE doesn't prevent such "features" as "constants operations" on an algebraic model; if you want the "clean slate", then you use the C key.

It seems to me that a much more reasonable primary reason for using CLX would be for when the user realized that he's entered the wrong value, and wants to replace it with the correct value without disturbing anything else, much like using a CE key on an algebraic input model.

Bill Wickes also mentions CLX in various other places in Transitions; notably, "CLX is primarily intended for replacing the contents of X with a new value. By disabling stack lift, the zero CLX enters can be overwritten by a following entry."

On an RPL model, a CLX key would seem rather silly. First off, a stack level can point to any type of object, so replacing the contents of level 1 with the real number zero wouldn't be such an obvious choice. More importantly, on an RPL model, one never writes directly into level 1, so to replace a "zeroed-out" level one, one would have to edit the level 1 object in the command line editor and enter the edited contents. It's easier to simply remove level 1 with a DROP, key in a new value (which automatically activates the command line editor), and enter the new value. Of course, if one wants to abandon the command line editor (discarding any contents), then the CANCEL (or ATTN) key is pressed.

Regards,
James

Edited: 19 June 2007, 3:09 a.m.

Quote:

DROP = [CLx][+] or [CLx][-]



More or less.

8)

Regards,
Howard