Power-of-two fraction handling for the 41C

[quantalume]

I was wondering if there is a program available that converts from decimal to fractions but limits itself to a user-defined power of two in the denominator. For example, if my power-of-two limit is 32 and I have a decimal number of 1.3525, then my conversion would be 1-11/32. Likewise, if my denominator limit is 64, the answer would be 1-23/64. The smallest denominator should always be used; for example, if the decimal number is 1.25, the answer would be 1-1/4, even if the denominator limit is 8 or higher. An added useful feature would be always representing the denominator in the given power of two upon setting of a flag; for example FS 04, then 1.25 = 1-16/64.

Does such a program exist, or should I write this?

[Dieter]

(01-31-2016 09:45 PM)quantalume Wrote:  I was wondering if there is a program available that converts from decimal to fractions but limits itself to a user-defined power of two in the denominator

That's easy – if the denominator is a power of 2 (or another base) all factors of this are 2 as well. So you could use the respective setting of calculators with fraction function, for instance the 35s.

As far as the 41-series is concerned...

(01-31-2016 09:45 PM)quantalume Wrote:  Does such a program exist, or should I write this?

Yes, it exists – I just wrote one. ;-)
Yes, you should write your own as well – it's fun.

32 [STO] 00

1,3525 [R/S]   1 11/32
[<–] 1,3438

64 [STO] 00

1,3525 [R/S] 1 23/64
[<–] 1,3594

1,25 [R/S]   1 1/4
[<–] 1,2500

[SF] 04
1,25 [R/S]   1 16/64
[<–] 1,2500

Dieter

[Dwight Sturrock]

http://www.hpmuseum.org/software/42decinc.htm

[quantalume]

(01-31-2016 11:24 PM)Dieter Wrote:  

(01-31-2016 09:45 PM)quantalume Wrote:  Does such a program exist, or should I write this?

Yes, it exists – I just wrote one. ;-)
Yes, you should write your own as well – it's fun.

OK, I shall then. We can compare code when I finish.

[quantalume]

(02-01-2016 01:23 AM)Dwight Sturrock Wrote:  http://www.hpmuseum.org/software/42decinc.htm

That's a good start. I also looked at the AECROM unit-of-length feature. They are both limited to 1/16 as the finest division, however.

[Dieter]

(02-01-2016 02:06 AM)quantalume Wrote:  OK, I shall then. We can compare code when I finish.

Fine. Here's my version:

Code:

01 LBL "D2F"
02 RCL 00
03 *
04 FIX 0
05 CF 29
06 RND
07 RCL 00
08 FS? 04
09 GTO 02
10 RCL Y
11 RCL Y
12 LBL 01
13 MOD
14 LASTX
15 X<>Y
16 X≠0?
17 GTO 01
18 +
19 ST/ Z
20 /
21 LBL 02
22 RCL Y
23 RCL Y
24 /
25 ENTER
26 INT
27 " "
28 ARCL X
29 RDN
30 RDN
31 MOD
32 LASTX
33 "├ "
34 ARCL Y
35 "├/"
36 ARCL X
37 R↑
38 FIX 4
39 SF 29
40 AVIEW
41 END

Usage:
Store the maximum denominator in R00. No other data registers are used.
Set flag 04 if you want a fixed denominator, otherwise the fraction with the minimum denominator is returned.

64 STO 00
1,3525 XEQ"D2F"  =>  1 23/64

The rounded result is returned in X, the other stack registers hold the three values of the result.

T: 1
Z: 23
Y: 64
X: 1,359375

Variations:
The program can be easily modified to accept the max. denominator on the stack (fraction ENTER denominator XEQ"D2F") and/or return improper fractions (87/64 in this case).

Dieter

[quantalume]

OK, here is what I came up with. I avoided looking at your solution before I was finished.

Code:

01 LBL "TOF"
02 ENTER
03 FIX 0
04 INT
05 CLA
06 ARCL X
07 RDN
08 FRC
09 RCL 00
10 STO 01
11 *
12 0.5
13 X>Y?
14 GTO 04
15 RDN
16 FC? 04
17 GTO 02
18 ENTER
19 GTO 03
20 LBL 01
21 RDN
22 LBL 02
23 ENTER
24 RND
25 2
26 MOD
27 X≠0?
28 GTO 03
29 2
30 ST/ 01
31 RDN
32 RDN
33 2
34 /
35 GTO 02
36 LBL 03
37 RDN
38 "├ "
39 ARCL X
40 "├/"
41 ARCL 01
42 LBL 04
43 AVIEW
44 END

