A friend of mine runs a pharmacy.   He has a specialized function in his Dispensary application which receives a decimal value of currency and replaces it to a standard value.   This value is regulated by a government department.



Task

Given a floating point value between   0.00   and   1.00,   rescale according to the following table:

>=  0.00  <  0.06  :=  0.10
>=  0.06  <  0.11  :=  0.18
>=  0.11  <  0.16  :=  0.26
>=  0.16  <  0.21  :=  0.32
>=  0.21  <  0.26  :=  0.38
>=  0.26  <  0.31  :=  0.44
>=  0.31  <  0.36  :=  0.50
>=  0.36  <  0.41  :=  0.54
>=  0.41  <  0.46  :=  0.58
>=  0.46  <  0.51  :=  0.62
>=  0.51  <  0.56  :=  0.66
>=  0.56  <  0.61  :=  0.70
>=  0.61  <  0.66  :=  0.74
>=  0.66  <  0.71  :=  0.78
>=  0.71  <  0.76  :=  0.82
>=  0.76  <  0.81  :=  0.86
>=  0.81  <  0.86  :=  0.90
>=  0.86  <  0.91  :=  0.94
>=  0.91  <  0.96  :=  0.98
>=  0.96  <  1.01  :=  1.00



FUNCTION PriceFraction( npQuantDispensed )
    LOCAL aPriceFraction := { {0,.06,.1},;
                            {.06,.11,.18}, ;
                            {.11,.16,.26}, ;
                            {.16,.21,.32}, ;
                            {.21,.26,.38}, ;
                            {.26,.31,.44}, ;
                            {.31,.36,.5}, ;
                            {.36,.41,.54}, ;
                            {.41,.46,.58}, ;
                            {.46,.51,.62}, ;
                            {.51,.56,.66}, ;
                            {.56,.61,.7}, ;
                            {.61,.66,.74}, ;
                            {.66,.71,.78}, ;
                            {.71,.76,.82}, ;
                            {.76,.81,.86}, ;
                            {.81,.86,.9}, ;
                            {.86,.91,.94}, ;
                            {.91,.96,.98} }
    LOCAL nResult
    LOCAL nScan
    IF npQuantDispensed = 0
            nResult = 0
    ELSEIF npQuantDispensed >= .96
            nResult = 1
    ELSE
            nScan := ASCAN( aPriceFraction, ;
                   { |aItem| npQuantDispensed >= aItem[ 1 ] .AND.;
                             npQuantDispensed <  aItem[ 2 ] } )
            nResult := aPriceFraction[ nScan ][ 3 ]
    END IF
    RETURN nResult