RE: Numeric parameters and return values for utility procedures

Am I right in assuming you are suggesting that in the calling program declare a temp field of size of 31, 9. Use this with the utility function and finally copy the data returned in the temp field into the real variable ie. A var of size 14, 4 (or any other size 10, 3 or 7, 4 etc)

For example:
Calling Program:
D answer S 14, 4
D temp S 31, 9

temp = CalculateRate(19.4:3245.5623);
Monitor
answer = temp;
On-Error RESULT_OVERFLOW;
ReportError(Result to Large)
EndMon;

I think that seems to work how I would like. Cheers.

I would be interested to hear what other methods people would suggest? I'm starting to think if I wanted it to be completely modular and completely independent of precision and scale (and avoid temp fields) I would need to declare a standard decimal precision across the board ie. All decimal variables are declared to be 31, 9 (much like Java/C# etc does in the background with it's standard variable type anyway). Due to legacy apps this isn't really an option so I think Chandana's suggestion is a good compromise.

-----Original Message-----
From: rpg400-l-bounces@xxxxxxxxxxxx [mailto:rpg400-l-bounces@xxxxxxxxxxxx] On Behalf Of Chandana Silva
Sent: Monday, 7 September 2009 10:01 AM
To: RPG programming on the IBM i / System i
Subject: Re: Numeric parameters and return values for utility procedures

My two cents :

If the calling program is passing a parm (14,4),  the Return value has to match the same declaration.
I  would declare  a workfield (14,4) in the procedure  do the calculations based on a field size (31,9).
Return the value from workfield.

________________________________
From: Steven Harrison <steven.harrison@xxxxxxxxxxxxxxxxx>
To: RPG400-L@xxxxxxxxxxxx
Sent: Sunday, September 6, 2009 5:52:32 PM
Subject: Numeric parameters and return values for utility procedures

Hi All,



I am writing some new utility modules for our system that will perform
some common math functions. My question is regarding the parameters and
return values for ILE RPG programs.



I like to write the procedures so they can be utilised by any number of
programs with as little dependence on field size as possible. For
example here is a string function I have written in the past:



    P RemoveWhitespaces...

    P                B                  Export



      // Procedure Interface Definition (Parameters)

    D RemoveWhitespaces...

    D                PI        65535    Varying

    D  string                    65535    Varying Const



      // Return Variable

    D result          S          65535    Varying



      // Local Variables

    D position        S                  Like(StdInt) Inz(0)



      /FREE



      result = string;

      position = %Scan(WHITE_SPACE:result);

      DoW position > 0;

          result = %Replace('':result:position:%Len(WHITE_SPACE));

          position = %Scan(WHITE_SPACE:result);

      EndDo;



      return result;



      /END-FREE

    P                E



As you can see this procedure allows the calling program to pass in a
string of any size (up to 65535 at least!) and will return a string
value of any size (up to 65535). So all the following calls will work:



D question        S          2500

D answer          S          5000



answer = RemoveWhitespaces(question);



Or:



D answer          S          150



answer = RemoveWhitespaces('This sentence is a literal and could have
any size.');



My question is how to get this kind of functionality with numeric
functions? How can I declare a procedure that will accept a decimal
argument of any size and return a decimal argument of any size? Likewise
with integer values? I assume the calling program will need to wrap
calls in something like a monitor function to protect against field
overflow (ie. The result is too large to contain in the result field)
but I'm still a little stuck on the best way to declare the field types
in the utility modules. Do I declare something like:



D Decimal        S            31P 9



D CalculateDiscountRate...

D                                  PI        Like(Decimal)

D sellPrice                                Like(Decimal) Const

D productPrice                          Like(Decimal) Const



The problem I see though is with the return value. Say it calculates to
a value of 300.125 and the calling program has a result field of the
size 14,4. Obviously the field is big enough to contain the answer but
the field size is not going to match the size of the return variable
(31, 9). Will the iSeries allow this? Basically I want to mimic the
functionality of say a C# method where you would just use a decimal
field type (which wouldn't have any reliance on the precision of the
actual values as long as they fit within the decimal type).



Any comments or advice would be appreciated.



Steve