Donde puedo sonseguir la lib de Nanforum toolkits (Nanfor.lib)
para solucionar el probelma del round
usando la función es FT_Round().

Gracias

Vladimir :

/
* File......: Round.Prg
* Author....: David Husnian
* CIS ID....: ?
*
* This is an original work by David Husnian and is placed in the
* public domain.
*
* Modification history:
* ---------------------
*
* Rev 1.2 15 Aug 1991 23:05:30 GLENN
* Forest Belt proofread/edited/cleaned up doc
*
* Rev 1.1 14 Jun 1991 19:52:48 GLENN
* Minor edit to file header
*
* Rev 1.0 01 Apr 1991 01:02:08 GLENN
* Nanforum Toolkit
*
/

/ $DOC$
* $FUNCNAME$
* FT_ROUND()
* $CATEGORY$
* Math
* $ONELINER$
* Rounds a number to a specific place
* $SYNTAX$
* FT_ROUND( <nNumber> [, <nRoundToAmount> ;
* [, <cRoundType> [, <cRoundDirection> ;
* [, <nAcceptableError> ] ] ] ] ) -> nNumber
* $ARGUMENTS$
* <nNumber> is the number to round
*
* <nRoundToAmount> is the fraction to round to or the number of places,
* default is 2.
*
* <cRoundType> is the type of rounding desired
*
* "D" for Decimal (3 for thousandth, 1/1000) (default)
* "F" for Fraction (3 for thirds, 1/3)
* "W" for Whole numbers (3 for thousand, 1000)
*
* <cRoundDirection> is the direction to round the number toward
*
* "U" to round Up 1.31 -> 1.4
* -1.31 -> -1.4
* "D" to round Down 1.36 -> 1.3
* -1.36 -> -1.3
* "N" to round Normal 1.5 -> 2
* -1.5 -> -2
* 1.49 -> 1
* -1.49 -> -1
*
* <nAcceptableError> is the amount that is considered acceptable
* to be within, i.e., if you're within this amount of the number
* you don't need to round
* $RETURNS$
* The number, rounded as specified.
* $DESCRIPTION$
* This function will allow you to round a number. The following can
* be specified:
* a. Direction (up, down or normal - normal is 4/5 convention)
* b. Type (whole, decimal, fraction)
* c. Amount (100's, 5 decimals, 16th, etc.)
* $EXAMPLES$
* // round normal to 2 decimal places
* nDollars := FT_ROUND(nDollars)
*
* // round normal to 6 decimal places
* nIntRate := FT_ROUND(nIntRate, 6)
*
* // round to nearest thousands
* nPrice := FT_ROUND(nPrice, 3, NEAREST_WHOLE_NUMBER)
*
* // round Up to nearest third
* nAmount := FT_ROUND(nAmount, 3, NEAREST_FRACTION, ROUND_UP)
*
* // round down to 3 decimals Within .005
* nAvg := FT_ROUND(nAvg, 3, , ROUND_DOWN, .005)
* $END$
/

define IS_NEGATIVE(x) ((x) < 0)

define NEAREST_DECIMAL "D"

define NEAREST_FRACTION "F"

define NEAREST_WHOLE_NUMBER "W"

define ROUND_DOWN "D"

define ROUND_NORMAL "N"

define ROUND_UP "U"

command DEFAULT <Param1> TO <Def1> [, <ParamN> TO <DefN> ] ;

        => ;
        <Param1> := IF(<Param1> == NIL,<Def1>,<Param1>) ;
     [; <ParamN> := IF(<ParamN> == NIL,<DefN>,<ParamN>)]

command DEFAULT <Param1> TO <Def1> IF NOT <Type1> ;

             [, <ParamN> TO <DefN> IF NOT <TypeN> ] ;
        => ;
        <Param1> := IF(VALTYPE(<Param1>) == <Type1>,<Param1>,<Def1>) ;
     [; <ParamN> := IF(VALTYPE(<ParamN>) == <TypeN>,<ParamN>,<DefN>)]

FUNCTION FT_ROUND(nNumber, nRoundToAmount, cRoundType, cRoundDirection, ;
nAcceptableError)

LOCAL nResult := ABS(nNumber) // The Result of the Rounding

DEFAULT nRoundToAmount TO 2, ;
cRoundType TO NEAREST_DECIMAL, ;
cRoundDirection TO ROUND_NORMAL, ;
nAcceptableError TO 1 / (nRoundToAmount ** 2)

                                    // Are We Rounding to the Nearest Whole
                                    // Number or to Zero Decimal Places??

IF (LEFT(cRoundType,1) != NEAREST_WHOLE_NUMBER .AND. ;
(nRoundToAmount := INT(nRoundToAmount)) != 0)

                                    // No, Are We Rounding to the Nearest
                                    // Decimal Place??
  IF (LEFT(cRoundType,1) == NEAREST_DECIMAL)

                                    // Yes, Convert to Nearest Fraction
     nRoundToAmount := 10 ** nRoundToAmount

  ENDIF                             // LEFT(cRoundType,1) == NEAREST_DECIMAL

                                    // Are We Already Within the Acceptable
                                    // Error Factor??
  IF (ABS(INT(nResult * nRoundToAmount) - (nResult * nRoundToAmount)) > ;
      nAcceptableError)
                                    // No, Are We Rounding Down??
     nResult -= IIF(LEFT(cRoundDirection,1) == ROUND_DOWN, ;
                                  ; // Yes, Make Downward Adjustment
                    1 / nRoundToAmount / 2, ;
                                  ; // Are We Rounding Up??
                    IIF(LEFT(cRoundDirection,1) == ROUND_UP , ;
                                  ; // Yes, Make Upward Adjustment
                        -1 / (nRoundToAmount) / 2, ;
                                  ; // No, Rounding Normal, No Adjustment
                        0))
                                    //Do the Actual Rounding
     nResult := INT((nRoundToAmount * nResult) + .5 + nAcceptableError) / ;
                nRoundToAmount

  ENDIF                             // ABS(INT(nResult * nRoundToAmount) -
                                    //     (mResult * nRoundAmount)) >
                                    // nAcceptableError

ELSE // Yes, Round to Nearest Whole Number
// or to Zero Places

  nRoundToAmount := MAX(nRoundToAmount, 1)

  DO CASE                           // Do "Whole" Rounding

     CASE LEFT(cRoundDirection,1) == ROUND_UP

        nResult := (INT(nResult / nRoundToAmount) * nRoundToAmount) + ;
                   nRoundToAmount

     CASE LEFT(cRoundDirection,1) = ROUND_DOWN

        nResult := INT(nResult / nRoundToAmount) * nRoundToAmount

     OTHERWISE                      // Round Normally

        nResult := INT((nResult + nRoundToAmount / 2) / nRoundToAmount) * ;
                   nRoundToAmount

  ENDCASE

ENDIF // LEFT(cRoundType,1)!=NEAREST_WHOLE or
// nRoundToAmount == 0
IF IS_NEGATIVE(nNumber) // Was the Number Negative??
nResult := -nResult // Yes, Make the Result Negative Also
ENDIF // IS_NEGATIVE(nNumber)

RETURN (nResult) // FT_Round

Saludos