⚠️ Warning: This is a draft ⚠️

This means it might contain formatting issues, incorrect code, conceptual problems, or other severe issues.

If you want to help to improve and eventually enable this page, please fork RosettaGit's repository and open a merge request on GitHub.

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

type Price is delta 0.01 digits 3 range 0.0..1.0;
function Scale (Value : Price) return Price is
X : constant array (1..19) of Price :=
(  0.06, 0.11, 0.16, 0.21, 0.26,  0.31, 0.36, 0.41, 0.46, 0.51,
0.56, 0.61, 0.66, 0.71, 0.76,  0.81, 0.86, 0.91, 0.96
);
Y : constant array (1..20) of Price :=
(  0.10, 0.18, 0.26, 0.32, 0.38,  0.44, 0.50, 0.54, 0.58, 0.62,
0.66, 0.70, 0.74, 0.78, 0.82,  0.86, 0.90, 0.94, 0.98, 1.0
);
Low    : Natural := X'First;
High   : Natural := X'Last;
Middle : Natural;
begin
loop
Middle := (Low + High) / 2;
if Value = X (Middle) then
return Y (Middle + 1);
elsif Value < X (Middle) then
if Low = Middle then
return Y (Low);
end if;
High := Middle - 1;
else
if High = Middle then
return Y (High + 1);
end if;
Low := Middle + 1;
end if;
end loop;
end Scale;

The solution uses fixed point type to prevent rounding and representation issues. With the above declarations a full coverage test:

procedure Test_Price_Fraction is
-- Put the declarations here
Value : Price := Price'First;
begin
loop
Put_Line (Price'Image (Value) & "->" & Price'Image (Scale (Value)));
exit when Value = Price'Last;
Value := Price'Succ (Value);
end loop;
end Test_Price_Fraction;

{{out}}

0.00-> 0.10
0.01-> 0.10
0.02-> 0.10
0.03-> 0.10
0.04-> 0.10
0.05-> 0.10
0.06-> 0.18
0.07-> 0.18
0.08-> 0.18
0.09-> 0.18
0.10-> 0.18
0.11-> 0.26
0.12-> 0.26
0.13-> 0.26
0.14-> 0.26
0.15-> 0.26
0.16-> 0.32
0.17-> 0.32
0.18-> 0.32
0.19-> 0.32
0.20-> 0.32
0.21-> 0.38
0.22-> 0.38
0.23-> 0.38
0.24-> 0.38
0.25-> 0.38
0.26-> 0.44
0.27-> 0.44
0.28-> 0.44
0.29-> 0.44
0.30-> 0.44
0.31-> 0.50
0.32-> 0.50
0.33-> 0.50
0.34-> 0.50
0.35-> 0.50
0.36-> 0.54
0.37-> 0.54
0.38-> 0.54
0.39-> 0.54
0.40-> 0.54
0.41-> 0.58
0.42-> 0.58
0.43-> 0.58
0.44-> 0.58
0.45-> 0.58
0.46-> 0.62
0.47-> 0.62
0.48-> 0.62
0.49-> 0.62
0.50-> 0.62
0.51-> 0.66
0.52-> 0.66
0.53-> 0.66
0.54-> 0.66
0.55-> 0.66
0.56-> 0.70
0.57-> 0.70
0.58-> 0.70
0.59-> 0.70
0.60-> 0.70
0.61-> 0.74
0.62-> 0.74
0.63-> 0.74
0.64-> 0.74
0.65-> 0.74
0.66-> 0.78
0.67-> 0.78
0.68-> 0.78
0.69-> 0.78
0.70-> 0.78
0.71-> 0.82
0.72-> 0.82
0.73-> 0.82
0.74-> 0.82
0.75-> 0.82
0.76-> 0.86
0.77-> 0.86
0.78-> 0.86
0.79-> 0.86
0.80-> 0.86
0.81-> 0.90
0.82-> 0.90
0.83-> 0.90
0.84-> 0.90
0.85-> 0.90
0.86-> 0.94
0.87-> 0.94
0.88-> 0.94
0.89-> 0.94
0.90-> 0.94
0.91-> 0.98
0.92-> 0.98
0.93-> 0.98
0.94-> 0.98
0.95-> 0.98
0.96-> 1.00
0.97-> 1.00
0.98-> 1.00
0.99-> 1.00
1.00-> 1.00

AutoHotkey

; Submitted by MasterFocus --- http://tiny.cc/iTunis

Loop
{
InputBox, OutputVar, Price Fraction Example, Insert the value to be rounded.`n* [ 0 < value < 1 ]`n* Press ESC or Cancel to exit, , 200, 150
If ErrorLevel
Break
MsgBox % "Input: " OutputVar "`nResult: " PriceFraction( OutputVar )
}

;-----------------------------------------