I like your solution better as it is shorter, doesn't use an extra register and leaves the stack in a more-desirable state. You also take advantage of flag 29 to eliminate the decimal mark from the result. The only thing nice to add would be saving and recalling flag register d in order to return the calculator to the original mode setting, rather than assuming it was in FIX 4.

[quantalume]

I like to avoid dependencies, even on the CX function set. Trouble is, I'm finding it difficult to include a RCL d/STO d in Dieter's program without making it messy or disturbing the final stack.

[quantalume]

Well, it would be easy enough to put a RCL d, STO 01 at the start of the program. However, by doing a RCL 01, STO d after the last ARCL, I lose one of the results off the top of the stack that Dieter is returning. It could be done, but it messes up his elegant program.

[quantalume]

I took Dieter's code and added a check for the trivial case of calling the function with an integer. It now returns just the integer rather than the integer + "0/1". I won't bother saving/recalling flags as I keep the calculator in FIX 4 most of the time anyway. Hopefully Dieter will be along soon to clean up the mess I made of his code. It now has too many labels and jumps for my liking.

Code:

01 LBL "D2F"
02 RCL 00
03 *
04 FIX 0
05 CF 29
06 RND
07 RCL 00
08 FS? 04
09 GTO 02
10 RCL Y
11 RCL Y
12 LBL 01
13 MOD
14 LASTX
15 X<>Y
16 X≠0?
17 GTO 01
18 +
19 ST/ Z
20 /
21 LBL 02
22 RCL Y
23 RCL Y
24 /
25 ENTER
26 INT
27 " "
28 ARCL X
29 RDN
30 RDN
31 MOD
32 X=0?
33 GTO 03
34 LASTX
35 "├ "
36 ARCL Y
37 "├/"
38 ARCL X
39 GTO 04
40 LBL 03
41 LASTX
42 LBL 04
43 R↑
44 FIX 4
45 SF 29
46 AVIEW
47 END

[Dieter]

(02-01-2016 06:47 PM)quantalume Wrote:  Well, it would be easy enough to put a RCL d, STO 01 at the start of the program. However, by doing a RCL 01, STO d after the last ARCL, I lose one of the results off the top of the stack that Dieter is returning. It could be done, but it messes up his elegant program.

The problem is not the messed up stack – this can be avoided by using X<> commands. The problem is that both RCL and X<> normalize numbers, so that the original content of register d that was saved here, is altered before it can be stored back in d. This does not happen on the stack or in status registers, but the complete stack is used by the program.

Hmmm... there might be a way. The program could set/clear flags 0...3 so that the first nibble of d becomes 1001, indicating this is an alpha string. Which might avoid the normalisation procedure. Maybe the experts can say more here.

Another option is changing the program so that it uses one additional data register while d is kept on the stack. I think this should work.

Anyway, I just added support for improper fractions. Since the program so far does not handle negative input, an ABS at the start also makes sense (just to be sure...).

Dieter

[Dieter]

(02-01-2016 08:43 PM)quantalume Wrote:  I took Dieter's code and added a check for the trivial case of calling the function with an integer. It now returns just the integer rather than the integer + "0/1".
(...)
Hopefully Dieter will be along soon to clean up the mess I made of his code. It now has too many labels and jumps for my liking.

That's why I prefer flags here. Just clear or set e.g. flag 05 if MOD yields zero and skip the x/y output routine.

(02-01-2016 08:43 PM)quantalume Wrote:  I won't bother saving/recalling flags as I keep the calculator in FIX 4 most of the time anyway.

Great – this avoids several problems I mentioned in my other post. Which does not mean it cannot be done... ;-)

Here's a new version that uses flag 02 to switch between constant or minimized denominator, and flag 01 toggles between proper and improper fractions (in this case integer input is returned as x/1 instead of just x).

Code:

01 LBL "D2F"
02 ABS
03 RCL 00
04 *
05 FIX 0
06 CF 29
07 RND
08 RCL 00
09 FS? 02
10 GTO 02
11 RCL Y
12 RCL Y
13 LBL 01
14 MOD
15 LASTX
16 X<>Y
17 X≠0?
18 GTO 01
19 +
20 ST/ Z
21 /
22 LBL 02
23 " "
24 RCL Y
25 RCL Y
26 /
27 FS? 01
28 GTO 03
29 ENTER
30 INT
31 ARCL X
32 RDN
33 RDN
34 MOD
35 CF 05
36 X=0?
37 SF 05
38 LASTX
39 R↑
40 FS?C 05
41 GTO 04
42 "├ "
43 LBL 03
44 ARCL Z
45 "├/"
46 ARCL Y
47 LBL 04
48 FIX 4
49 SF 29
50 AVIEW
51 END