PriceFraction( p_Input )
{

If p_Input is not float ; returns 0 if input is not a float
Return 0

If ( ( p_Input <= 0 ) OR ( p_Input >= 1 ) ) ; returns 0 is input is out of range
Return 0

; declaring the table (arbitrary delimiters in use are '§' and '|')
l_List := "0.06|0.10§0.11|0.18§0.16|0.26§0.21|0.32§0.26|0.38§0.31|0.44§0.36|0.50§0.41|0.54§0.46|0.58§0.51|0.62§0.56|0.66§0.61|0.70§0.66|0.74§0.71|0.78§0.76|0.82§0.81|0.86§0.86|0.90§0.91|0.94§0.96|0.98§1.01|1.00"

Loop, Parse, l_List, § ; retrieves each field (delimited by '§')
{
StringSplit, l_Array, A_LoopField, | ; splits current field (using delimiter '|')
If ( p_Input <= l_Array1 )
Return l_Array2 ; returns the second value if input <= first value
}

Return 0 ; returns 0, indicating failure (shouldn't be reached though)

}

ALGOL 68

{{trans|C}} - note: This specimen retains the original [[Price Fraction#C|C]] coding style.

{{works with|ALGOL 68|Revision 1 - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}} {{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - specimen requires formatted transput}}

main:
(
# Just get a random price between 0 and 1 #
# srand(time(NIL)); #
REAL price := random;
REAL tops := 0.06;
REAL std val := 0.10;

# Conditionals are a little odd here "(price-0.001 < tops AND
price+0.001 > tops)" is to check if they are equal. Stupid
C floats, right?   :) #
WHILE ( price>tops OR (price-0.001 < tops AND price+0.001 > tops) ) AND tops<=1.01
DO
tops+:=0.05;

IF std val < 0.26 THEN
std val +:= 0.08
ELIF std val < 0.50 THEN
std val +:= 0.06
ELSE
std val +:= 0.04
FI;

IF std val > 0.98 THEN
std val := 1.0
FI
OD;

printf((\$"Value :   "z.2dl,"Converted to standard :   "z.2dl\$, price, std val))
)

{{out}}

Value :   0.38
Converted to standard :   0.54

AWK

BEGIN {
O = ".06 .11 .16 .21 .26 .31 .36 .41 .46 .51 .56 .61 .66 .71 .76 .81 .86 .91 .96 1.01"
N = ".10 .18 .26 .32 .38 .44 .50 .54 .58 .62 .66 .70 .74 .78 .82 .86 .90 .94 .98 1.00"
fields = split(O,Oarr," ") # original values
split(N,Narr," ") # replacement values
for (i=-.01; i<=1.02; i+=.01) { # test
printf("%5.2f = %4.2f\n",i,lookup(i))
}
}
function lookup(n,  i) {
if (n < 0 || n > 1.01) {
return(0) # when input is out of range
}
for (i=1; i<=fields; i++) {
# +10 is used because .11 returned .18 instead of .26
# under AWK95, GAWK, and MAWK; Thompson Automation's TAWK worked correctly
if (n+10 < Oarr[i]+10) {
return(Narr[i])
}
}
}

BASIC

{{works with|QBasic}}

This could also be done by building an array, but I felt that this was simpler.

DECLARE FUNCTION PriceFraction! (price AS SINGLE)

RANDOMIZE TIMER
DIM x AS SINGLE
x = RND
PRINT x, PriceFraction(x)

FUNCTION PriceFraction! (price AS SINGLE)
'returns price unchanged if invalid value
SELECT CASE price
CASE IS < 0!
PriceFraction! = price
CASE IS < .06
PriceFraction! = .1
CASE IS < .11
PriceFraction! = .18
CASE IS < .16
PriceFraction! = .26
CASE IS < .21
PriceFraction! = .32
CASE IS < .26
PriceFraction! = .38
CASE IS < .31
PriceFraction! = .44
CASE IS < .36
PriceFraction! = .5
CASE IS < .41
PriceFraction! = .54
CASE IS < .46
PriceFraction! = .58
CASE IS < .51
PriceFraction! = .62
CASE IS < .56
PriceFraction! = .66
CASE IS < .61
PriceFraction! = .7
CASE IS < .66
PriceFraction! = .74
CASE IS < .71
PriceFraction! = .78
CASE IS < .76
PriceFraction! = .82
CASE IS < .81
PriceFraction! = .86
CASE IS < .86
PriceFraction! = .9
CASE IS < .91
PriceFraction! = .94
CASE IS < .96
PriceFraction! = .98
CASE IS < 1.01
PriceFraction! = 1!
CASE ELSE
PriceFraction! = price
END SELECT
END FUNCTION

{{out}} (run 5 times): .7388727 .82 .8593103 .9 .826687 .9 .3444635 .5 .0491907 .1

BBC BASIC

PRINT FNpricefraction(0.5)
END

DEF FNpricefraction(p)
IF p < 0.06 THEN = 0.10
IF p < 0.11 THEN = 0.18
IF p < 0.16 THEN = 0.26
IF p < 0.21 THEN = 0.32
IF p < 0.26 THEN = 0.38
IF p < 0.31 THEN = 0.44
IF p < 0.36 THEN = 0.50
IF p < 0.41 THEN = 0.54
IF p < 0.46 THEN = 0.58
IF p < 0.51 THEN = 0.62
IF p < 0.56 THEN = 0.66
IF p < 0.61 THEN = 0.70
IF p < 0.66 THEN = 0.74
IF p < 0.71 THEN = 0.78
IF p < 0.76 THEN = 0.82
IF p < 0.81 THEN = 0.86
IF p < 0.86 THEN = 0.90
IF p < 0.91 THEN = 0.94
IF p < 0.96 THEN = 0.98
= 1.00

Bracmat

Bracmat has no native support for floating point variables nor for the fixed point values in the conversion table. Instead this solution just applies a string comparison.

( ( convert
=
.         ("0.06"."0.10")
("0.11"."0.18")
("0.16"."0.26")
("0.21"."0.32")
("0.26"."0.38")
("0.31"."0.44")
("0.36"."0.50")
("0.41"."0.54")
("0.46"."0.58")
("0.51"."0.62")
("0.56"."0.66")
("0.61"."0.70")
("0.66"."0.74")
("0.71"."0.78")
("0.76"."0.82")
("0.81"."0.86")
("0.86"."0.90")
("0.91"."0.94")
("0.96"."0.98")
("1.01"."1.00")
: ? (>!arg.?arg) ?
& !arg
| "invalid input"
)
& -1:?n
&   whl
' ( !n+1:?n:<103
& ( @(!n:? [<2)&str\$("0.0" !n):?a
| @(!n:? [<3)&str\$("0." !n):?a
|   @(!n:?ones [-3 ?decimals)
& str\$(!ones "." !decimals):?a
)
& out\$(!a "-->" convert\$!a)
)
)

{{out}}

0.00 --> 0.10
0.01 --> 0.10
0.02 --> 0.10
0.03 --> 0.10
0.04 --> 0.10
0.05 --> 0.10
0.06 --> 0.18
0.07 --> 0.18
0.08 --> 0.18
0.09 --> 0.18
0.10 --> 0.18
0.11 --> 0.26
0.12 --> 0.26
0.13 --> 0.26
0.14 --> 0.26
0.15 --> 0.26
0.16 --> 0.32
0.17 --> 0.32
...
0.85 --> 0.90
0.86 --> 0.94
0.87 --> 0.94
0.88 --> 0.94
0.89 --> 0.94
0.90 --> 0.94
0.91 --> 0.98
0.92 --> 0.98
0.93 --> 0.98
0.94 --> 0.98
0.95 --> 0.98
0.96 --> 1.00
0.97 --> 1.00
0.98 --> 1.00
0.99 --> 1.00
1.00 --> 1.00
1.01 --> invalid input
1.02 --> invalid input

C

#include <stdio.h>

double table[][2] = {
{0.06, 0.10}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32},
{0.26, 0.38}, {0.31, 0.44}, {0.36, 0.50}, {0.41, 0.54},
{0.46, 0.58}, {0.51, 0.62}, {0.56, 0.66}, {0.61, 0.70},
{0.66, 0.74}, {0.71, 0.78}, {0.76, 0.82}, {0.81, 0.86},
{0.86, 0.90}, {0.91, 0.94}, {0.96, 0.98}, {1.01, 1.00},
{-1, 0}, /* guarding element */
};

double price_fix(double x)
{
int i;
for (i = 0; table[i][0] > 0; i++)
if (x < table[i][0]) return table[i][1];

abort(); /* what else to do? */
}

int main()
{
int i;
for (i = 0; i <= 100; i++)
printf("%.2f %.2f\n", i / 100., price_fix(i / 100.));

return 0;
}

C#

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
for (int x = 0; x < 10; x++)
{
Console.WriteLine("In: {0:0.00}, Out: {1:0.00}", ((double)x) / 10, SpecialRound(((double)x) / 10));
}

Console.WriteLine();

for (int x = 0; x < 10; x++)
{
Console.WriteLine("In: {0:0.00}, Out: {1:0.00}", ((double)x) / 10 + 0.05, SpecialRound(((double)x) / 10 + 0.05));
}

Console.WriteLine();
Console.WriteLine("In: {0:0.00}, Out: {1:0.00}", 1.01, SpecialRound(1.01));

}

private static double SpecialRound(double inValue)
{
if (inValue > 1) return 1;

double[] Splitters = new double[] {
0.00 , 0.06 , 0.11 , 0.16 , 0.21 ,
0.26 , 0.31 , 0.36 , 0.41 , 0.46 ,
0.51 , 0.56 , 0.61 , 0.66 , 0.71 ,
0.76 , 0.81 , 0.86 , 0.91 , 0.96 };

double[] replacements = new double[] {
0.10 , 0.18 , 0.26 , 0.32 , 0.38 ,
0.44 , 0.50 , 0.54 , 0.58 , 0.62 ,
0.66 , 0.70 , 0.74 , 0.78 , 0.82 ,
0.86 , 0.90 , 0.94 , 0.98 , 1.00 };

for (int x = 0; x < Splitters.Length - 1; x++)
{
if (inValue >= Splitters[x] &&
inValue < Splitters[x + 1])
{
return replacements[x];
}
}

return inValue;
}
}
}

C++

#include <iostream>
#include <cmath>

int main( ) {
double froms[ ] = { 0.00 , 0.06 , 0.11 , 0.16 , 0.21 , 0.26 ,
0.31 , 0.36 , 0.41 , 0.46 , 0.51 , 0.56 , 0.61 , 0.66 ,
0.71 , 0.76 , 0.81 , 0.86 , 0.91 , 0.96 } ;
double tos[ ] = { 0.06 , 0.11 , 0.16 , 0.21 , 0.26 , 0.31 ,
0.36 , 0.41 , 0.46 , 0.51 , 0.56 , 0.61 , 0.66 , 0.71 ,
0.76 , 0.81 , 0.86 , 0.91 , 0.96 , 1.01 } ;
double replacements [] = { 0.10 , 0.18 , 0.26 , 0.32 , 0.38 ,
0.44 , 0.50 , 0.54 , 0.58 , 0.62 , 0.66 , 0.70 , 0.74 ,
0.78 , 0.82 , 0.86 , 0.90 , 0.94 , 0.98 , 1.00 } ;
double number = 0.1 ;
std::cout << "Enter a fractional number between 0 and 1 ( 0 to end )!\n" ;
std::cin >> number ;
while ( number != 0 ) {
if ( number < 0 || number > 1 ) {
std::cerr << "Error! Only positive values between 0 and 1 are allowed!\n" ;
return 1 ;
}
int n = 0 ;
while ( ! ( number >= froms[ n ] && number < tos[ n ] ) )
n++ ;
std::cout << "-->" << replacements[ n ] << '\n' ;
std::cout << "Enter a fractional number ( 0 to end )!\n" ;
std::cin >> number ;
}
return 0 ;
}

{{out}}

Enter a fractional number between 0 and 1 ( 0 to end )!
0.7
-->0.78
Enter a fractional number ( 0 to end )!
0.32
-->0.5
Enter a fractional number ( 0 to end )!
0.12
-->0.26
Enter a fractional number ( 0 to end )!
0

Clipper

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

The function above crashes with an array access bound error if the value passed is negative. Also, the spec. indicates that 0.00 should be replaced with standard value 0.10, not 0. The following is a more concise solution:

Procedure Main()
Local i
For i := -0.02 to 1.02 STEP 0.03
? i, "->", PriceFraction(i), i+0.02, "->", PriceFraction(i+0.02)
Next
Return

Static Function PriceFraction( nValue )
Local nResult
Local n
// Function is only defined for values 0 to 1.00
// Return NIL for anything else
// Table of values {V1, V2} = {Threshhold, Standard value}
#define TV_THRESHHOLD 1
#define TV_STD_VALUE  2
Local aTable := { {0,    NIL },;
{0.06, 0.10},;
{0.11, 0.18},;
{0.16, 0.26},;
{0.21, 0.32},;
{0.26, 0.38},;
{0.31, 0.44},;
{0.36, 0.50},;
{0.41, 0.54},;
{0.46, 0.58},;
{0.51, 0.62},;
{0.56, 0.66},;
{0.61, 0.70},;
{0.66, 0.74},;
{0.71, 0.78},;
{0.76, 0.82},;
{0.81, 0.86},;
{0.86, 0.90},;
{0.91, 0.94},;
{0.96, 0.98},;
{1.01, 1.00} }
n := AScan( aTable, {|x| nValue < x[TV_THRESHHOLD] })
If n > 0
nResult := aTable[n][TV_STD_VALUE]
Else
nResult := NIL
Endif
Return nResult