And maybe we can also get this RCL d thing working... ;-)

Dieter

[quantalume]

(02-01-2016 09:10 PM)Dieter Wrote:  

(02-01-2016 06:47 PM)quantalume Wrote:  Well, it would be easy enough to put a RCL d, STO 01 at the start of the program. However, by doing a RCL 01, STO d after the last ARCL, I lose one of the results off the top of the stack that Dieter is returning. It could be done, but it messes up his elegant program.

The problem is not the messed up stack – this can be avoided by using X<> commands. The problem is that both RCL and X<> normalize numbers, so that the original content of register d that was saved here, is altered before it can be stored back in d. This does not happen on the stack or in status registers, but the complete stack is used by the program.

Ok, I was operating under the assumption that the register only becomes normalized when you try to use it in an arithmetic operation. The PPC ROM has a couple of functions for saving and restoring display mode, but unfortunately they utilize the alpha register. Seems like the best bet is to keep the flags on the stack.

[Dieter]

(02-01-2016 09:36 PM)Dieter Wrote:  And maybe we can also get this RCL d thing working... ;-)

Here is a version that adds some benefits:

• Mode settings (register d) are preserved.
• Output can be displayed as a mixed number or improper fraction.
  Clear resp. set flag 01.
• Denominator can be minimized or fixed.
  Clear resp. set flag 02.
• Input can be positive or negative.
• Integer output is displayed without "0/1" part.
  

And here is the code:

Code:

01  LBL"D2F"  
02  RCL d     
03  X<>Y      ' Save status register on stack
04  CF 05     
05  X<0?      
06  SF 05     ' Set sign flag
07  ABS       
08  RCL 00    ' A simple constant like 32 or 64 can be used here as well
09  STO 02    ' Store denominator in R02
10  *         
11  FIX 0     
12  CF 29     
13  RND       
14  STO 01    ' Store nominator in R01
15  FS? 02    ' Constant denominator mode?
16  GTO 02    ' Then skip GCD calculation
17  RCL 02    
18  LBL 01    ' Use Euclidean algorithm
19  MOD       ' to compute gcd(R01, R02)
20  LASTX     
21  X<>Y      
22  X≠0?      
23  GTO 01    
24  +         ' = GCD
25  ST/ 01    ' reduce fraction
26  ST/ 02    
27  LBL 02    
28  CLX       ' Set integer part "a" = 0
29  FS? 01    ' Improper fraction mode?
30  GTO 03    ' Then skip conversion to mixed number
31  RDN       
32  RCL 01    
33  RCL 02    
34  MOD       ' Compute "b" = nominator mod denominator
35  X<> 01    ' and store it in R01
36  RCL 02    
37  /         
38  INT       ' Compute "a" = nominator DIV denominator
39  FS? 05    ' If input was negative
40  CHS       ' adjust sign of integer part
41  LBL 03    ' Start of formatting routine for result "a b/c"
42  CLA       ' Here "a" is in X while "b" and "c" are in R01 and R02
43  X=0?      ' if a = 0
44  GTO 04    ' do not display it
45  X>0?      ' else if a ≥ 0
46  " "       ' start with a blank
47  ARCL X    ' then append integer part to output string
48  LBL 04    
49  RCL 01    
50  FS? 05    ' if input was negative
51  CHS       ' adjust sign of nominator
52  STO 01    
53  X=0?      ' if nominator = 0
54  GTO 05    ' skip adding b/c
55  X>0?      ' else if nominator ≥ 0
56  "├ "      ' append a blank
57  ARCL 01   ' append nominator,
58  "├/"      ' fraction bar
59  ARCL 02   ' and denominator
60  LBL 05    ' At this point the output line is complete
61  RCL 02    ' Now calculate a + b/c
62  ST/ 01    ' R01 = b/c
63  R↑        ' Recall status bits from stack
64  STO d     ' and restore original mode settings
65  RDN       
66  RCL Z     ' add integer part
67  ST+ 01    ' to R01
68  X<> 01    ' and move result = a + b/c to X
69  X=0?      ' The (AFAIK) only case that's not handled properly
70  " 0"      ' is x=0, so use a pragmatic solution. ;-)
71  AVIEW     ' Display result
72  END       ' Quit with a, b, c and a+b/c on the stack.

Here are some examples:

Code:

 64   [STO] 00
      [CF] 01
      [CF] 02

 1,35 XEQ"D2F"     1 11/32

      [SF] 02
 1,35 XEQ"D2F"     1 22/64

      [SF] 01
      [CF] 02

-2,5  XEQ"D2F"    -5/2

      [CF] 01
-2,5  XEQ"D2F"    -2-1/2

 0,17 XEQ"D2F"     11/64

 3    XEQ"D2F"     3

Note: in improper fraction mode integer results are returned as x/1.

Now try this version and see what you get. There may be errors, so as usual all remarks and error reports are welcome.

Dieter

[quantalume]

(02-02-2016 08:21 PM)Dieter Wrote:  

(02-01-2016 09:36 PM)Dieter Wrote:  And maybe we can also get this RCL d thing working... ;-)

Here is a version that adds some benefits:

• Mode settings (register d) are preserved.
• Output can be displayed as a mixed number or improper fraction.
  Clear resp. set flag 01.
• Denominator can be minimized or fixed.
  Clear resp. set flag 02.
• Input can be positive or negative.
• Integer output is displayed without "0/1" part.
  

Wow, this is really nice! I have not been able to find any errors in testing. I did make one small change. So as not to display the sign twice for negative output expressed as mixed numbers (this is just a personal preference), I replaced lines 50 and 51 with:

Code:

50 FC? 05
51 GTO 06
52 FS? 01
53 CHS
54 LBL 06

I appreciate the work you put into this, and I will definitely get daily use out of it. You should create an article in the 41C software library section once you're happy with the program.

[Dieter]

(02-02-2016 09:35 PM)quantalume Wrote:  Wow, this is really nice! I have not been able to find any errors in testing. I did make one small change. So as not to display the sign twice for negative output expressed as mixed numbers (this is just a personal preference), I replaced lines 50 and 51 with:

Code:

50 FC? 05
51 GTO 06
52 FS? 01
53 CHS
54 LBL 06

Logically this tests if both flag flag 05 and flag 01 are set. This can be accomplished without labels in a composite test, the last one returning "always false":

Code:

FS? 05
FC? 01
FS? 54
CHS

BUT... this messes up the stack output. The idea behind the double sign was that the value of the rounded fraction should equal T + Z/Y, and this is returned in X. Try it for negative input, and you'll see it doesn't work.

I think the following version works better and the result should be displayed the way you prefer. It's even one line shorter.

Code:

01  LBL"D2F"  
02  RCL d     
03  X<>Y      ' Save status register on stack
04  CF 05     
05  X<0?      
06  SF 05     ' Set sign flag
07  ABS       
08  RCL 00    ' A simple constant like 32 or 64 can be used here as well
09  STO 02    ' Store denominator in R02
10  *         
11  FIX 0     
12  CF 29     
13  RND       
14  STO 01    ' Store nominator in R01
15  FS? 02    ' Constant denominator mode?
16  GTO 02    ' Then skip GCD calculation
17  RCL 02    
18  LBL 01    ' Use Euclidean algorithm
19  MOD       ' to compute gcd(R01, R02)
20  LASTX     
21  X<>Y      
22  X≠0?      
23  GTO 01    
24  +         ' = GCD
25  ST/ 01    ' reduce fraction
26  ST/ 02    
27  LBL 02    
28  CLX       ' Set integer part "a" = 0
29  FS? 01    ' Improper fraction mode?
30  GTO 03    ' Then skip conversion to mixed number
31  RDN       
32  RCL 01    
33  RCL 02    
34  MOD       ' compute "b" = nominator mod denominator
35  X<> 01    ' and store it in R01
36  RCL 02    
37  /         
38  INT       ' compute "a" = nominator DIV denominator
39  LBL 03    ' Start of formatting routine for result "a b/c"
40  " "       ' Here "a" is in X while "b" and "c" are in R01 and R02
41  FS? 05    ' Start with a blank or minus sign
42  "-"       
43  X=0?      ' if a = 0
44  GTO 04    ' do not display it
45  ARCL X    ' else append it
46  "├ "      
47  FS? 05    ' adjust sign of integer part a
48  CHS       
49  LBL 04    
50  RCL 01    
51  FS? 05    ' adjust sign of nominator b
52  CHS       
53  X=0?      ' if nominator = 0
54  GTO 05    ' skip adding b/c
55  ARCL 01   ' else append unsigned nominator,
56  "├/"      ' append fraction bar
57  ARCL 02   ' and denominator
58  LBL 05    ' At this point the output line is complete
59  STO 01    ' Store sign-adjusted nominator
60  RCL 02    ' Calculate a + b/c
61  ST/ 01    ' R01 = b/c
62  R↑        ' Recall status bits from stack
63  STO d     ' and restore original mode settings
64  RDN       
65  RCL Z     ' add integer part
66  ST+ 01    ' to R01
67  X<> 01    ' and move result = a + b/c to X
68  X=0?      ' The (AFAIK) only case that's not handled properly
69  " 0"      ' is x=0, so use a pragmatic solution. ;-)
70  AVIEW     ' Display result
71  END       ' Quit with a, b, c and a+b/c on the stack.