{{out}}

-0.02 -> NIL          0.00 ->          0.10
0.01 ->          0.10          0.03 ->          0.10
0.04 ->          0.10          0.06 ->          0.18
0.07 ->          0.18          0.09 ->          0.18
0.10 ->          0.18          0.12 ->          0.26
0.13 ->          0.26          0.15 ->          0.26
0.16 ->          0.32          0.18 ->          0.32
0.19 ->          0.32          0.21 ->          0.38
0.22 ->          0.38          0.24 ->          0.38
0.25 ->          0.38          0.27 ->          0.44
0.28 ->          0.44          0.30 ->          0.44
0.31 ->          0.50          0.33 ->          0.50
0.34 ->          0.50          0.36 ->          0.54
0.37 ->          0.54          0.39 ->          0.54
0.40 ->          0.54          0.42 ->          0.58
0.43 ->          0.58          0.45 ->          0.58
0.46 ->          0.62          0.48 ->          0.62
0.49 ->          0.62          0.51 ->          0.66
0.52 ->          0.66          0.54 ->          0.66
0.55 ->          0.66          0.57 ->          0.70
0.58 ->          0.70          0.60 ->          0.70
0.61 ->          0.74          0.63 ->          0.74
0.64 ->          0.74          0.66 ->          0.78
0.67 ->          0.78          0.69 ->          0.78
0.70 ->          0.78          0.72 ->          0.82
0.73 ->          0.82          0.75 ->          0.82
0.76 ->          0.86          0.78 ->          0.86
0.79 ->          0.86          0.81 ->          0.90
0.82 ->          0.90          0.84 ->          0.90
0.85 ->          0.90          0.87 ->          0.94
0.88 ->          0.94          0.90 ->          0.94
0.91 ->          0.98          0.93 ->          0.98
0.94 ->          0.98          0.96 ->          1.00
0.97 ->          1.00          0.99 ->          1.00
1.00 ->          1.00          1.02 -> NIL
```

## Clojure

{{trans|JavaScript}}

```clojure
(def values [10 18 26 32 38 44 50 54 58 62 66 70 74 78 82 86 90 94 98 100])

(defn price [v]
(format "%.2f" (double (/ (values (int (/ (- (* v 100) 1) 5))) 100))))
```

{{out}}

```txt