As usual: try it and see if it works for you. All error reports are welcome.

Dieter

[4ster]

I really like Dieter's first version (below) since it is compact and I don't mind the occasional "0/1" fraction portion of the answer. After having it on my calculator for a while I bought a "Thermal & Transport Science Pac" module. An unexpected (for me) feature of the module is that it has a fairly powerful unit management system that can be incorporated into user programs. After playing with it a while it dawned on me that with some simple additions to Dieter's program I could do full, fractional conversions to imperial unit systems.

See the "Thermal & Transport Science Pac" manual for details on how the conversion system works.

Conversion examples, entered in the alpha register before running D2F:
CM-IN (centimeters to inches with 1/8, 1/16, 1/32... precision by storing 8, 16, 32... in R00)
M-YD (meters to yards and feet, by storing 3 in R00)
KG-LBM (kilogram to pounds and ounces of mass by storing 16 in R00)

I made the following additions to Dieter's program:
At line 02, 5 lines are inserted:
FS? 01
EXQ 03 (If flag 01 is set a unit conversion is run on the input before being fractionalized)
FS? 55
VIEW X (if a printer is present it prints the converted, digital, input)
ASTO 01 (stores unit conversion string to put back into the alpha register at the program's end)

At line 27 insert:
CLA (to clear the alpha register of the conversion string)

At line 40 insert:
CLA (clears the alpha register of the fractionalized answer)
ARCL 01 (Puts the unit conversion string back into alpha so its ready for another input.)
GTO 04
LBL 03
VIEW X (prints the input)
AVIEW (prints the conversion type to be be run)
-SI (The unit conversion sub-routine on the Thermal module)
RTN
LBL 04
END

Usage:

If I want to run the unit conversion before fractionalizing the number I enter the unit conversion string into alpha and set flag 01.
Note that since register 1 is temporarily used to store the alpha string of the unit conversion, that string is limited to 6 characters. KG-LBM is fine, KGF-LBF (kilogram force to pound force) is seven characters so will not work. Most of the valid conversions strings are 6 characters or less. If a printer is attached, the program prints four items: the original input, the conversion string used, the conversion, and the fractionalized conversion.

(02-01-2016 07:10 AM)Dieter Wrote:  

(02-01-2016 02:06 AM)quantalume Wrote:  OK, I shall then. We can compare code when I finish.

Fine. Here's my version:

Code:

01 LBL "D2F"
02 RCL 00
03 *
04 FIX 0
05 CF 29
06 RND
07 RCL 00
08 FS? 04
09 GTO 02
10 RCL Y
11 RCL Y
12 LBL 01
13 MOD
14 LASTX
15 X<>Y
16 X≠0?
17 GTO 01
18 +
19 ST/ Z
20 /
21 LBL 02
22 RCL Y
23 RCL Y
24 /
25 ENTER
26 INT
27 " "
28 ARCL X
29 RDN
30 RDN
31 MOD
32 LASTX
33 "├ "
34 ARCL Y
35 "├/"
36 ARCL X
37 R↑
38 FIX 4
39 SF 29
40 AVIEW
41 END

Usage:
Store the maximum denominator in R00. No other data registers are used.
Set flag 04 if you want a fixed denominator, otherwise the fraction with the minimum denominator is returned.

64 STO 00
1,3525 XEQ"D2F"  =>  1 23/64

The rounded result is returned in X, the other stack registers hold the three values of the result.

T: 1
Z: 23
Y: 64
X: 1,359375

Variations:
The program can be easily modified to accept the max. denominator on the stack (fraction ENTER denominator XEQ"D2F") and/or return improper fractions (87/64 in this case).

Dieter