user=> (price 0.50)
"0.62"
user=> (let [k (map #(double (/ % 100)) (range 101))] (sort (zipmap k (map #(price %) k))))
([0.0 "0.10"] [0.01 "0.10"] [0.02 "0.10"] [0.03 "0.10"] [0.04 "0.10"] [0.05 "0.10"]
[0.06 "0.18"] [0.07 "0.18"] [0.08 "0.18"] [0.09 "0.18"] [0.1 "0.18"]
[0.11 "0.26"] [0.12 "0.26"] [0.13 "0.26"] [0.14 "0.26"] [0.15 "0.26"]
[0.16 "0.32"] [0.17 "0.32"] [0.18 "0.32"] [0.19 "0.32"] [0.2 "0.32"]
[0.21 "0.38"] [0.22 "0.38"] [0.23 "0.38"] [0.24 "0.38"] [0.25 "0.38"]
[0.26 "0.44"] [0.27 "0.44"] [0.28 "0.44"] [0.29 "0.44"] [0.3 "0.44"]
[0.31 "0.50"] [0.32 "0.50"] [0.33 "0.50"] [0.34 "0.50"] [0.35 "0.50"]
[0.36 "0.54"] [0.37 "0.54"] [0.38 "0.54"] [0.39 "0.54"] [0.4 "0.54"]
[0.41 "0.58"] [0.42 "0.58"] [0.43 "0.58"] [0.44 "0.58"] [0.45 "0.58"]
[0.46 "0.62"] [0.47 "0.62"] [0.48 "0.62"] [0.49 "0.62"] [0.5 "0.62"]
[0.51 "0.66"] [0.52 "0.66"] [0.53 "0.66"] [0.54 "0.66"] [0.55 "0.66"]
[0.56 "0.70"] [0.57 "0.70"] [0.58 "0.70"] [0.59 "0.70"] [0.6 "0.70"]
[0.61 "0.74"] [0.62 "0.74"] [0.63 "0.74"] [0.64 "0.74"] [0.65 "0.74"]
[0.66 "0.78"] [0.67 "0.78"] [0.68 "0.78"] [0.69 "0.78"] [0.7 "0.78"]
[0.71 "0.82"] [0.72 "0.82"] [0.73 "0.82"] [0.74 "0.82"] [0.75 "0.82"]
[0.76 "0.86"] [0.77 "0.86"] [0.78 "0.86"] [0.79 "0.86"] [0.8 "0.86"]
[0.81 "0.90"] [0.82 "0.90"] [0.83 "0.90"] [0.84 "0.90"] [0.85 "0.90"]
[0.86 "0.94"] [0.87 "0.94"] [0.88 "0.94"] [0.89 "0.94"] [0.9 "0.94"]
[0.91 "0.98"] [0.92 "0.98"] [0.93 "0.98"] [0.94 "0.98"] [0.95 "0.98"]
[0.96 "1.00"] [0.97 "1.00"] [0.98 "1.00"] [0.99 "1.00"] [1.0 "1.00"])
```

## Common Lisp

```lisp
(defun scale (value)
(cond ((minusp value) (error "invalid value: ~A" value))
((< value 0.06) 0.10)
((< value 0.11) 0.18)
((< value 0.16) 0.26)
((< value 0.21) 0.32)
((< value 0.26) 0.38)
((< value 0.31) 0.44)
((< value 0.36) 0.50)
((< value 0.41) 0.54)
((< value 0.46) 0.58)
((< value 0.51) 0.62)
((< value 0.56) 0.66)
((< value 0.61) 0.70)
((< value 0.66) 0.74)
((< value 0.71) 0.78)
((< value 0.76) 0.82)
((< value 0.81) 0.86)
((< value 0.86) 0.90)
((< value 0.91) 0.94)
((< value 0.96) 0.98)
((< value 1.01) 1.00)
(t (error "invalid value: ~A" value))))
```

## D

```d
import std.stdio, std.range;

double priceRounder(in double price) pure nothrow
in {
assert(price >= 0 && price <= 1.0);
} body {
static immutable cin  = [.06, .11, .16, .21, .26, .31, .36, .41,
.46, .51, .56, .61, .66, .71, .76, .81,
.86, .91, .96, 1.01],
cout = [.10, .18, .26, .32, .38, .44, .50, .54,
.58, .62, .66, .70, .74, .78, .82, .86,
.90, .94, .98, 1.00];
return cout[cin.assumeSorted.lowerBound(price).length];
}

void main() {
foreach (const price; [0.7388727, 0.8593103, 0.826687, 0.3444635])
price.priceRounder.writeln;
}
```

{{out}}

```txt
0.82
0.9
0.9
0.5
```

## Eiffel

```Eiffel

class
APPLICATION

create
make

feature

make
--Tests the price_adjusted feature.
local
i: REAL
do
create price_fraction.initialize
from
i := 5
until
i = 100
loop
io.put_string ("Given: ")
io.put_real (i / 100)
io.put_real (price_fraction.adjusted_price (i / 100))
io.new_line
i := i + 5
end
end

price_fraction: PRICE_FRACTION

end

```

```Eiffel

class
PRICE_FRACTION

create
initialize

feature

initialize
-- Initializes limit and price to the given values.
do
limit := <<0.06, 0.11, 0.16, 0.21, 0.26, 0.31, 0.36, 0.41, 0.46, 0.51, 0.56, 0.61, 0.66, 0.71, 0.76, 0.81, 0.86, 0.91, 0.96, 1.01>>
price := <<0.10, 0.18, 0.26, 0.32, 0.38, 0.44, 0.50, 0.54, 0.58, 0.62, 0.66, 0.70, 0.74, 0.78, 0.81, 0.86, 0.90, 0.94, 0.98, 1.00>>
end

adjusted_price (n: REAL): REAL
-- Adjusted price according to the given price values.
local
i: INTEGER
found: BOOLEAN
do
from
i := 1
until
i > limit.count or found
loop
if n <= limit [i] then
Result := (price [i])
found := True
end
i := i + 1
end
end

feature {NONE}

limit: ARRAY [REAL]

price: ARRAY [REAL]

end

```

{{out}}

```txt

```

## Elixir

```elixir
defmodule Price do
@table [ {0.06, 0.10}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32}, {0.26, 0.38},
{0.31, 0.44}, {0.36, 0.50}, {0.41, 0.54}, {0.46, 0.58}, {0.51, 0.62},
{0.56, 0.66}, {0.61, 0.70}, {0.66, 0.74}, {0.71, 0.78}, {0.76, 0.82},
{0.81, 0.86}, {0.86, 0.90}, {0.91, 0.94}, {0.96, 0.98}, {1.01, 1.00} ]

def fraction(value) when value in 0..1 do
{_, standard_value} = Enum.find(@table, fn {upper_limit, _} -> value < upper_limit end)
standard_value
end
end

val = for i <- 0..100, do: i/100
Enum.each(val, fn x ->
:io.format "~5.2f ->~5.2f~n", [x, Price.fraction(x)]
end)
```

{{out}}

```txt

0.00 -> 0.10
0.01 -> 0.10
0.02 -> 0.10
0.03 -> 0.10
0.04 -> 0.10
0.05 -> 0.10
0.06 -> 0.18
0.07 -> 0.18
0.08 -> 0.18
0.09 -> 0.18
0.10 -> 0.18
0.11 -> 0.26
...
0.95 -> 0.98
0.96 -> 1.00
0.97 -> 1.00
0.98 -> 1.00
0.99 -> 1.00
1.00 -> 1.00

```

## Erlang

```erlang
priceFraction(N) when N < 0 orelse N > 1 ->
erlang:error('Values must be between 0 and 1.');
priceFraction(N) when N < 0.06 -> 0.10;
priceFraction(N) when N < 0.11 -> 0.18;
priceFraction(N) when N < 0.16 -> 0.26;
priceFraction(N) when N < 0.21 -> 0.32;
priceFraction(N) when N < 0.26 -> 0.38;
priceFraction(N) when N < 0.31 -> 0.44;
priceFraction(N) when N < 0.36 -> 0.50;
priceFraction(N) when N < 0.41 -> 0.54;
priceFraction(N) when N < 0.46 -> 0.58;
priceFraction(N) when N < 0.51 -> 0.62;
priceFraction(N) when N < 0.56 -> 0.66;
priceFraction(N) when N < 0.61 -> 0.70;
priceFraction(N) when N < 0.66 -> 0.74;
priceFraction(N) when N < 0.71 -> 0.78;
priceFraction(N) when N < 0.76 -> 0.82;
priceFraction(N) when N < 0.81 -> 0.86;
priceFraction(N) when N < 0.86 -> 0.90;
priceFraction(N) when N < 0.91 -> 0.94;
priceFraction(N) when N < 0.96 -> 0.98;
priceFraction(N) -> 1.00.
```

## Euphoria

{{trans|C}}

```euphoria
constant table = {
{0.06, 0.10}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32},
{0.26, 0.38}, {0.31, 0.44}, {0.36, 0.50}, {0.41, 0.54},
{0.46, 0.58}, {0.51, 0.62}, {0.56, 0.66}, {0.61, 0.70},
{0.66, 0.74}, {0.71, 0.78}, {0.76, 0.82}, {0.81, 0.86},
{0.86, 0.90}, {0.91, 0.94}, {0.96, 0.98}, {1.01, 1.00}
}

function price_fix(atom x)
for i = 1 to length(table) do
if x < table[i][1] then
return table[i][2]
end if
end for
return -1
end function

for i = 0 to 99 do
printf(1, "%.2f %.2f\n", { i/100, price_fix(i/100) })
end for
```

Inspired by Python's bisect solution. Using decimal (System.Decimal) to avoid number representation problems with floats.

```fsharp
let cin = [ 0.06m .. 0.05m ..1.01m ]
let cout = [0.1m; 0.18m] @ [0.26m .. 0.06m .. 0.44m] @ [0.50m .. 0.04m .. 0.98m] @ [1.m]

let priceadjuster p =
let rec bisect lo hi =
if lo < hi then
let mid = (lo+hi)/2.
let left = p < cin.[int mid]
bisect (if left then lo else mid+1.) (if left then mid else hi)
else lo

if p < 0.m || 1.m < p then p
else cout.[int (bisect 0. (float cin.Length))]

[ 0.m .. 0.01m .. 1.m ]
|> Seq.ofList
|> Seq.iter (fun p -> printfn "%.2f -> %.2f" p (priceadjuster p))
```

{{out}}
The same as shown by Ada as of 2013-11-03T17:42Z (apart from whitespace formatting)

## Factor

```factor
CONSTANT: dispensary-data {
{ 0.06 0.10 }
{ 0.11 0.18 }
{ 0.16 0.26 }
{ 0.21 0.32 }
{ 0.26 0.38 }
{ 0.31 0.44 }
{ 0.36 0.50 }
{ 0.41 0.54 }
{ 0.46 0.58 }
{ 0.51 0.62 }
{ 0.56 0.66 }
{ 0.61 0.70 }
{ 0.66 0.74 }
{ 0.71 0.78 }
{ 0.76 0.82 }
{ 0.81 0.86 }
{ 0.86 0.90 }
{ 0.91 0.94 }
{ 0.96 0.98 }
{ 1.01 1.00 } }

: price-fraction ( n -- n ) dispensary-data [ first over >= ] find 2nip second ;

{ 0 0.5 0.65 0.66 1 } [ price-fraction ] map
```

{{out}}

{ 0.1 0.62 0.74 0.74 1.0 }

## Fantom

```fantom

class Defn // to hold the three numbers from a 'row' in the table
{
Float low
Float high
Float value
new make (Float low, Float high, Float value)
{
this.low = low
this.high = high
this.value = value
}
}

class PriceConverter
{
Defn[] defns := [,]
new make (Str table) // process given table and store numbers from each row in a defn
{
table.split('\n').each |Str line|
{
data := line.split
defns.add (Defn(Float.fromStr(data[1]), Float.fromStr(data[3]), Float.fromStr(data[5])))
}
}

public Float convert (Float price) // convert by looking through list of defns
{
Float result := price
defns.each |Defn defn|
{
if (price >= defn.low && price < defn.high)
result = defn.value
}
return result
}
}

class Main
{
public static Void main ()
{
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"
converter := PriceConverter (table)
10.times  // simple test with random values
{
price := (0..100).random.toFloat / 100
echo ("\$price -> \${converter.convert (price)}")
}
}
}

```

## Forth

A floating-point version wouldn't be hard -- four words would change ( , @ @ cell+ -to- f, f@ f@ float+ ), EVALUATE would be replaced with a small word that forced a floating-point interpretation, and the return stack would not be used in ROUND -- but it would be strikingly unusual.  See this page's discussion.

```forth
: as begin parse-word dup while evaluate , repeat 2drop ;

create bounds   as  96 91 86 81 76 71 66 61 56 51 46 41 36 31 26 21 16 11  6  0
create official as 100 98 94 90 86 82 78 74 70 66 62 58 54 50 44 38 32 26 18 10

: official@ ( a-bounds -- +n )
\ (a+n) - a + b = (a+n) + (b - a) = (b+n)
[ official bounds - ] literal + @ ;

: round ( n-cents -- n-cents' )
>r bounds begin dup @ r@ > while cell+ repeat
r> drop official@ ;
```

## Fortran

{{works with|Fortran|90 and later}}

```fortran
program price_fraction

implicit none
integer, parameter :: i_max = 10
integer :: i
real, dimension (20), parameter :: in =                           &
& (/0.00, 0.06, 0.11, 0.16, 0.21, 0.26, 0.31, 0.36, 0.41, 0.46, &
&   0.51, 0.56, 0.61, 0.66, 0.71, 0.76, 0.81, 0.86, 0.91, 0.96/)
real, dimension (20), parameter :: out =                          &
& (/0.10, 0.18, 0.26, 0.32, 0.38, 0.44, 0.50, 0.54, 0.58, 0.62, &
&   0.66, 0.70, 0.74, 0.78, 0.82, 0.86, 0.90, 0.94, 0.98, 1.00/)
real :: r

do i = 1, i_max
call random_number (r)
write (*, '(f8.6, 1x, f4.2)') r, out (maxloc (in, r >= in))
end do

end program price_fraction
```

{{out}}
0.997560 1.00
0.566825 0.70
0.965915 1.00
0.747928 0.82
0.367391 0.54
0.480637 0.62
0.073754 0.18
0.005355 0.10
0.347081 0.50
0.342244 0.50
```

## FreeBASIC

```freebasic
' FB 1.050.0 Win64

Function rescale(price As Double) As Double
If price < 0.00 OrElse price > 1.00 Then Return price
Select Case price
Case Is < 0.06 : Return 0.10
Case Is < 0.11 : Return 0.18
Case Is < 0.16 : Return 0.26
Case Is < 0.21 : Return 0.32
Case Is < 0.26 : Return 0.38
Case Is < 0.31 : Return 0.44
Case Is < 0.36 : Return 0.50
Case Is < 0.41 : Return 0.54
Case Is < 0.46 : Return 0.58
Case Is < 0.51 : Return 0.62
Case Is < 0.56 : Return 0.66
Case Is < 0.61 : Return 0.70
Case Is < 0.66 : Return 0.74
Case Is < 0.71 : Return 0.78
Case Is < 0.76 : Return 0.82
Case Is < 0.81 : Return 0.86
Case Is < 0.86 : Return 0.90
Case Is < 0.91 : Return 0.94
Case Is < 0.96 : Return 0.98
End Select
Return 1.00
End Function

For i As Integer = 1 To 100
Dim d As Double = i/100.0
Print Using "#.##"; d;
Print " -> ";
Print Using "#.##"; rescale(d);
Print "  ";
If i Mod 5 = 0 Then Print
Next

Print
Print "Press any key to quit"
Sleep
```

{{out}}

```txt

0.01 -> 0.10  0.02 -> 0.10  0.03 -> 0.10  0.04 -> 0.10  0.05 -> 0.10
0.06 -> 0.18  0.07 -> 0.18  0.08 -> 0.18  0.09 -> 0.18  0.10 -> 0.18
0.11 -> 0.26  0.12 -> 0.26  0.13 -> 0.26  0.14 -> 0.26  0.15 -> 0.26
0.16 -> 0.32  0.17 -> 0.32  0.18 -> 0.32  0.19 -> 0.32  0.20 -> 0.32
0.21 -> 0.38  0.22 -> 0.38  0.23 -> 0.38  0.24 -> 0.38  0.25 -> 0.38
0.26 -> 0.44  0.27 -> 0.44  0.28 -> 0.44  0.29 -> 0.44  0.30 -> 0.44
0.31 -> 0.50  0.32 -> 0.50  0.33 -> 0.50  0.34 -> 0.50  0.35 -> 0.50
0.36 -> 0.54  0.37 -> 0.54  0.38 -> 0.54  0.39 -> 0.54  0.40 -> 0.54
0.41 -> 0.58  0.42 -> 0.58  0.43 -> 0.58  0.44 -> 0.58  0.45 -> 0.58
0.46 -> 0.62  0.47 -> 0.62  0.48 -> 0.62  0.49 -> 0.62  0.50 -> 0.62
0.51 -> 0.66  0.52 -> 0.66  0.53 -> 0.66  0.54 -> 0.66  0.55 -> 0.66
0.56 -> 0.70  0.57 -> 0.70  0.58 -> 0.70  0.59 -> 0.70  0.60 -> 0.70
0.61 -> 0.74  0.62 -> 0.74  0.63 -> 0.74  0.64 -> 0.74  0.65 -> 0.74
0.66 -> 0.78  0.67 -> 0.78  0.68 -> 0.78  0.69 -> 0.78  0.70 -> 0.78
0.71 -> 0.82  0.72 -> 0.82  0.73 -> 0.82  0.74 -> 0.82  0.75 -> 0.82
0.76 -> 0.86  0.77 -> 0.86  0.78 -> 0.86  0.79 -> 0.86  0.80 -> 0.86
0.81 -> 0.90  0.82 -> 0.90  0.83 -> 0.90  0.84 -> 0.90  0.85 -> 0.90
0.86 -> 0.94  0.87 -> 0.94  0.88 -> 0.94  0.89 -> 0.94  0.90 -> 0.94
0.91 -> 0.98  0.92 -> 0.98  0.93 -> 0.98  0.94 -> 0.98  0.95 -> 0.98
0.96 -> 1.00  0.97 -> 1.00  0.98 -> 1.00  0.99 -> 1.00  1.00 -> 1.00

```

## Gambas

'''[https://gambas-playground.proko.eu/?gist=87527eed297164593d88aa2c35898eaf Click this link to run this code]'''

```gambas
Public Sub Main()
Dim byValue As Byte[] = [10, 18, 26, 32, 38, 44, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 100]
Dim byLimit As Byte[] = [6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96]
Dim byCount, byCheck As Byte

For byCount = 0 To 100
For byCheck = 0 To byLimit.Max
If byCount < byLimit[byCheck] Then Break
Next
Print Format(byCount / 100, "0.00") & " = " & Format(byValue[byCheck] / 100, "0.00") & gb.Tab;
If byCount Mod 5 = 0 Then Print
Next

End
```

Output:

```txt

0.00 = 0.10
0.01 = 0.10     0.02 = 0.10     0.03 = 0.10     0.04 = 0.10     0.05 = 0.10
0.06 = 0.18     0.07 = 0.18     0.08 = 0.18     0.09 = 0.18     0.10 = 0.18
0.11 = 0.26     0.12 = 0.26     0.13 = 0.26     0.14 = 0.26     0.15 = 0.26
0.16 = 0.32     0.17 = 0.32     0.18 = 0.32     0.19 = 0.32     0.20 = 0.32
0.21 = 0.38     0.22 = 0.38     0.23 = 0.38     0.24 = 0.38     0.25 = 0.38
0.26 = 0.44     0.27 = 0.44     0.28 = 0.44     0.29 = 0.44     0.30 = 0.44
0.31 = 0.50     0.32 = 0.50     0.33 = 0.50     0.34 = 0.50     0.35 = 0.50
0.36 = 0.54     0.37 = 0.54     0.38 = 0.54     0.39 = 0.54     0.40 = 0.54
0.41 = 0.58     0.42 = 0.58     0.43 = 0.58     0.44 = 0.58     0.45 = 0.58
0.46 = 0.62     0.47 = 0.62     0.48 = 0.62     0.49 = 0.62     0.50 = 0.62
0.51 = 0.66     0.52 = 0.66     0.53 = 0.66     0.54 = 0.66     0.55 = 0.66
0.56 = 0.70     0.57 = 0.70     0.58 = 0.70     0.59 = 0.70     0.60 = 0.70
0.61 = 0.74     0.62 = 0.74     0.63 = 0.74     0.64 = 0.74     0.65 = 0.74
0.66 = 0.78     0.67 = 0.78     0.68 = 0.78     0.69 = 0.78     0.70 = 0.78
0.71 = 0.82     0.72 = 0.82     0.73 = 0.82     0.74 = 0.82     0.75 = 0.82
0.76 = 0.86     0.77 = 0.86     0.78 = 0.86     0.79 = 0.86     0.80 = 0.86
0.81 = 0.90     0.82 = 0.90     0.83 = 0.90     0.84 = 0.90     0.85 = 0.90
0.86 = 0.94     0.87 = 0.94     0.88 = 0.94     0.89 = 0.94     0.90 = 0.94
0.91 = 0.98     0.92 = 0.98     0.93 = 0.98     0.94 = 0.98     0.95 = 0.98
0.96 = 1.00     0.97 = 1.00     0.98 = 1.00     0.99 = 1.00     1.00 = 1.00

```

## Go

```go
func pf(v float64) float64 {
switch {
case v < .06: return .10
case v < .11: return .18
case v < .16: return .26
case v < .21: return .32
case v < .26: return .38
case v < .31: return .44
case v < .36: return .50
case v < .41: return .54
case v < .46: return .58
case v < .51: return .62
case v < .56: return .66
case v < .61: return .70
case v < .66: return .74
case v < .71: return .78
case v < .76: return .82
case v < .81: return .86
case v < .86: return .90
case v < .91: return .94
case v < .96: return .98
}
return 1
}
```

## Groovy

```groovy
def priceFraction(value) {
assert value >= 0.0 && value <= 1.0

def priceMappings = [(0.06): 0.10, (0.11): 0.18, (0.16): 0.26, (0.21): 0.32, (0.26): 0.38,
(0.31): 0.44, (0.36): 0.50, (0.41): 0.54, (0.46): 0.58, (0.51): 0.62,
(0.56): 0.66, (0.61): 0.70, (0.66): 0.74, (0.71): 0.78, (0.76): 0.82,
(0.81): 0.86, (0.86): 0.90, (0.91): 0.94, (0.96): 0.98]

for (price in priceMappings.keySet()) {
if (value < price) return priceMappings[price]
}
1.00
}

for (def v = 0.00; v <= 1.00; v += 0.01) {
println "\$v --> \${priceFraction(v)}"
}
```

{{out}}
```txt 0.00 --> 0.10 0.01 --> 0.10 0.02 --> 0.10 0.03 --> 0.10 0.04 --> 0.10 0.05 --> 0.10 0.06 --> 0.18 0.07 --> 0.18 0.08 --> 0.18 0.09 --> 0.18 0.10 --> 0.18 0.11 --> 0.26 0.12 --> 0.26 0.13 --> 0.26 0.14 --> 0.26 0.15 --> 0.26 0.16 --> 0.32 0.17 --> 0.32 0.18 --> 0.32 0.19 --> 0.32 0.20 --> 0.32 0.21 --> 0.38 0.22 --> 0.38 0.23 --> 0.38 0.24 --> 0.38 0.25 --> 0.38 0.26 --> 0.44 0.27 --> 0.44 0.28 --> 0.44 0.29 --> 0.44 0.30 --> 0.44 0.31 --> 0.50 0.32 --> 0.50 0.33 --> 0.50 0.34 --> 0.50 0.35 --> 0.50 0.36 --> 0.54 0.37 --> 0.54 0.38 --> 0.54 0.39 --> 0.54 0.40 --> 0.54 0.41 --> 0.58 0.42 --> 0.58 0.43 --> 0.58 0.44 --> 0.58 0.45 --> 0.58 0.46 --> 0.62 0.47 --> 0.62 0.48 --> 0.62 0.49 --> 0.62 0.50 --> 0.62 0.51 --> 0.66 0.52 --> 0.66 0.53 --> 0.66 0.54 --> 0.66 0.55 --> 0.66 0.56 --> 0.70 0.57 --> 0.70 0.58 --> 0.70 0.59 --> 0.70 0.60 --> 0.70 0.61 --> 0.74 0.62 --> 0.74 0.63 --> 0.74 0.64 --> 0.74 0.65 --> 0.74 0.66 --> 0.78 0.67 --> 0.78 0.68 --> 0.78 0.69 --> 0.78 0.70 --> 0.78 0.71 --> 0.82 0.72 --> 0.82 0.73 --> 0.82 0.74 --> 0.82 0.75 --> 0.82 0.76 --> 0.86 0.77 --> 0.86 0.78 --> 0.86 0.79 --> 0.86 0.80 --> 0.86 0.81 --> 0.90 0.82 --> 0.90 0.83 --> 0.90 0.84 --> 0.90 0.85 --> 0.90 0.86 --> 0.94 0.87 --> 0.94 0.88 --> 0.94 0.89 --> 0.94 0.90 --> 0.94 0.91 --> 0.98 0.92 --> 0.98 0.93 --> 0.98 0.94 --> 0.98 0.95 --> 0.98 0.96 --> 1.00 0.97 --> 1.00 0.98 --> 1.00 0.99 --> 1.00 1.00 --> 1.00 ```
original price ──► 0.00       0.10  ◄── adjusted price
original price ──► 0.01       0.10  ◄── adjusted price
original price ──► 0.02       0.10  ◄── adjusted price
original price ──► 0.03       0.10  ◄── adjusted price
original price ──► 0.04       0.10  ◄── adjusted price
original price ──► 0.05       0.10  ◄── adjusted price
original price ──► 0.06       0.18  ◄── adjusted price
original price ──► 0.07       0.18  ◄── adjusted price
original price ──► 0.08       0.18  ◄── adjusted price
original price ──► 0.09       0.18  ◄── adjusted price
original price ──► 0.10       0.18  ◄── adjusted price
original price ──► 0.11       0.26  ◄── adjusted price
original price ──► 0.12       0.26  ◄── adjusted price
original price ──► 0.13       0.26  ◄── adjusted price
original price ──► 0.14       0.26  ◄── adjusted price
original price ──► 0.15       0.26  ◄── adjusted price
original price ──► 0.16       0.32  ◄── adjusted price
original price ──► 0.17       0.32  ◄── adjusted price
original price ──► 0.18       0.32  ◄── adjusted price
original price ──► 0.19       0.32  ◄── adjusted price
original price ──► 0.20       0.32  ◄── adjusted price
original price ──► 0.21       0.38  ◄── adjusted price
original price ──► 0.22       0.38  ◄── adjusted price
original price ──► 0.23       0.38  ◄── adjusted price
original price ──► 0.24       0.38  ◄── adjusted price
original price ──► 0.25       0.38  ◄── adjusted price
original price ──► 0.26       0.44  ◄── adjusted price
original price ──► 0.27       0.44  ◄── adjusted price
original price ──► 0.28       0.44  ◄── adjusted price
original price ──► 0.29       0.44  ◄── adjusted price
original price ──► 0.30       0.44  ◄── adjusted price
original price ──► 0.31       0.50  ◄── adjusted price
original price ──► 0.32       0.50  ◄── adjusted price
original price ──► 0.33       0.50  ◄── adjusted price
original price ──► 0.34       0.50  ◄── adjusted price
original price ──► 0.35       0.50  ◄── adjusted price
original price ──► 0.36       0.54  ◄── adjusted price
original price ──► 0.37       0.54  ◄── adjusted price
original price ──► 0.38       0.54  ◄── adjusted price
original price ──► 0.39       0.54  ◄── adjusted price
original price ──► 0.40       0.54  ◄── adjusted price
original price ──► 0.41       0.58  ◄── adjusted price
original price ──► 0.42       0.58  ◄── adjusted price
original price ──► 0.43       0.58  ◄── adjusted price
original price ──► 0.44       0.58  ◄── adjusted price
original price ──► 0.45       0.58  ◄── adjusted price
original price ──► 0.46       0.62  ◄── adjusted price
original price ──► 0.47       0.62  ◄── adjusted price
original price ──► 0.48       0.62  ◄── adjusted price
original price ──► 0.49       0.62  ◄── adjusted price
original price ──► 0.50       0.62  ◄── adjusted price
original price ──► 0.51       0.66  ◄── adjusted price
original price ──► 0.52       0.66  ◄── adjusted price
original price ──► 0.53       0.66  ◄── adjusted price
original price ──► 0.54       0.66  ◄── adjusted price
original price ──► 0.55       0.66  ◄── adjusted price
original price ──► 0.56       0.70  ◄── adjusted price
original price ──► 0.57       0.70  ◄── adjusted price
original price ──► 0.58       0.70  ◄── adjusted price
original price ──► 0.59       0.70  ◄── adjusted price
original price ──► 0.60       0.70  ◄── adjusted price
original price ──► 0.61       0.74  ◄── adjusted price
original price ──► 0.62       0.74  ◄── adjusted price
original price ──► 0.63       0.74  ◄── adjusted price
original price ──► 0.64       0.74  ◄── adjusted price
original price ──► 0.65       0.74  ◄── adjusted price
original price ──► 0.66       0.78  ◄── adjusted price
original price ──► 0.67       0.78  ◄── adjusted price
original price ──► 0.68       0.78  ◄── adjusted price
original price ──► 0.69       0.78  ◄── adjusted price
original price ──► 0.70       0.78  ◄── adjusted price
original price ──► 0.71       0.82  ◄── adjusted price
original price ──► 0.72       0.82  ◄── adjusted price
original price ──► 0.73       0.82  ◄── adjusted price
original price ──► 0.74       0.82  ◄── adjusted price
original price ──► 0.75       0.82  ◄── adjusted price
original price ──► 0.76       0.86  ◄── adjusted price
original price ──► 0.77       0.86  ◄── adjusted price
original price ──► 0.78       0.86  ◄── adjusted price
original price ──► 0.79       0.86  ◄── adjusted price
original price ──► 0.80       0.86  ◄── adjusted price
original price ──► 0.81       0.90  ◄── adjusted price
original price ──► 0.82       0.90  ◄── adjusted price
original price ──► 0.83       0.90  ◄── adjusted price
original price ──► 0.84       0.90  ◄── adjusted price
original price ──► 0.85       0.90  ◄── adjusted price
original price ──► 0.86       0.94  ◄── adjusted price
original price ──► 0.87       0.94  ◄── adjusted price
original price ──► 0.88       0.94  ◄── adjusted price
original price ──► 0.89       0.94  ◄── adjusted price
original price ──► 0.90       0.94  ◄── adjusted price
original price ──► 0.91       0.98  ◄── adjusted price
original price ──► 0.92       0.98  ◄── adjusted price
original price ──► 0.93       0.98  ◄── adjusted price
original price ──► 0.94       0.98  ◄── adjusted price
original price ──► 0.95       0.98  ◄── adjusted price
original price ──► 0.96       1.00  ◄── adjusted price
original price ──► 0.97       1.00  ◄── adjusted price
original price ──► 0.98       1.00  ◄── adjusted price
original price ──► 0.99       1.00  ◄── adjusted price
original price ──► 1.00       1.00  ◄── adjusted price

```

### version 2

```rexx
/* REXX ***************************************************************
* Inspired by some other solutions tested with version 1 (above)
* 20.04.2013 Walter Pachl
* 03.11.2013 -"- move r. computation (once is enough)
**********************************************************************/
rl='0.10 0.18 0.26 0.32 0.38 0.44 0.50 0.54 0.58 0.62',
'0.66 0.70 0.74 0.78 0.82 0.86 0.90 0.94 0.98 1.00'
Do i=1 To 20
Parse Var rl r.i rl
End
Do x=0 To 1 By 0.01
If old<>new Then tag='??'
else tag=''
Say x old new  tag
End
Exit

adjprice2: Procedure Expose r.
i=((100*arg(1)-1)%5+1)
Return r.i
```

## Ring

```ring

see pricefraction(0.5)

func pricefraction n
if n < 0.06 return 0.10 ok
if n < 0.11 return 0.18 ok
if n < 0.16 return 0.26 ok
if n < 0.21 return 0.32 ok
if n < 0.26 return 0.38 ok
if n < 0.31 return 0.44 ok
if n < 0.36 return 0.50 ok
if n < 0.41 return 0.54 ok
if n < 0.46 return 0.58 ok
if n < 0.51 return 0.62 ok
if n < 0.56 return 0.66 ok
if n < 0.61 return 0.70 ok
if n < 0.66 return 0.74 ok
if n < 0.71 return 0.78 ok
if n < 0.76 return 0.82 ok
if n < 0.81 return 0.86 ok
if n < 0.86 return 0.90 ok
if n < 0.91 return 0.94 ok
if n < 0.96 return 0.98 ok
return 1

```

## Ruby

A simple function with hardcoded values.

```ruby
def rescale_price_fraction(value)
raise ArgumentError, "value=#{value}, must have: 0 <= value < 1.01" if value < 0 || value >= 1.01
if     value < 0.06  then  0.10
elsif  value < 0.11  then  0.18
elsif  value < 0.16  then  0.26
elsif  value < 0.21  then  0.32
elsif  value < 0.26  then  0.38
elsif  value < 0.31  then  0.44
elsif  value < 0.36  then  0.50
elsif  value < 0.41  then  0.54
elsif  value < 0.46  then  0.58
elsif  value < 0.51  then  0.62
elsif  value < 0.56  then  0.66
elsif  value < 0.61  then  0.70
elsif  value < 0.66  then  0.74
elsif  value < 0.71  then  0.78
elsif  value < 0.76  then  0.82
elsif  value < 0.81  then  0.86
elsif  value < 0.86  then  0.90
elsif  value < 0.91  then  0.94
elsif  value < 0.96  then  0.98
elsif  value < 1.01  then  1.00
end
end
```

Or, where we can cut and paste the textual table in one place

{{works with|Ruby|1.8.7+}} for the String#lines method.
For Ruby 1.8.6, use String#each_line

```ruby
class Price
ConversionTable = <<-END_OF_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
END_OF_TABLE

RE = %r{ ([<>=]+) \s* (\d\.\d\d) \s* ([<>=]+) \s* (\d\.\d\d) \D+ (\d\.\d\d) }x

# extract the comparison operators and numbers from the table
CONVERSION_TABLE = ConversionTable.lines.inject([]) do |table, line|
m = line.match(RE)
if not m.nil? and m.length == 6
table << [m[1], m[2].to_f, m[3], m[4].to_f, m[5].to_f]
end
table
end

MIN_COMP, MIN = CONVERSION_TABLE[0][0..1]
MAX_COMP, MAX = CONVERSION_TABLE[-1][2..3]

def initialize(value)
if (not value.send(MIN_COMP, MIN)) or (not value.send(MAX_COMP, MAX))
raise ArgumentError, "value=#{value}, must have: #{MIN} #{MIN_COMP} value #{MAX_COMP} #{MAX}"
end
@standard_value = CONVERSION_TABLE.find do |comp1, lower, comp2, upper, standard|
value.send(comp1, lower) and value.send(comp2, upper)
end.last
end
end
```

And a test suite

```ruby
require 'test/unit'

class PriceFractionTests < Test::Unit::TestCase
@@ok_tests = [
[0.3793, 0.54],
[0.4425, 0.58],
[0.0746, 0.18],
[0.6918, 0.78],
[0.2993, 0.44],
[0.5486, 0.66],
[0.7848, 0.86],
[0.9383, 0.98],
[0.2292, 0.38],
]
@@bad_tests = [1.02, -3]

def test_ok
@@ok_tests.each do |val, exp|
assert_equal(exp, rescale_price_fraction(val))
assert_equal(exp, Price.new(val).standard_value)
end
assert_raise(ArgumentError) {rescale_price_fraction(val)}
assert_raise(ArgumentError) {Price.new(val).standard_value}
end
end
end
```

{{out}}

```txt
Started
.
Finished in 0.001000 seconds.

1 tests, 22 assertions, 0 failures, 0 errors, 0 skips
```

## Run BASIC

```runbasic
data .06, .1,.11,.18,.16,.26,.21,.32,.26,.38,.31,.44,.36,.50,.41,.54,.46,.58,.51,.62
data .56,.66,.61,.70,.66,.74,.71,.78,.76,.82,.81,.86,.86,.90,.91,.94,.96,.98

dim od(100)
dim nd(100)
for i = 1 to 19
j = j + 1
for j = j to oldDec * 100
nd(j) = newDec
next j
next i

[loop]
input "Gimme a number";numb
decm  = val(using("##",(numb mod 1) * 100))
print numb;" -->";nd(decm)

goto [loop]
```

```txt
Gimme a number?12.676
12.676 -->0.78
Gimme a number?4.876
4.876 -->0.94
Gimme a number?34.12
34.12 -->0.26
```

## Rust

```rust
fn fix_price(num: f64) -> f64 {
match num {
0.96...1.00 => 1.00,
0.91...0.96 => 0.98,
0.86...0.91 => 0.94,
0.81...0.86 => 0.90,
0.76...0.81 => 0.86,
0.71...0.76 => 0.82,
0.66...0.71 => 0.78,
0.61...0.66 => 0.74,
0.56...0.61 => 0.70,
0.51...0.56 => 0.66,
0.46...0.51 => 0.62,
0.41...0.46 => 0.58,
0.36...0.41 => 0.54,
0.31...0.36 => 0.50,
0.26...0.31 => 0.44,
0.21...0.26 => 0.38,
0.16...0.21 => 0.32,
0.11...0.16 => 0.26,
0.06...0.11 => 0.18,
0.00...0.06 => 0.10,
// panics on invalid value
_ => unreachable!(),
}
}

fn main() {
let mut n: f64 = 0.04;
while n <= 1.00 {
println!("{:.2} => {}", n, fix_price(n));
n += 0.04;
}
}

// and a unit test to check that we haven't forgotten a branch, use 'cargo test' to execute test.
//
// typically this could be included in the match as those check for exhaustiveness already
// by explicitly listing all remaining ranges / values instead of a catch-all underscore (_)
// but f64::NaN, f64::INFINITY and f64::NEG_INFINITY can't be matched like this
#[test]
fn exhaustiveness_check() {
let mut input_price = 0.;
while input_price <= 1. {
fix_price(input_price);
input_price += 0.01;
}
}
```

{{out}}

```txt
0.04 => 0.1
0.09 => 0.18
0.14 => 0.26
0.19 => 0.32
0.24 => 0.38
0.29 => 0.44
0.34 => 0.5
0.39 => 0.54
0.44 => 0.58
0.49 => 0.62
0.54 => 0.66
0.59 => 0.7
0.64 => 0.74
0.69 => 0.78
0.74 => 0.82
0.79 => 0.86
0.84 => 0.9
0.89 => 0.94
0.94 => 0.98
0.99 => 1
```

'''Output of unit test:'''

```txt

running 1 test
test exhaustiveness_check ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
```

## Scala

```scala
def priceFraction(x:Double)=x match {
case n if n>=0 && n<0.06 => 0.10
case n if n<0.11 => 0.18
case n if n<0.36 => ((((n*100).toInt-11)/5)*6+26)/100.toDouble
case n if n<0.96 => ((((n*100).toInt-31)/5)*4+50)/100.toDouble
case _ => 1.00
}

def testPriceFraction()=
for(n <- 0.00 to (1.00, 0.01)) println("%.2f  %.2f".format(n, priceFraction(n)))
```

{{out}}

```txt

0,00  0,10
0,01  0,10
0,02  0,10
0,03  0,10
0,04  0,10
0,05  0,10
0,06  0,18
...
0,25  0,38
0,26  0,44
0,27  0,44
0,28  0,44
0,29  0,44
0,30  0,44
0,31  0,50
0,32  0,50
0,33  0,50
0,34  0,50
0,35  0,50
0,36  0,54
0,37  0,54
...
0,88  0,94
0,89  0,94
0,90  0,94
0,91  0,98
0,92  0,98
0,93  0,98
0,94  0,98
0,95  0,98
0,96  1,00
0,97  1,00
0,98  1,00
0,99  1,00
1,00  1,00

```

## Seed7

```seed7
\$ include "seed7_05.s7i";
include "float.s7i";

const func float: computePrice (in float: x) is func
result
var float: price is 0.0;
begin
if x >= 0.0 and x < 0.06 then
price := 0.10;
elsif x < 0.11 then
price := 0.18;
elsif x < 0.36 then
price := flt(((trunc(x * 100.0) - 11) div 5) * 6 + 26) / 100.0;
elsif x < 0.96 then
price := flt(((trunc(x * 100.0) - 31) div 5) * 4 + 50) / 100.0;
else
price := 1.0;
end if;
end func;

const proc: main is func
local
var integer: i is 0;
begin
for i range 0 to 100 do
writeln(flt(i) / 100.0 digits 2 <& " " <& computePrice(flt(i) / 100.0) digits 2);
end for;
end func;
```

The following variant of ''computePrice'' works with a table and raises RANGE_ERROR when x < 0.0 or x >= 1.01 holds:

```seed7
const array array float: table is [] (
[] (0.06, 0.10), [] (0.11, 0.18), [] (0.16, 0.26), [] (0.21, 0.32), [] (0.26, 0.38),
[] (0.31, 0.44), [] (0.36, 0.50), [] (0.41, 0.54), [] (0.46, 0.58), [] (0.51, 0.62),
[] (0.56, 0.66), [] (0.61, 0.70), [] (0.66, 0.74), [] (0.71, 0.78), [] (0.76, 0.82),
[] (0.81, 0.86), [] (0.86, 0.90), [] (0.91, 0.94), [] (0.96, 0.98), [] (1.01, 1.00));

const func float: computePrice (in float: x) is func
result
var float: price is 0.0;
local
var integer: index is 1;
begin
if x >= 0.0 then
while x >= table[index][1] do
incr(index);
end while;
price := table[index][2];
else
raise RANGE_ERROR;
end if;
end func;
```

## Sidef

```ruby
var table = <<'EOT'.lines.map { .words.grep{.is_numeric}.map{.to_n} }
>=  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
EOT

func price(money) {
table.each { |row|
(row[0] <= money) ->
&& (row[1] >  money) ->
&& return row[2];
}
die "Out of range";
}

for n in %n(0.3793 0.4425 0.0746 0.6918 0.2993 0.5486 0.7848 0.9383 0.2292) {
say price(n);
}
```

{{out}}

```txt

0.54
0.58
0.18
0.78
0.44
0.66
0.86
0.98
0.38

```

## Smalltalk

{{works with|GNU Smalltalk}}

```smalltalk
"Table driven rescale"
Object subclass: PriceRescale [
|table|
PriceRescale class  >> new: theTable [
^ self basicNew initialize: theTable
]
initialize: theTable [
table := theTable asOrderedCollection.
^self
]
rescale: aPrice [ |v1 v2|
1 to: (table size - 1) do: [:i|
v1 := table at: i.
v2 := table at: (i+1).
((aPrice >= (v1 x)) & (aPrice < (v2 x)))
ifTrue: [ ^ v1 y ]
].
(aPrice < ((v1:=(table first)) x)) ifTrue: [ ^ v1 y ].
(aPrice >= ((v1:=(table last)) x)) ifTrue: [ ^ v1 y ]
]
].

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

"get a price"
(pr rescale: ( (Random between: 0 and: 100)/100 )) displayNl.
```

## Tcl

Structured as two functions, one to parse the input data as described in the problem into a form which Tcl can work with easily, and the other to perform the mapping.

```tcl
# Used once to turn the table into a "nice" form
proc parseTable table {
set map {}
set LINE_RE {^ *>= *([0-9.]+) *< *([0-9.]+) *:= *([0-9.]+) *\$}
foreach line [split \$table \n] {
if {[string trim \$line] eq ""} continue
if {[regexp \$LINE_RE \$line -> min max target]} {
lappend map \$min \$max \$target
} else {
error "invalid table format: \$line"
}
}
return \$map
}

# How to apply the "nice" table to a particular value
proc priceFraction {map value} {
foreach {minimum maximum target} \$map {
if {\$value >= \$minimum && \$value < \$maximum} {return \$target}
}
# Failed to map; return the input
return \$value
}
```

How it is used:

```tcl
# Make the mapping
set inputTable {
>=  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
}
set map [parseTable \$inputTable]

# Apply the mapping to some inputs (from the Oz example)
foreach example {.7388727 .8593103 .826687 .3444635 .0491907} {
puts "\$example -> [priceFraction \$map \$example]"
}
```

{{out}}

```txt

.7388727 -> 0.82
.8593103 -> 0.90
.826687 -> 0.90
.3444635 -> 0.50
.0491907 -> 0.10

```

## Ursala

```Ursala
#import flo

le  = <0.06,.11,.16,.21,.26,.31,.36,.41,.46,.51,.56,.61,.66,.71,.76,.81,.86,.91,.96,1.01>
out = <0.10,.18,.26,.32,.38,.44,.50,.54,.58,.62,.66,.70,.74,.78,.82,.86,.90,.94,.98,1.>

price_fraction = fleq@rlPlX*|rhr\~&p(le,out)
```

main points:
* ~&p(le,out) zips the pair of lists le and out into a list of pairs
* A function of the form f\y applied to an argument x evaluates to f(x,y)
* A function of the form f*| applied to a pair (x,y) where y is a list, makes a list of pairs with x on the left of each item and an item of y on the right. Then it applies f to each pair, makes a list of the right sides of those for which f returned true, and makes a separate list of the right sides of those for which f returned false.
* The suffix rhr after the *| operator extracts the right side of the head of the right list from the result.
* The operand to the *| operator, fleq@rlPlX is the less-or-equal predicate on floating point numbers, composed with the function ~&rlPlX which transforms a triple (u,(v,w)) to (v,u)

test program:

```Ursala
#cast %eL

test = price_fraction* <0.34,0.070145,0.06,0.05,0.50214,0.56,1.,0.99,0.>

```

{{out}}

```txt
<
5.000000e-01,
1.800000e-01,
1.800000e-01,
1.000000e-01,
6.200000e-01,
7.000000e-01,
1.000000e+00,
1.000000e+00,
1.000000e-01>
```

## VBA

```vb

Option Explicit

Sub Main()
Dim test, i As Long
test = Array(0.34, 0.070145, 0.06, 0.05, 0.50214, 0.56, 1#, 0.99, 0#, 0.7388727)
For i = 0 To UBound(test)
Debug.Print test(i) & " := " & Price_Fraction(CSng(test(i)))
Next i
End Sub

Private Function Price_Fraction(n As Single) As Single
Dim Vin, Vout, i As Long
Vin = Array(0.06, 0.11, 0.16, 0.21, 0.26, 0.31, 0.36, 0.41, 0.46, 0.51, 0.56, 0.61, 0.66, 0.71, 0.76, 0.81, 0.86, 0.91, 0.96, 1.01)
Vout = Array(0.1, 0.18, 0.26, 0.32, 0.38, 0.44, 0.5, 0.54, 0.58, 0.62, 0.66, 0.7, 0.74, 0.78, 0.82, 0.86, 0.9, 0.94, 0.98, 1#)
For i = 0 To UBound(Vin)
If n < Vin(i) Then Price_Fraction = Vout(i): Exit For
Next i
End Function
```

{{Out}}

```txt
0.34 := 0.5
0.070145 := 0.18
0.06 := 0.18
0.05 := 0.1
0.50214 := 0.62
0.56 := 0.7
1 := 1
0.99 := 1
0 := 0.1
0.7388727 := 0.82
```

## VBScript

```vb

Function pf(p)
If p < 0.06 Then
pf = 0.10
ElseIf p < 0.11 Then
pf = 0.18
ElseIf p < 0.16 Then
pf = 0.26
ElseIf p < 0.21 Then
pf = 0.32
ElseIf p < 0.26 Then
pf = 0.38
ElseIf p < 0.31 Then
pf = 0.44
ElseIf p < 0.36 Then
pf = 0.50
ElseIf p < 0.41 Then
pf = 0.54
ElseIf p < 0.46 Then
pf = 0.58
ElseIf p < 0.51 Then
pf = 0.62
ElseIf p < 0.56 Then
pf = 0.66
ElseIf p < 0.61 Then
pf = 0.70
ElseIf p < 0.66 Then
pf = 0.74
ElseIf p < 0.71 Then
pf = 0.78
ElseIf p < 0.76 Then
pf = 0.82
ElseIf p < 0.81 Then
pf = 0.86
ElseIf p < 0.86 Then
pf = 0.90
ElseIf p < 0.91 Then
pf = 0.94
ElseIf p < 0.96 Then
pf = 0.98
Else
pf = 1.00
End If
End Function

WScript.Echo pf(0.7388727)
WScript.Echo pf(0.8593103)
WScript.Echo pf(0.826687)
WScript.Echo pf(0.3444635)

```

{{Out}}

```txt

0.82
0.9
0.9
0.5

```

## XPL0

```XPL0
include c:\cxpl\codes;  \intrinsic 'code' declarations

func real Price(V);     \Convert to standard value
real V;
[V:= V + 0.001;         \avoids possible rounding error i.e. 0.059999999
case of
V < 0.06: ret 0.10;
V < 0.11: ret 0.18;
V < 0.16: ret 0.26;
V < 0.21: ret 0.32;
V < 0.26: ret 0.38;
V < 0.31: ret 0.44;
V < 0.36: ret 0.50;
V < 0.41: ret 0.54;
V < 0.46: ret 0.58;
V < 0.51: ret 0.62;
V < 0.56: ret 0.66;
V < 0.61: ret 0.70;
V < 0.66: ret 0.74;
V < 0.71: ret 0.78;
V < 0.76: ret 0.82;
V < 0.81: ret 0.86;
V < 0.86: ret 0.90;
V < 0.91: ret 0.94;
V < 0.96: ret 0.98
other       ret 1.00;
];

[Format(1,2);
RlOut(0, Price(0.0599));  CrLf(0);
RlOut(0, Price(0.10));  CrLf(0);
RlOut(0, Price(1.0));  CrLf(0);
]
```

{{out}}

```txt

0.18
0.18
1.00

```

## zkl

```zkl
fcn convert(price){ // float --> float
//   <    -->, increments of 0.05 but tables are easier to update
var vert=T( T(0.06, 0.10), T(0.11, 0.18), T(0.16, 0.26),
T(0.21, 0.32), T(0.26, 0.38), T(0.31, 0.44),
T(0.36, 0.50), T(0.41, 0.54), T(0.46, 0.58),
T(0.51, 0.62), T(0.56, 0.66), T(0.61, 0.70),
T(0.66, 0.74), T(0.71, 0.78), T(0.76, 0.82),
T(0.81, 0.86), T(0.86, 0.90), T(0.91, 0.94),
T(0.96, 0.98), T(1.01, 1.00), );
vert.filter1('wrap([(a,_)]){ price