Rosetta Code

Price fraction: Difference between revisions

Page Discussion

Price fraction (view source)

Revision as of 19:28, 1 May 2024

44,919 bytes added ,  18 days ago
→‎{{header|langur}}
(→‎{{header|Go}}: Turned this old code into a runnable program with examples.)
 
(41 intermediate revisions by 26 users not shown)
Line 28:
>= 0.96 < 1.01 := 1.00
<br><br>
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">F bisect_right(a, x)
V lo = 0
V hi = a.len
L lo < hi
V mid = (lo + hi) I/ 2
I x < a[mid]
hi = mid
E
lo = mid + 1
R lo
 
V _cin = [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]
V _cout = [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]
F pricerounder(pricein)
R :_cout[bisect_right(:_cin, pricein)]
 
L(i) 0..10
print(‘#.2 #.2’.format(i / 10, pricerounder(i / 10)))</syntaxhighlight>
 
{{out}}
<pre>
0.00 0.10
0.10 0.18
0.20 0.32
0.30 0.44
0.40 0.54
0.50 0.62
0.60 0.70
0.70 0.78
0.80 0.86
0.90 0.94
1.00 1.00
</pre>
 
=={{header|Action!}}==
<syntaxhighlight lang="action!">DEFINE COUNT="20"
BYTE ARRAY levels=[6 11 16 21 26 31 36 41 46 51 56 61 66 71 76 81 86 91 96 101]
BYTE ARRAY values=[10 18 26 32 38 44 50 54 58 62 66 70 74 78 82 86 90 94 98 100]
 
PROC PrintValue(BYTE v)
PrintB(v/100) Put('.)
v=v MOD 100
PrintB(v/10)
v=v MOD 10
PrintB(v)
RETURN
 
BYTE FUNC Map(BYTE v)
BYTE i
 
FOR i=0 TO COUNT-1
DO
IF v<levels(i) THEN
RETURN (values(i))
FI
OD
RETURN (v)
 
PROC Main()
BYTE i,v
 
FOR i=0 TO 100
DO
v=Map(i)
PrintValue(v)
IF i MOD 5=4 THEN
PutE()
ELSE
Put(' )
FI
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Price_fraction.png Screenshot from Atari 8-bit computer]
<pre>
0.10 0.10 0.10 0.10 0.10
0.10 0.18 0.18 0.18 0.18
0.18 0.26 0.26 0.26 0.26
0.26 0.32 0.32 0.32 0.32
0.32 0.38 0.38 0.38 0.38
0.38 0.44 0.44 0.44 0.44
0.44 0.50 0.50 0.50 0.50
0.50 0.54 0.54 0.54 0.54
0.54 0.58 0.58 0.58 0.58
0.58 0.62 0.62 0.62 0.62
0.62 0.66 0.66 0.66 0.66
0.66 0.70 0.70 0.70 0.70
0.70 0.74 0.74 0.74 0.74
0.74 0.78 0.78 0.78 0.78
0.78 0.82 0.82 0.82 0.82
0.82 0.86 0.86 0.86 0.86
0.86 0.90 0.90 0.90 0.90
0.90 0.94 0.94 0.94 0.94
0.94 0.98 0.98 0.98 0.98
0.98 1.00 1.00 1.00 1.00
1.00
</pre>
 
=={{header|Ada}}==
<syntaxhighlight lang="ada">
<lang Ada>
type Price is delta 0.01 digits 3 range 0.0..1.0;
function Scale (Value : Price) return Price is
Line 62 ⟶ 163:
end loop;
end Scale;
</syntaxhighlight>
</lang>
The solution uses fixed point type to prevent rounding and representation issues. With the above declarations a full coverage test:
<syntaxhighlight lang="ada">
<lang Ada>
with Ada.Text_IO; use Ada.Text_IO;
procedure Test_Price_Fraction is
Line 76 ⟶ 177:
end loop;
end Test_Price_Fraction;
</syntaxhighlight>
</lang>
{{out}}
<div style="height: 200px;overflow:scroll">
Line 191 ⟶ 292:
{{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}}
<langsyntaxhighlight lang="algol68">main:
(
# Just get a random price between 0 and 1 #
Line 220 ⟶ 321:
 
printf(($"Value : "z.2dl,"Converted to standard : "z.2dl$, price, std val))
)</langsyntaxhighlight>
{{out}}
<pre>
Line 226 ⟶ 327:
Converted to standard : 0.54
</pre>
 
=={{header|AppleScript}}==
===Procedural===
The task description doesn't make a lot of sense, implying that the pharmacist charges no more than 1.00 for his wares and that even whole-number prices are nudged by 0.10 and odd ones aren't. This offering takes any decimal currency value and standardises just the fractional part:
 
<syntaxhighlight lang="applescript">-- This handler just returns the standardised real value. It's up to external processes to format it for display.
 
on standardisePrice(input)
set integerPart to input div 1.0
set fractionalPart to input mod 1.0
if (fractionalPart is 0.0) then
return input as real
else if (fractionalPart < 0.06) then
return integerPart + 0.1
else if (fractionalPart < 0.16) then
return integerPart + 0.18 + (fractionalPart - 0.06) div 0.05 * 0.08
else if (fractionalPart < 0.36) then
return integerPart + 0.32 + (fractionalPart - 0.16) div 0.05 * 0.06
else if (fractionalPart < 0.96) then
return integerPart + 0.54 + (fractionalPart - 0.36) div 0.05 * 0.04
else
return integerPart + 1.0
end if
end standardisePrice
 
-- Test code:
set originals to {}
set standardised to {}
repeat 20 times
set price to (random number 100) / 100
set end of originals to text 2 thru -2 of ((price + 10.001) as text)
set end of standardised to text 2 thru -2 of ((standardisePrice(price) + 10.001) as text)
end repeat
 
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to ", "
set output to linefeed & "Originals: " & originals & linefeed & "Standardised: " & standardised
set AppleScript's text item delimiters to astid
return output</syntaxhighlight>
 
{{output}}
<syntaxhighlight lang="applescript">"
Originals: 0.49, 0.79, 1.00, 0.83, 0.99, 0.23, 0.12, 0.28, 0.72, 0.37, 0.95, 0.51, 0.43, 0.52, 0.84, 0.89, 0.48, 0.48, 0.30, 0.01
Standardised: 0.62, 0.86, 1.00, 0.90, 1.00, 0.38, 0.26, 0.44, 0.82, 0.54, 0.98, 0.66, 0.58, 0.66, 0.90, 0.94, 0.62, 0.62, 0.44, 0.10"</syntaxhighlight>
 
An alternative that would save editing the handler in the event of the government department changing its directive would be to feed it a conversion table of up-to and standardised prices stored elsewhere.
 
<syntaxhighlight lang="applescript">-- This handler just returns the standardised real value. It's up to external processes to format it for display.
 
on standardisePrice(input, table)
set integerPart to input div 1.0
set fractionalPart to input mod 1.0
if (fractionalPart is 0.0) then return input as real
repeat with thisEntry in table
if (fractionalPart ≤ beginning of thisEntry) then return integerPart + (end of thisEntry)
end repeat
end standardisePrice
 
-- Test code:
-- The conceit here is that the conversion table has been obtained from a file or from a spreadsheet application.
set table to {{0.05, 0.1}, {0.1, 0.18}, {0.15, 0.26}, {0.2, 0.32}, {0.25, 0.38}, {0.3, 0.44}, {0.35, 0.5}, {0.4, 0.54}, {0.45, 58}, {0.5, 0.62}, {0.55, 0.66}, {0.6, 0.7}, {0.65, 0.74}, {0.7, 0.78}, {0.75, 0.82}, {0.8, 0.86}, {0.85, 0.9}, {0.9, 0.94}, {0.95, 0.98}, {0.99, 1.0}}
 
set originals to {}
set standardised to {}
repeat 20 times
set price to (random number 100) / 100
set end of originals to text 2 thru -2 of ((price + 10.001) as text)
set end of standardised to text 2 thru -2 of ((standardisePrice(price, table) + 10.001) as text)
end repeat
 
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to ", "
set output to linefeed & "Originals: " & originals & linefeed & "Standardised: " & standardised
set AppleScript's text item delimiters to astid
return output</syntaxhighlight>
 
{{output}}
<syntaxhighlight lang="applescript">"
Originals: 0.92, 0.86, 0.10, 0.40, 0.00, 0.34, 0.44, 0.77, 0.67, 0.19, 1.00, 0.02, 0.49, 0.40, 0.61, 0.91, 0.85, 0.54, 0.01, 0.04
Standardised: 0.98, 0.94, 0.18, 0.54, 0.00, 0.50, 8.00, 0.86, 0.78, 0.32, 1.00, 0.10, 0.62, 0.54, 0.74, 0.98, 0.90, 0.66, 0.10, 0.10"</syntaxhighlight>
 
===Functional===
<syntaxhighlight lang="applescript">---------------------- PRICE FRACTION ----------------------
 
property table : [¬
{0.06, 0.1}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32}, {0.26, 0.38}, ¬
{0.31, 0.44}, {0.36, 0.5}, {0.41, 0.54}, {0.46, 0.58}, {0.51, 0.62}, ¬
{0.56, 0.66}, {0.61, 0.7}, {0.66, 0.74}, {0.71, 0.78}, {0.76, 0.82}, ¬
{0.81, 0.86}, {0.86, 0.9}, {0.91, 0.94}, {0.96, 0.98}, {1.01, 1.0}]
 
 
-- rescaled :: [(Float, Float)] -> Float -> Float
on rescaled(table)
script
on |λ|(x)
if 0 > x or 1.01 < x then
|Left|("Out of range.")
else
|Right|(snd(my head(dropWhile(compose(ge(x), my fst), table))))
end if
end |λ|
end script
end rescaled
 
 
--------------------------- TEST ---------------------------
on run
fTable("Price adjustments:\n", ¬
showReal(2), either(identity, showReal(2)), ¬
rescaled(table), enumFromThenTo(-0.05, 0, 1.1))
end run
 
 
----------- GENERAL AND REUSABLE PURE FUNCTIONS ------------
 
-- Left :: a -> Either a b
on |Left|(x)
{type:"Either", |Left|:x, |Right|:missing value}
end |Left|
 
 
-- Right :: b -> Either a b
on |Right|(x)
{type:"Either", |Left|:missing value, |Right|:x}
end |Right|
 
 
-- compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
on compose(f, g)
script
property mf : mReturn(f)
property mg : mReturn(g)
on |λ|(x)
mf's |λ|(mg's |λ|(x))
end |λ|
end script
end compose
 
 
-- drop :: Int -> [a] -> [a]
-- drop :: Int -> String -> String
on drop(n, xs)
set c to class of xs
if script is not c then
if string is not c then
if n < length of xs then
items (1 + n) thru -1 of xs
else
{}
end if
else
if n < length of xs then
text (1 + n) thru -1 of xs
else
""
end if
end if
else
take(n, xs) -- consumed
return xs
end if
end drop
 
 
-- dropWhile :: (a -> Bool) -> [a] -> [a]
-- dropWhile :: (Char -> Bool) -> String -> String
on dropWhile(p, xs)
set lng to length of xs
set i to 1
tell mReturn(p)
repeat while i ≤ lng and |λ|(item i of xs)
set i to i + 1
end repeat
end tell
drop(i - 1, xs)
end dropWhile
 
 
-- either :: (a -> c) -> (b -> c) -> Either a b -> c
on either(lf, rf)
script
on |λ|(e)
if missing value is |Left| of e then
tell mReturn(rf) to |λ|(|Right| of e)
else
tell mReturn(lf) to |λ|(|Left| of e)
end if
end |λ|
end script
end either
 
 
-- enumFromThenTo :: Int -> Int -> Int -> [Int]
on enumFromThenTo(x1, x2, y)
set xs to {}
set d to x2 - x1
set v to x1
repeat until v ≥ y
set end of xs to v
set v to d + v
end repeat
return xs
end enumFromThenTo
 
 
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl
 
 
-- fst :: (a, b) -> a
on fst(tpl)
if class of tpl is record then
|1| of tpl
else
item 1 of tpl
end if
end fst
 
 
-- fTable :: String -> (a -> String) -> (b -> String) -> (a -> b) -> [a] -> String
on fTable(s, xShow, fxShow, f, xs)
set ys to map(xShow, xs)
set w to maximum(map(my |length|, ys))
script arrowed
on |λ|(a, b)
justifyRight(w, space, a) & " -> " & b
end |λ|
end script
s & linefeed & unlines(zipWith(arrowed, ¬
ys, map(compose(fxShow, f), xs)))
end fTable
 
 
-- ge :: Ord a => a -> a -> Bool
on ge(a)
-- True if a is greater
-- than or equal to b.
script
on |λ|(b)
a ≥ b
end |λ|
end script
end ge
 
 
-- head :: [a] -> a
on head(xs)
if xs = {} then
missing value
else
item 1 of xs
end if
end head
 
 
-- identity :: a -> a
on identity(x)
-- The argument unchanged.
x
end identity
 
 
-- justifyLeft :: Int -> Char -> String -> String
on justifyLeft(n, cFiller, strText)
if n > length of strText then
text 1 thru n of (strText & replicate(n, cFiller))
else
strText
end if
end justifyLeft
 
 
-- justifyRight :: Int -> Char -> String -> String
on justifyRight(n, cFiller, strText)
if n > length of strText then
text -n thru -1 of ((replicate(n, cFiller) as text) & strText)
else
strText
end if
end justifyRight
 
 
-- length :: [a] -> Int
on |length|(xs)
set c to class of xs
if list is c or string is c then
length of xs
else
(2 ^ 29 - 1) -- (maxInt - simple proxy for non-finite)
end if
end |length|
 
 
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f
-- to each element of xs.
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
 
 
-- max :: Ord a => a -> a -> a
on max(x, y)
if x > y then
x
else
y
end if
end max
 
 
-- maximum :: Ord a => [a] -> a
on maximum(xs)
script
on |λ|(a, b)
if a is missing value or b > a then
b
else
a
end if
end |λ|
end script
foldl(result, missing value, xs)
end maximum
 
 
-- min :: Ord a => a -> a -> a
on min(x, y)
if y < x then
y
else
x
end if
end min
 
 
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper.
if script is class of f then
f
else
script
property |λ| : f
end script
end if
end mReturn
 
 
-- Egyptian multiplication - progressively doubling a list, appending
-- stages of doubling to an accumulator where needed for binary
-- assembly of a target length
-- replicate :: Int -> a -> [a]
on replicate(n, a)
set out to {}
if 1 > n then return out
set dbl to {a}
repeat while (1 < n)
if 0 < (n mod 2) then set out to out & dbl
set n to (n div 2)
set dbl to (dbl & dbl)
end repeat
return out & dbl
end replicate
 
 
-- showReal :: Num b => Int -> b -> String
on showReal(n)
script
on |λ|(x)
set {l, r} to splitOn(".", (x as real) as string)
l & "." & justifyLeft(n, "0", r)
end |λ|
end script
end showReal
 
 
-- snd :: (a, b) -> b
on snd(tpl)
if class of tpl is record then
|2| of tpl
else
item 2 of tpl
end if
end snd
 
 
-- splitOn :: String -> String -> [String]
on splitOn(pat, src)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, pat}
set xs to text items of src
set my text item delimiters to dlm
return xs
end splitOn
 
 
-- str :: a -> String
on str(x)
x as text
end str
 
 
-- take :: Int -> [a] -> [a]
-- take :: Int -> String -> String
on take(n, xs)
set c to class of xs
if list is c then
if 0 < n then
items 1 thru min(n, length of xs) of xs
else
{}
end if
else if string is c then
if 0 < n then
text 1 thru min(n, length of xs) of xs
else
""
end if
else if script is c then
set ys to {}
repeat with i from 1 to n
set v to |λ|() of xs
if missing value is v then
return ys
else
set end of ys to v
end if
end repeat
return ys
else
missing value
end if
end take
 
 
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation
-- of a list of strings with the newline character.
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set s to xs as text
set my text item delimiters to dlm
s
end unlines
 
 
-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
on zipWith(f, xs, ys)
set lng to min(length of xs, length of ys)
set lst to {}
if 1 > lng then
return {}
else
tell mReturn(f)
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, item i of ys)
end repeat
return lst
end tell
end if
end zipWith</syntaxhighlight>
{{Out}}
<pre>Price adjustments:
 
-0.05 -> Out of range.
0.00 -> 0.10
0.05 -> 0.10
0.10 -> 0.18
0.15 -> 0.26
0.20 -> 0.32
0.25 -> 0.38
0.30 -> 0.44
0.35 -> 0.50
0.40 -> 0.54
0.45 -> 0.58
0.50 -> 0.62
0.55 -> 0.66
0.60 -> 0.70
0.65 -> 0.74
0.70 -> 0.78
0.75 -> 0.82
0.80 -> 0.86
0.85 -> 0.90
0.90 -> 0.94
0.95 -> 0.98
1.00 -> 1.00
1.05 -> Out of range.</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">pricePoints: [
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
]
 
getPricePoint: function [price][
loop pricePoints [limit,correct][
if price < limit -> return correct
]
]
 
tests: [0.3793 0.4425 0.0746 0.6918 0.2993 0.5486 0.7849 0.9383 0.2292]
 
loop tests 'test [
print [test "=>" getPricePoint test]
]</syntaxhighlight>
 
{{out}}
 
<pre>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.7849 => 0.86
0.9383 => 0.98
0.2292 => 0.38</pre>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">; Submitted by MasterFocus --- http://tiny.cc/iTunis
 
Loop
Line 261 ⟶ 905:
Return 0 ; returns 0, indicating failure (shouldn't be reached though)
 
}</langsyntaxhighlight>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
BEGIN {
O = ".06 .11 .16 .21 .26 .31 .36 .41 .46 .51 .56 .61 .66 .71 .76 .81 .86 .91 .96 1.01"
Line 286 ⟶ 930:
}
}
</syntaxhighlight>
</lang>
 
=={{header|BASIC}}==
 
{{works with|QBasic}}
 
This could also be done by building an array, but I felt that this was simpler.
 
<langsyntaxhighlight lang="qbasic">DECLARE FUNCTION PriceFraction! (price AS SINGLE)
 
RANDOMIZE TIMER
Line 349 ⟶ 991:
PriceFraction! = price
END SELECT
END FUNCTION</langsyntaxhighlight>
 
{{out}} (run 5 times):
Line 358 ⟶ 1,000:
.0491907 .1
 
==={{header|Commodore BASICBASIC256}}===
{{trans|Gambas}}
<syntaxhighlight lang="basic256">arraybase 1
dim byValue = {10, 18, 26, 32, 38, 44, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 100}
dim byLimit = {6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96}
 
for byCount = 1 to 100
for byCheck = 0 to byLimit[?]
if byCount < byLimit[byCheck] then exit for
next byCheck
print ljust((byCount/100),4," "); " -> "; ljust((byValue[byCheck]/100),4," "); chr(9);
if byCount mod 5 = 0 then print
next byCount
end</syntaxhighlight>
 
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> 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</syntaxhighlight>
 
==={{header|Commodore BASIC}}===
We'll use a couple of arrays for translation. Should work for several other 8-bit BASICs after converting the screen control codes.
 
<langsyntaxhighlight lang="gwbasic">1 rem price fraction
2 rem rosetta code
10 data 0.06,0.1,0.11,0.18,0.16,0.26,0.21,0.32,0.26,0.38,0.31,0.44,0.36,0.5
Line 384 ⟶ 1,066:
520 next i
530 np=1:return
</syntaxhighlight>
</lang>
 
{{out}}
Line 412 ⟶ 1,094:
ready.</pre>
 
==={{header|BBC BASICFreeBASIC}}===
<syntaxhighlight lang="freebasic">' FB 1.050.0 Win64
<lang bbcbasic> PRINT FNpricefraction(0.5)
 
END
Function rescale(price As Double) As Double
If price < 0.00 OrElse price > 1.00 Then Return price
DEF FNpricefraction(p)
Select Case price
IF p < 0.06 THEN = 0.10
Case IF pIs < 0.1106 THEN: =Return 0.1810
Case IF pIs < 0.1611 THEN: =Return 0.2618
Case IF pIs < 0.2116 THEN: =Return 0.3226
Case IF pIs < 0.2621 THEN: =Return 0.3832
Case IF pIs < 0.3126 THEN: =Return 0.4438
Case IF pIs < 0.3631 THEN: =Return 0.5044
Case IF pIs < 0.4136 THEN: =Return 0.5450
Case IF pIs < 0.4641 THEN: =Return 0.5854
Case IF pIs < 0.5146 THEN: =Return 0.6258
Case IF pIs < 0.5651 THEN: =Return 0.6662
Case IF pIs < 0.6156 THEN: =Return 0.7066
Case IF pIs < 0.6661 THEN: =Return 0.7470
Case IF pIs < 0.7166 THEN: =Return 0.7874
Case IF pIs < 0.7671 THEN: =Return 0.8278
Case IF pIs < 0.8176 THEN: =Return 0.8682
Case IF pIs < 0.8681 THEN: =Return 0.9086
Case IF pIs < 0.9186 THEN: =Return 0.9490
Case IF pIs < 0.9691 THEN: =Return 0.9894
Case Is =< 10.00</lang>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</syntaxhighlight>
 
{{out}}
<pre>
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
</pre>
 
==={{header|Gambas}}===
'''[https://gambas-playground.proko.eu/?gist=87527eed297164593d88aa2c35898eaf Click this link to run this code]'''
<syntaxhighlight lang="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 </syntaxhighlight>
Output:
<pre>
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
</pre>
 
==={{header|Liberty BASIC}}===
<syntaxhighlight lang="lb">
dim DR(38) 'decimal range
dim PF(38) 'corresponding price fraction
range$="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 0.01"
frac$="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 i = 1 to 38
DR(i)=val(word$(range$,i))
PF(i)=val(word$(frac$,i))
next
 
for i = 0 to .99 step 0.03
print i;" -> ";PriceFraction(i)
next
end
 
Function PriceFraction(n)
PriceFraction=n 'return original if outside test bounds
for i = 1 to 38
if n<=DR(i) then
PriceFraction=PF(i)
exit for
end if
next
end function
</syntaxhighlight>
 
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">Procedure.f PriceFraction(price.f)
;returns price unchanged if value is invalid
Protected fraction
Select price * 100
Case 0 To 5
fraction = 10
Case 06 To 10
fraction = 18
Case 11 To 15
fraction = 26
Case 16 To 20
fraction = 32
Case 21 To 25
fraction = 38
Case 26 To 30
fraction = 44
Case 31 To 35
fraction = 5
Case 36 To 40
fraction = 54
Case 41 To 45
fraction = 58
Case 46 To 50
fraction = 62
Case 51 To 55
fraction = 66
Case 56 To 60
fraction = 7
Case 61 To 65
fraction = 74
Case 66 To 70
fraction = 78
Case 71 To 75
fraction = 82
Case 76 To 80
fraction = 86
Case 81 To 85
fraction = 9
Case 86 To 90
fraction = 94
Case 91 To 95
fraction = 98
Case 96 To 100
fraction = 100
Default
ProcedureReturn price
EndSelect
ProcedureReturn fraction / 100
EndProcedure
 
If OpenConsole()
Define x.f, i
For i = 1 To 10
x = Random(10000)/10000
PrintN(StrF(x, 4) + " -> " + StrF(PriceFraction(x), 2))
Next
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf</syntaxhighlight>
{{out}}
<pre>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
0.9560 -> 1.00</pre>
 
==={{header|Run BASIC}}===
<syntaxhighlight lang="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
read oldDec
read newDec
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]</syntaxhighlight>
<pre>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</pre>
 
==={{header|True BASIC}}===
{{trans|BASIC}}
<syntaxhighlight lang="qbasic">FUNCTION pricefraction(price)
!returns price unchanged if invalid value
SELECT CASE price
CASE IS < 0
LET pricefraction = price
CASE IS < .06
LET pricefraction = .1
CASE IS < .11
LET pricefraction = .18
CASE IS < .16
LET pricefraction = .26
CASE IS < .21
LET pricefraction = .32
CASE IS < .26
LET pricefraction = .38
CASE IS < .31
LET pricefraction = .44
CASE IS < .36
LET pricefraction = .5
CASE IS < .41
LET pricefraction = .54
CASE IS < .46
LET pricefraction = .58
CASE IS < .51
LET pricefraction = .62
CASE IS < .56
LET pricefraction = .66
CASE IS < .61
LET pricefraction = .7
CASE IS < .66
LET pricefraction = .74
CASE IS < .71
LET pricefraction = .78
CASE IS < .76
LET pricefraction = .82
CASE IS < .81
LET pricefraction = .86
CASE IS < .86
LET pricefraction = .9
CASE IS < .91
LET pricefraction = .94
CASE IS < .96
LET pricefraction = .98
CASE IS < 1.01
LET pricefraction = 1
CASE ELSE
LET pricefraction = price
END SELECT
END FUNCTION
 
RANDOMIZE
FOR i = 1 TO 100
LET d = RND
PRINT USING "#.##": d;
PRINT " -> ";
PRINT USING "#.## ": pricefraction(d);
IF REMAINDER(i,5) = 0 THEN PRINT
NEXT i
END</syntaxhighlight>
 
==={{header|uBasic/4tH}}===
{{trans|Forth}}
{{works with|R3}}
<syntaxhighlight lang="text">For i = 0 To 100 Step 5
Print Using "+?.##"; i, Using "+?.##"; FUNC(_Normalize (FUNC(_Classify (i))))
Next
 
End
 
_Normalize ' normalize the price
Param (1) ' class
Local (4) ' accumulator, increment, switch and iterator
b@ = 0 : c@ = 10 : d@ = 2 ' setup accumulator, increment and switch
For e@ = 0 to a@ ' from zero to class
If And(e@ + 1, d@) Then d@ = And(d@ + d@, 15) : c@ = c@ - 2
b@ = b@ + c@ ' switch increment if needed
Next ' accumulate price
Return (Min(b@, 100)) ' clip top of price in accumulator
' calculate class
_Classify Param (1) : Return ((a@ - (a@>0)) / 5)</syntaxhighlight>
Output:
<pre>
0.00 0.10
0.05 0.10
0.10 0.18
0.15 0.26
0.20 0.32
0.25 0.38
0.30 0.44
0.35 0.50
0.40 0.54
0.45 0.58
0.50 0.62
0.55 0.66
0.60 0.70
0.65 0.74
0.70 0.78
0.75 0.82
0.80 0.86
0.85 0.90
0.90 0.94
0.95 0.98
1.00 1.00
 
0 OK, 0:115</pre>
 
 
==={{header|VBA}}===
<syntaxhighlight lang="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</syntaxhighlight>
{{Out}}
<pre>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</pre>
 
==={{header|Yabasic}}===
{{trans|BASIC256}}
<syntaxhighlight lang="vb">data 10, 18, 26, 32, 38, 44, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 100
data 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96
 
dim od(21)
for i = 1 to 20
read oldDec
od(i) = oldDec
next i
dim nd(20)
for j = 1 to 19
read newDec
nd(j) = newDec
next j
 
for i = 1 to 100
for j = 1 to arraysize(nd(),1)-1
if i < nd(j) break
next j
print (i/100) using ("#.##"), " -> ", (od(j)/100) using ("#.##"), "\t";
if mod(i, 5) = 0 print
next i
end</syntaxhighlight>
 
=={{header|Beads}}==
<syntaxhighlight lang="beads">beads 1 program 'Price fraction'
 
record a_table
value
rescaled
const table : array of a_table = [<
value, rescaled
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 a_test = [0.05 0.62 0.34 0.93 0.45]
 
calc main_init
loop across:a_test val:v
loop across:table index:ix
if v < table[ix].value
log "{v} => {table[ix].rescaled}"
exit</syntaxhighlight>
{{out}}
<pre>0.05 => 0.1
0.62 => 0.74
0.34 => 0.5
0.93 => 0.98
0.45 => 0.58</pre>
 
 
=={{header|Bracmat}}==
Bracmat has no native support for floating point variables nor for the fixed point values in the conversion table. Instead thisThis solution just applies a string comparison.
<langsyntaxhighlight lang="bracmat">( ( convert
=
. ("0.06"."0.10")
Line 476 ⟶ 1,584:
& out$(!a "-->" convert$!a)
)
)</langsyntaxhighlight>
{{out}}
<pre>0.00 --> 0.10
Line 517 ⟶ 1,625:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include<stdio.h>
 
double table[][2] = {
Line 544 ⟶ 1,652:
 
return 0;
}</langsyntaxhighlight>
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">namespace ConsoleApplication1
{
class Program
Line 599 ⟶ 1,707:
}
}
}</langsyntaxhighlight>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <cmath>
 
Line 632 ⟶ 1,740:
return 0 ;
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 650 ⟶ 1,758:
 
=={{header|Clipper}}==
<langsyntaxhighlight lang="dbase">FUNCTION PriceFraction( npQuantDispensed )
LOCAL aPriceFraction := { {0,.06,.1},;
{.06,.11,.18}, ;
Line 682 ⟶ 1,790:
nResult := aPriceFraction[ nScan ][ 3 ]
END IF
RETURN nResult</langsyntaxhighlight>
 
The function above crashes with an array access bound error if the value passed is negative.
Line 688 ⟶ 1,796:
The following is a more concise solution:
 
<langsyntaxhighlight Clipperlang="clipper">Procedure Main()
Local i
For i := -0.02 to 1.02 STEP 0.03
Line 731 ⟶ 1,839:
nResult := NIL
Endif
Return nResult</langsyntaxhighlight>
 
{{out}}
Line 772 ⟶ 1,880:
=={{header|Clojure}}==
{{trans|JavaScript}}
<langsyntaxhighlight lang="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))))</langsyntaxhighlight>
 
 
Line 808 ⟶ 1,916:
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">(defun scale (value)
(cond ((minusp value) (error "invalid value: ~A" value))
((< value 0.06) 0.10)
Line 830 ⟶ 1,938:
((< value 0.96) 0.98)
((< value 1.01) 1.00)
(t (error "invalid value: ~A" value))))</langsyntaxhighlight>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio, std.range;
 
double priceRounder(in double price) pure nothrow
Line 851 ⟶ 1,959:
foreach (const price; [0.7388727, 0.8593103, 0.826687, 0.3444635])
price.priceRounder.writeln;
}</langsyntaxhighlight>
{{out}}
<pre>0.82
Line 857 ⟶ 1,965:
0.9
0.5</pre>
 
=={{header|Dart}}==
{{trans|Swift}}
<syntaxhighlight lang="Dart">
class Range {
final double start;
final double end;
 
Range(this.start, this.end);
 
bool contains(double value) {
return value >= start && value < end;
}
}
 
List<MapEntry<Range, double>> ranges = [
MapEntry(Range(0.00, 0.06), 0.10),
MapEntry(Range(0.06, 0.11), 0.18),
MapEntry(Range(0.11, 0.16), 0.26),
MapEntry(Range(0.16, 0.21), 0.32),
MapEntry(Range(0.21, 0.26), 0.38),
MapEntry(Range(0.26, 0.31), 0.44),
MapEntry(Range(0.31, 0.36), 0.50),
MapEntry(Range(0.36, 0.41), 0.54),
MapEntry(Range(0.41, 0.46), 0.58),
MapEntry(Range(0.46, 0.51), 0.62),
MapEntry(Range(0.51, 0.56), 0.66),
MapEntry(Range(0.56, 0.61), 0.70),
MapEntry(Range(0.61, 0.66), 0.74),
MapEntry(Range(0.66, 0.71), 0.78),
MapEntry(Range(0.71, 0.76), 0.82),
MapEntry(Range(0.76, 0.81), 0.86),
MapEntry(Range(0.81, 0.86), 0.90),
MapEntry(Range(0.86, 0.91), 0.94),
MapEntry(Range(0.91, 0.96), 0.98),
MapEntry(Range(0.96, 1.01), 1.00),
];
 
double adjustDouble(double val, List<MapEntry<Range, double>> ranges) {
for (var range in ranges) {
if (range.key.contains(val)) {
return range.value;
}
}
return val; // Return the original value if no range is found
}
 
void main() {
for (double val = 0.0; val <= 1.0; val += 0.01) {
String strFmt(double n) => n.toStringAsFixed(2);
 
double adjusted = adjustDouble(val, ranges);
print("${strFmt(val)} -> ${strFmt(adjusted)}");
}
}
</syntaxhighlight>
{{out}}
<pre style="overflow: scroll; height: 20em">
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.18
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
 
</pre>
 
=={{header|Delphi}}==
See [https://rosettacode.org/wiki/Price_fraction#Pascal Pascal].
 
=={{header|EasyLang}}==
<syntaxhighlight lang=easylang>
n[] = [ 10 18 26 32 38 44 50 54 58 62 66 70 74 78 82 86 90 94 98 100 ]
func conv p .
cat = (p - 1) div 5 + 1
return n[cat]
.
for in = 5 step 5 to 100
if in = 100
in$ = "1.00"
elif in < 10
in$ = "0.0" & in
else
in$ = "0." & in
.
out = conv in
if out = 100
out$ = "1.00"
else
out$ = "0." & out
.
print in$ & " -> " & out$
.
</syntaxhighlight>
{{out}}
<pre>
0.05 -> 0.10
0.10 -> 0.18
0.15 -> 0.26
0.20 -> 0.32
0.25 -> 0.38
0.30 -> 0.44
0.35 -> 0.50
0.40 -> 0.54
0.45 -> 0.58
0.50 -> 0.62
0.55 -> 0.66
0.60 -> 0.70
0.65 -> 0.74
0.70 -> 0.78
0.75 -> 0.82
0.80 -> 0.86
0.85 -> 0.90
0.90 -> 0.94
0.95 -> 0.98
1.00 -> 1.00
</pre>
 
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
<lang Eiffel>
class
APPLICATION
Line 891 ⟶ 2,210:
 
end
</syntaxhighlight>
</lang>
<syntaxhighlight lang="eiffel">
<lang Eiffel>
class
PRICE_FRACTION
Line 934 ⟶ 2,253:
 
end
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 959 ⟶ 2,278:
 
=={{header|Elixir}}==
<langsyntaxhighlight lang="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},
Line 974 ⟶ 2,293:
Enum.each(val, fn x ->
:io.format "~5.2f ->~5.2f~n", [x, Price.fraction(x)]
end)</langsyntaxhighlight>
 
{{out}}
Line 1,000 ⟶ 2,319:
 
=={{header|Erlang}}==
<langsyntaxhighlight lang="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;
Line 1,021 ⟶ 2,340:
priceFraction(N) when N < 0.91 -> 0.94;
priceFraction(N) when N < 0.96 -> 0.98;
priceFraction(N) -> 1.00.</langsyntaxhighlight>
 
=={{header|Euphoria}}==
{{trans|C}}
<langsyntaxhighlight lang="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},
Line 1,044 ⟶ 2,363:
for i = 0 to 99 do
printf(1, "%.2f %.2f\n", { i/100, price_fix(i/100) })
end for</langsyntaxhighlight>
 
=={{header|F_Sharp|F#}}==
Inspired by Python's bisect solution. Using decimal (System.Decimal) to avoid number representation problems with floats.
<langsyntaxhighlight lang="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]
 
Line 1,064 ⟶ 2,383:
[ 0.m .. 0.01m .. 1.m ]
|> Seq.ofList
|> Seq.iter (fun p -> printfn "%.2f -> %.2f" p (priceadjuster p))</langsyntaxhighlight>
{{out}}
The same as shown by Ada as of 2013-11-03T17:42Z (apart from whitespace formatting)
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">CONSTANT: dispensary-data {
{ 0.06 0.10 }
{ 0.11 0.18 }
Line 1,093 ⟶ 2,412:
: price-fraction ( n -- n ) dispensary-data [ first over >= ] find 2nip second ;
 
{ 0 0.5 0.65 0.66 1 } [ price-fraction ] map</langsyntaxhighlight>
 
{{out}}
Line 1,101 ⟶ 2,420:
=={{header|Fantom}}==
 
<langsyntaxhighlight lang="fantom">
class Defn // to hold the three numbers from a 'row' in the table
{
Line 1,171 ⟶ 2,490:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Forth}}==
Line 1,177 ⟶ 2,496:
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.
 
<langsyntaxhighlight lang="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
Line 1,188 ⟶ 2,507:
: round ( n-cents -- n-cents' )
>r bounds begin dup @ r@ > while cell+ repeat
r> drop official@ ;</langsyntaxhighlight>
This one is done in the spirit of "Thinking Forth" and doesn't use any tables at all.
<syntaxhighlight lang="text">: ?adjust 1+ over and if 2* 15 and >r 2 - r> then ;
: accumulate >r dup >r + r> r> ;
: classify dup 0> if 1- then 5 / ;
: calculate do i ?adjust accumulate loop drop drop 100 min ;
: normalize classify >r 0 10 2 r> 1+ 0 calculate ;
: print s>d <# # # [char] . hold #s #> type ;
 
: test cr 101 0 ?do i print i 2 spaces normalize print cr 5 +loop ;
 
test</syntaxhighlight>
Output:
<pre>
0.00 0.10
0.05 0.10
0.10 0.18
0.15 0.26
0.20 0.32
0.25 0.38
0.30 0.44
0.35 0.50
0.40 0.54
0.45 0.58
0.50 0.62
0.55 0.66
0.60 0.70
0.65 0.74
0.70 0.78
0.75 0.82
0.80 0.86
0.85 0.90
0.90 0.94
0.95 0.98
1.00 1.00
</pre>
 
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<langsyntaxhighlight lang="fortran">program price_fraction
 
implicit none
Line 1,210 ⟶ 2,564:
end do
 
end program price_fraction</langsyntaxhighlight>
{{out}}
<syntaxhighlight lang="text">0.997560 1.00
0.566825 0.70
0.965915 1.00
Line 1,221 ⟶ 2,575:
0.005355 0.10
0.347081 0.50
0.342244 0.50</langsyntaxhighlight>
 
=={{header|FreeBASICFutureBasic}}==
<syntaxhighlight lang="futurebasic">
<lang freebasic>' FB 1.050.0 Win64
local fn PriceFraction( price as double ) as double
double result
if price < 0.00 or price > 1.00 then exit fn = price
if price < 0.06 then exit fn = 0.10
if price < 0.11 then exit fn = 0.18
if price < 0.16 then exit fn = 0.26
if price < 0.21 then exit fn = 0.32
if price < 0.26 then exit fn = 0.38
if price < 0.31 then exit fn = 0.44
if price < 0.36 then exit fn = 0.50
if price < 0.41 then exit fn = 0.54
if price < 0.46 then exit fn = 0.58
if price < 0.51 then exit fn = 0.62
if price < 0.56 then exit fn = 0.66
if price < 0.61 then exit fn = 0.70
if price < 0.66 then exit fn = 0.74
if price < 0.71 then exit fn = 0.78
if price < 0.76 then exit fn = 0.82
if price < 0.81 then exit fn = 0.86
if price < 0.86 then exit fn = 0.90
if price < 0.91 then exit fn = 0.94
if price < 0.96 then exit fn = 0.98
result = 1.00
end fn = result
 
void local fn GetPriceFractions
Function rescale(price As Double) As Double
NSUInteger i
If price < 0.00 OrElse price > 1.00 Then Return price
Select Case price
for i = 1 to 100
Case Is < 0.06 : Return 0.10
Casedouble Isd <= 0i/100.11 : Return 0.18
printf @"%.2f -> %.2f\t\b", d, fn PriceFraction( d )
Case Is < 0.16 : Return 0.26
Caseif Isi <mod 0.215 : Return== 0.32 then print
next
Case Is < 0.26 : Return 0.38
end fn
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
 
fn GetPriceFractions
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
 
NSLog( @"%@", fn WindowPrintViewString( 1 ) )
Print
Print "Press any key to quit"
Sleep</lang>
 
HandleEvents
{{out}}
</syntaxhighlight>
{{output}}
<pre>
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
</pre>
 
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=87527eed297164593d88aa2c35898eaf Click this link to run this code]'''
<lang 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 </lang>
Output:
<pre>
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
</pre>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 1,385 ⟶ 2,702:
fmt.Printf("%0.4f -> %0.2f\n", v, pf(v))
}
}</langsyntaxhighlight>
 
<pre>
Line 1,401 ⟶ 2,718:
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">def priceFraction(value) {
assert value >= 0.0 && value <= 1.0
 
Line 1,417 ⟶ 2,734:
for (def v = 0.00; v <= 1.00; v += 0.01) {
println "$v --> ${priceFraction(v)}"
}</langsyntaxhighlight>
{{out}}
<div style="height: 200px;overflow:scroll">
Line 1,524 ⟶ 2,841:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">price_fraction n
| n < 0 || n > 1 = error "Values must be between 0 and 1."
| n < 0.06 = 0.10
Line 1,545 ⟶ 2,862:
| n < 0.91 = 0.94
| n < 0.96 = 0.98
| otherwise = 1.00</langsyntaxhighlight>
Alternative {{trans|OCaml}}:
<langsyntaxhighlight lang="haskell">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),
Line 1,556 ⟶ 2,873:
price_fraction n
| n < 0 || n > 1 = error "Values must be between 0 and 1."
| otherwise = snd $ head $ dropWhile ((<= n) . fst) table</langsyntaxhighlight>
 
=={{header|HicEst}}==
<langsyntaxhighlight HicEstlang="hicest">DIMENSION upperbound(20), rescaleTo(20), temp(20)
upperbound = (.06,.11,.16,.21,.26,.31,.36,.41,.46,.51,.56,.61,.66,.71,.76,.81,.86,.91,.96,1.01)
rescaleTo = (.10,.18,.26,.32,.38,.44,.50,.54,.58,.62,.66,.70,.74,.78,.82,.86,.90,.94,.98,1.00)
Line 1,568 ⟶ 2,885:
PriceFraction = rescaleTo( INDEX(temp, 0) )
WRITE(Format="F8.6, F6.2") value, PriceFraction
ENDDO</langsyntaxhighlight>
<pre>0.589230 0.70
0.017623 0.10
Line 1,582 ⟶ 2,899:
=={{header|Icon}} and {{header|Unicon}}==
 
<syntaxhighlight lang="icon">
<lang Icon>
record Bounds(low,high,new)
 
Line 1,622 ⟶ 2,939:
}
end
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,642 ⟶ 2,959:
Inform doesn't have native floating-point support; this version uses fixed point numbers with two decimal places.
 
<langsyntaxhighlight lang="inform7">Home is a room.
 
Price is a kind of value. 0.99 specifies a price.
Line 1,678 ⟶ 2,995:
let P be a random price between 0.00 and 1.00;
say "[P] -> [standardized value of P].";
end the story.</langsyntaxhighlight>
 
=={{header|J}}==
'''Solution:'''
<langsyntaxhighlight lang="j">le =: -0.96 0.91 0.86 0.81 0.76 0.71 0.66 0.61 0.56 0.51 0.46 0.41 0.36 0.31 0.26 0.21 0.16 0.11 0.06 0.0
out =: 1.00 0.98 0.94 0.90 0.86 0.82 0.78 0.74 0.70 0.66 0.62 0.58 0.54 0.50 0.44 0.38 0.32 0.26 0.18 0.1
 
priceFraction =: out {~ le I. -</langsyntaxhighlight>
 
'''Example:'''
<langsyntaxhighlight lang="j"> priceFraction 0.34 0.070145 0.06 0.05 0.50214 0.56 1 0.99 0
0.5 0.18 0.18 0.1 0.62 0.7 1 1 0.1</langsyntaxhighlight>
 
This implementation performs a binary search on the boundary values, and then uses the resulting index to select from the result values.
Line 1,696 ⟶ 3,013:
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.util.Random;
 
public class Main {
Line 1,730 ⟶ 3,047:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>0.149969 -> 0.26
Line 1,749 ⟶ 3,066:
Passing a value outside the range 0 <= x < 1.01 will return undefined.
 
<langsyntaxhighlight lang="javascript">function getScaleFactor(v) {
 
var values = ['0.10','0.18','0.26','0.32','0.38','0.44','0.50','0.54',
Line 1,756 ⟶ 3,073:
 
return values[(v * 100 - 1) / 5 | 0];
}</langsyntaxhighlight>
 
=={{header|jq}}==
The solution given here is based on the JavaScript solution.
<langsyntaxhighlight lang="jq">def getScaleFactor:
["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"] as $values
| $values[ (. * 100 - 1) / 5 | floor ] ;</langsyntaxhighlight>
The full coverage test as given in the Ada example:
<langsyntaxhighlight lang="jq">def test:
(range(0;10) | "0.0\(.) -> \( 0.01 * . | getScaleFactor)"),
(range(10;100) | "0.\(.) -> \( 0.01 * . | getScaleFactor)");
 
test</langsyntaxhighlight>
Run the test, showing the first few lines of output:
<pre>
Line 1,790 ⟶ 3,107:
=={{header|Julia}}==
This solution is somewhat straightforward but does highlight a couple of Julia features. The interval cut-offs and values are exactly represented by rational numbers. The interval to which an input value belongs is identified by applying the <code>findfirst</code> (true value) function to an element-wise comparison (<code>.&lt;</code>) of this value to the cut-off array.
<syntaxhighlight lang="julia">
<lang Julia>
const PFCUT = [6:5:101]//100
const PFVAL = [10:8:26, 32:6:50, 54:4:98, 100]//100
Line 1,806 ⟶ 3,123:
println(@sprintf " %.4f -> %.4f" t pricefraction(t))
end
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,844 ⟶ 3,161:
Translation of the J solution:
 
<syntaxhighlight lang="k">
<lang K>
le:- 0.96 0.91 0.86 0.81 0.76 0.71 0.66 0.61 0.56 0.51 0.46 0.41 0.36 0.31 0.26 0.21 0.16 0.11 0.06 0.0
out: 1.00 0.98 0.94 0.90 0.86 0.82 0.78 0.74 0.70 0.66 0.62 0.58 0.54 0.50 0.44 0.38 0.32 0.26 0.18 0.1
 
pf:{out@_bin[le;-x]}'
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,857 ⟶ 3,174:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.0.6
 
fun rescale(price: Double): Double =
Line 1,890 ⟶ 3,207:
if (i % 5 == 0) println()
}
}</langsyntaxhighlight>
 
{{out}}
Line 1,919 ⟶ 3,236:
Langur uses decimal floating point.
 
<langsyntaxhighlight lang="langur">#val using.pricefrac an= impliedfn(.f) parameter{ switch[and] .f ...{
val .pricefrac = f given .f {
case >= 0.00, < 0.06: 0.10
case >= 0.06, < 0.11: 0.18
Line 1,942 ⟶ 3,258:
case >= 0.96, <= 1.00: 1.00
default: throw "bad data"
}}
 
# The default operator between test cases is "and".
# That is, writing "case" without a logical operator is the same as writing "case and".
# To make a given case act as a switch case does in other languages, use "case or".
}
 
writeln .pricefrac(0.17)
writeln .pricefrac(0.71)</langsyntaxhighlight>
 
{{out}}
<pre>0.32
0.82</pre>
 
=={{header|Liberty BASIC}}==
<lang lb>
dim DR(38) 'decimal range
dim PF(38) 'corresponding price fraction
range$="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 0.01"
frac$="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 i = 1 to 38
DR(i)=val(word$(range$,i))
PF(i)=val(word$(frac$,i))
next
 
for i = 0 to .99 step 0.03
print i;" -> ";PriceFraction(i)
next
end
 
Function PriceFraction(n)
PriceFraction=n 'return original if outside test bounds
for i = 1 to 38
if n<=DR(i) then
PriceFraction=PF(i)
exit for
end if
next
end function
</lang>
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">scaleTable = {
{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},
Line 2,004 ⟶ 3,289:
print("Adjusted price:", rescale(rnd))
print()
end</langsyntaxhighlight>
{{out}}
<pre>Random value: 0.61946413522022
Line 2,020 ⟶ 3,305:
Random value: 0.36528313938816
Adjusted price: 0.54</pre>
 
=={{header|M2000 Interpreter}}==
Derived from BASIC
 
<syntaxhighlight lang="m2000 interpreter">
Module PriceFraction {
Currency i
Print $("0.00"),
for i=0@ to 1@ step .10@
Print i, @PriceFraction(i)
next
Print $(""),
function PriceFraction(price as currency)
select case price
case < 0
= price
case < .06
= .1
case < .11
= .18
case < .16
= .26
case < .21
= .32
case < .26
= .38
case < .31
= .44
case < .36
= .5
case < .41
= .54
case < .46
= .58
case < .51
= .62
case < .56
= .66
case < .61
= .7
case < .66
= .74
case < .71
= .78
case < .76
= .82
case < .81
= .86
case < .86
= .9
case < .91
= .94
case < .96
= .98
case < 1.01
= 1!
case else
= price
end select
end function
}
PriceFraction
</syntaxhighlight>
{{out}}
<pre>
0.00 0.10
0.10 0.18
0.20 0.32
0.30 0.44
0.40 0.54
0.50 0.62
0.60 0.70
0.70 0.78
0.80 0.86
0.90 0.94
1.00 1.00
</pre>
 
 
 
=={{header|Maple}}==
<langsyntaxhighlight lang="maple">priceFraction := proc(price)
local values, standard, newPrice, i;
values := [0, 0.06, 0.11, 0.16, 0.21, 0.26, 0.31, 0.36, 0.41, 0.46, 0.51, 0.56, 0.61,
Line 2,039 ⟶ 3,404:
for i to 5 do
priceFraction (rand(0.0..1.0)());
end do;</langsyntaxhighlight>
{{out}}
<pre>0.524386 --> 0.66
Line 2,047 ⟶ 3,412:
0.540447 --> 0.66</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">PriceFraction[x_]:=Piecewise[{{.1, 0 <= x < 0.06}, {.18, x < .11}, {.26,x < 0.16},
{.32, x < .21}, {.38, x < .26}, {.44, x < 0.31}, {.5, x < .36},
{.54, x < .41}, {.58, x < .46}, {.62, x < .51}, {.66, x < .56},
{.70, x < .61}, {.74, x < .66}, {.78, x < .71}, {.82, x < .76},
{.86, x < .81}, {.90, x < .86}, {.94, x < .91}, {.98, x < .96}}, 1]</langsyntaxhighlight>
 
=={{header|MATLAB}} / {{header|Octave}}==
 
<langsyntaxhighlight Matlablang="matlab"> function y = rescale(x)
L = [0,.06:.05:1.02];
Line 2,068 ⟶ 3,433:
 
t=0:0.001:1;
plot(t,rescale(t)); </langsyntaxhighlight>
 
=={{header|Mercury}}==
<langsyntaxhighlight Mercurylang="mercury">:- module price.
:- interface.
:- import_module int.
Line 2,114 ⟶ 3,479:
rule(86, 91, 94),
rule(91, 96, 98),
rule(96, 101, 100)].</langsyntaxhighlight>
 
A build system might turn the text of the table into the definition of a hundred-element array of adjustments. In that case,
 
<langsyntaxhighlight Mercurylang="mercury">adjust(Cents) = array.lookup(price_table, Cents).</langsyntaxhighlight>
 
 
=={{header|MUMPS}}==
<langsyntaxhighlight MUMPSlang="mumps">PRICFRAC(X)
;Outputs a specified value dependent upon the input value
;The non-inclusive upper limits are encoded in the PFMAX string, and the values
Line 2,131 ⟶ 3,497:
FOR I=1:1:$LENGTH(PFMAX,"^") Q:($DATA(RESULT)'=0) SET:X<$P(PFMAX,"^",I) RESULT=$P(PFRES,"^",I)
KILL PFMAX,PFRES,I
QUIT RESULT</langsyntaxhighlight>
{{out}}
<pre>USER>W $$PRICFRAC^ROSETTA(.04)
Line 2,145 ⟶ 3,511:
 
=={{header|NetRexx}}==
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols nobinary
 
Line 2,202 ⟶ 3,568:
end tv
return test_vals
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,214 ⟶ 3,580:
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">import strutilsrandom, mathstrformat
 
# Representation of a standard value as an int (actual value * 100).
const
type StandardValue = distinct int
pricemap: array[0 .. 19, int] = [10,18,26,32,38,44,50,54,58,62,66,70,74,78,82,86,90,94,98,100]
 
proc `<`(a, b: StandardValue): bool {.borrow.}
 
const Pricemap = [10, 18, 26, 32, 38, 44, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 100]
 
 
proc toStandardValue(f: float): StandardValue =
## Convert a float to a standard value (decimal value multiplied by 100).
## Index: 0.01..0.05 -> 0, 0.06..0.10 -> 1, 0.11..0.15 -> 2...
var value = int(f * 100)
if value == 0: return StandardValue(10)
dec value
# Increment index every 5 of value, so value in 1..100 translates to index in 0..19.
let index = 2 * (value div 10) + (value mod 10) div 5
result = StandardValue(Pricemap[index])
 
# outputs an int (=>float*100)
proc floatToPrice100(f: float): int =
# indx: 0.1-0.05->0, 0.06-0.10->1, 0.11-0.15->2, .....
var valu: int = toInt(f*100)
if valu == 0:
result = 10
else:
dec(valu)
# inc indx every 5 of valu, so value of 1..100 translates to indx of 0..19
var indx: int = 2*int(valu/10)+int((valu%%10)/5)
result = pricemap[indx]
 
proc `$`(price: StandardValue): string =
# str representation of an int (that is a representation of a float price)
## Return the string representation of a standard value.
proc price100ToStr(p: int): string =
if pprice < StandardValue(10): "0.0" & $int(price)
elif price < result =StandardValue(100): "0.0" & $pint(price)
else: "1.00"
if p < 100:
result = "0." & $p
else:
result = "1.00"
 
randomize()
var i: int = 0
 
when isMainModule:
for x in 0 .. 10:
i = randomrandomize(101)
for _ in 0 .. 10:
echo("Price for ", i.price100ToStr(), ", is: ", float(i/100).floatToPrice100().price100ToStr())</lang>
let price = rand(1.01)
echo &"Price for {price:.2f} is {price.toStandardValue()}"</syntaxhighlight>
{{out}}
A random output looking something like this:
<pre>Price for 0.73,88 is: 0.8294
Price for 0.29,58 is: 0.4470
Price for 0.25,67 is: 0.3878
Price for 0.52,53 is: 0.66
Price for 0.66,56 is: 0.7866
Price for 0.23,02 is: 0.3810
Price for 0.62,61 is: 0.7470
Price for 0.26,41 is: 0.4458
Price for 0.70,22 is: 0.7838
Price for 0.69,91 is: 0.7898
Price for 0.39,42 is: 0.5458</pre>
 
=={{header|Objeck}}==
{{trans|C#}}
<langsyntaxhighlight lang="objeck">class PriceFraction {
function : Main(args : String[]) ~ Nil {
for(i := 0; i < 5; i++;) {
Line 2,296 ⟶ 3,663:
return inValue;
}
}</langsyntaxhighlight>
 
{{output}}
Line 2,309 ⟶ 3,676:
=={{header|OCaml}}==
 
<langsyntaxhighlight lang="ocaml">let price_fraction v =
if v < 0.0 || v >= 1.01 then
invalid_arg "price_fraction";
Line 2,323 ⟶ 3,690:
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;
]</langsyntaxhighlight>
 
<langsyntaxhighlight lang="ocaml">let () =
let ok_tests = [
(0.3793, 0.54);
Line 2,342 ⟶ 3,709:
Printf.printf " %6g %g %b\n" v r (r = ok);
) ok_tests;
;;</langsyntaxhighlight>
 
=={{header|Oforth}}==
 
<langsyntaxhighlight lang="oforth">[.06, .11, .16, .21, .26, .31, .36, .41, .46, .51, .56, .61, .66, .71, .76, .81, .86, .91, .96, 1.01] const: IN
[.10, .18, .26, .32, .38, .44, .50, .54, .58, .62, .66, .70, .74, .78, .82, .86, .90, .94, .98, 1.00] const: OUT
 
Line 2,352 ⟶ 3,719:
| i |
IN size loop: i [ f IN at(i) < ifTrue: [ OUT at(i) return ] ]
null ;</langsyntaxhighlight>
 
{{Out}}
Line 2,365 ⟶ 3,732:
i.e. a value that throws an exception when it is accessed.
 
<langsyntaxhighlight lang="oz">fun {PriceFraction X}
OutOfRange = {Value.failed outOfRange(X)}
in
Line 2,379 ⟶ 3,746:
if X < Limit then {Return Result} end
end
end</langsyntaxhighlight>
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">priceLookup=[6,11,16,21,26,31,41,46,51,56,61,66,71,76,81,86,91,96,101];
priceReplace=[10,18,26,32,38,44,50,54,58,62,66,70,74,78,82,86,90,94,98,100];
pf(x)={
Line 2,390 ⟶ 3,757:
);
"nasal demons"
};</langsyntaxhighlight>
 
=={{header|Pascal}}==
<langsyntaxhighlight lang="pascal">Program PriceFraction(output);
 
const
Line 2,417 ⟶ 3,784:
writeln (cost:6:4, ' -> ', price[j+1]:4:2);
end;
end.</langsyntaxhighlight>
{{out}}
<pre>% ./PriceFraction
Line 2,432 ⟶ 3,799:
 
=={{header|Perl}}==
<langsyntaxhighlight Perllang="perl">my @table = map [ /([\d\.]+)/g ], split "\n", <<'TBL';
>= 0.00 < 0.06 := 0.10
>= 0.06 < 0.11 := 0.18
Line 2,468 ⟶ 3,835:
printf "%.3f -> %g\n", $m, convert($m);
}
</syntaxhighlight>
</lang>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>constant TBL=split("""
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
>= 0.00 < 0.06 := 0.10
<span style="color: #008080;">constant</span> <span style="color: #000000;">TBL</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"""
>= 0.06 < 0.11 := 0.18
> &gt;= 0.1100 <&lt; 0.1606 := 0.2610
> &gt;= 0.1606 <&lt; 0.2111 := 0.3218
> &gt;= 0.2111 <&lt; 0.2616 := 0.3826
> &gt;= 0.2616 <&lt; 0.3121 := 0.4432
> &gt;= 0.3121 <&lt; 0.3626 := 0.5038
> &gt;= 0.3626 <&lt; 0.4131 := 0.5444
> &gt;= 0.4131 <&lt; 0.4636 := 0.5850
> &gt;= 0.4636 <&lt; 0.5141 := 0.6254
> &gt;= 0.5141 <&lt; 0.5646 := 0.6658
> &gt;= 0.5646 <&lt; 0.6151 := 0.7062
> &gt;= 0.6151 <&lt; 0.6656 := 0.7466
> &gt;= 0.6656 <&lt; 0.7161 := 0.7870
> &gt;= 0.7161 <&lt; 0.7666 := 0.8274
> &gt;= 0.7666 <&lt; 0.8171 := 0.8678
> &gt;= 0.8171 <&lt; 0.8676 := 0.9082
> &gt;= 0.8676 <&lt; 0.9181 := 0.9486
> &gt;= 0.9181 <&lt; 0.9686 := 0.9890
> &gt;= 0.9686 <&lt; 10.0191 := 10.00""",'\n')94
&gt;= 0.91 &lt; 0.96 := 0.98
&gt;= 0.96 &lt; 1.01 := 1.00"""</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\n'</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">limits</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">},</span>
<span style="color: #000000;">prices</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">pl</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">plt</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">price</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">TBL</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">pl</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">price</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">TBL</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"&gt;= %.2f &lt; %.2f := %.2f"</span><span style="color: #0000FF;">)[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
<span style="color: #7060A8;">assert</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pl</span><span style="color: #0000FF;">==</span><span style="color: #000000;">plt</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">plt</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">lt</span>
<span style="color: #000000;">limits</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">limits</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lt</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">prices</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">prices</span><span style="color: #0000FF;">,</span><span style="color: #000000;">price</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">price_fix</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">limits</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">p</span><span style="color: #0000FF;"><</span><span style="color: #000000;">limits</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">prices</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">101</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"%5.2f %5.2f\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">/</span><span style="color: #000000;">100</span><span style="color: #0000FF;">,</span><span style="color: #000000;">price_fix</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">/</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
 
=={{header|Phixmonti}}==
sequence limits = {0},
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt
prices = {-1}
atom lt,price
for i=1 to length(TBL) do
{{?,lt,price}} = scanf(TBL[i],">= %.2f < %.2f := %.2f")
limits = append(limits,lt)
prices = append(prices,price)
end for
 
(
function price_fix(atom p)
( 0.00 0.06 0.10 )
for i=1 to length(limits) do
( 0.06 0.11 0.18 )
if p<limits[i] then
( 0.11 0.16 0.26 )
return prices[i]
( 0.16 0.21 0.32 )
end if
( 0.21 0.26 0.38 )
end for
( 0.26 0.31 0.44 )
return -1
( 0.31 0.36 0.50 )
end function
( 0.36 0.41 0.54 )
( 0.41 0.46 0.58 )
for i=-1 to 101 do
( 0.46 0.51 0.62 )
printf(1, "%5.2f %5.2f\n", {i/100,price_fix(i/100)})
( 0.51 0.56 0.66 )
end for</lang>
( 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 ) )
 
def price_fix
var p
len for
get
3 get swap 1 get swap 2 get nip
p swap < swap p swap >=
and if
exitfor
else
drop
endif
endfor
enddef
 
( 0.00 1.01 0.01 ) for
dup print 9 tochar print price_fix print nl
endfor
</syntaxhighlight>
 
=={{header|Picat}}==
===Approach 1===
<syntaxhighlight lang="picat">go =>
_ = random2(),
D = [
[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]],
 
Len = D.length,
foreach(_ in 1..10)
R = frand2(100),
between(1,Len,Ix),
R >= D[Ix,1],
R < D[Ix,2],
New = D[Ix,3],
println(R=New)
end,
nl.
 
% Getting numbers of precision 2
frand2(N) = (random() mod N)/N.</syntaxhighlight>
 
{{out}}
<pre>0.2 = 0.32
0.91 = 0.98
0.44 = 0.58
0.81 = 0.9
0.74 = 0.82
0.1 = 0.18
0.42 = 0.58
0.93 = 0.98
0.14 = 0.26
0.62 = 0.74</pre>
 
===Using a fact table===
<syntaxhighlight lang="picat">go2 =>
_ = random2(),
foreach(_ in 1..10)
R = frand2(100),
r(From,To,Val),
R >= From,
R <= To,
println(R=Val)
end,
 
nl.
 
r(0.00,0.06,0.10).
r(0.06,0.11,0.18).
r(0.11,0.16,0.26).
r(0.16,0.21,0.32).
r(0.21,0.26,0.38).
r(0.26,0.31,0.44).
r(0.31,0.36,0.50).
r(0.36,0.41,0.54).
r(0.41,0.46,0.58).
r(0.46,0.51,0.62).
r(0.51,0.56,0.66).
r(0.56,0.61,0.70).
r(0.61,0.66,0.74).
r(0.66,0.71,0.78).
r(0.71,0.76,0.82).
r(0.76,0.81,0.86).
r(0.81,0.86,0.90).
r(0.86,0.91,0.94).
r(0.91,0.96,0.98).
r(0.96,1.01,1.00).</syntaxhighlight>
 
{{out}}
<pre>0.83 = 0.9
0.77 = 0.86
0.65 = 0.74
0.08 = 0.18
0.08 = 0.18
0.02 = 0.1
0.73 = 0.82
0.99 = 1.0
0.58 = 0.7
0.0 = 0.1</pre>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(scl 2)
 
(de price (Pr)
Line 2,546 ⟶ 4,060:
 
(for N (0.3793 0.4425 0.0746 0.6918 0.2993 0.5486 0.7848 0.9383 0.2292)
(prinl (price N)) )</langsyntaxhighlight>
{{out}}
<pre>0.54
Line 2,560 ⟶ 4,074:
=={{header|PL/I}}==
===version 1===
<langsyntaxhighlight PLlang="pl/Ii">declare t(20) fixed decimal (3,2) static initial (
.06, .11, .16, .21, .26, .31, .36, .41, .46, .51,
.56, .61, .66, .71, .76, .81, .86, .91, .96, 1.01);
Line 2,573 ⟶ 4,087:
if x < t(i) then
do; d = r(i); leave loop; end;
end;</langsyntaxhighlight>
 
===version 2===
{{trans|REXX version2}}
<langsyntaxhighlight PLlang="pl/Ii">cpt: Proc Options(main);
Dcl x Dec Fixed(4,2);
Do x=0 To 1 By 0.01;
Line 2,591 ⟶ 4,105:
Return(r(i));
End;
End;</langsyntaxhighlight>
 
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
<lang PowerShell>
function Convert-PriceFraction
{
Line 2,640 ⟶ 4,154:
}
}
</syntaxhighlight>
</lang>
<syntaxhighlight lang="powershell">
<lang PowerShell>
.7388727, .8593103, .826687, .3444635, .0491907 | Convert-PriceFraction | ForEach-Object {"{0:C}" -f $_}
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 2,652 ⟶ 4,166:
$0.10
</pre>
 
=={{header|PureBasic}}==
<lang PureBasic>Procedure.f PriceFraction(price.f)
;returns price unchanged if value is invalid
Protected fraction
Select price * 100
Case 0 To 5
fraction = 10
Case 06 To 10
fraction = 18
Case 11 To 15
fraction = 26
Case 16 To 20
fraction = 32
Case 21 To 25
fraction = 38
Case 26 To 30
fraction = 44
Case 31 To 35
fraction = 5
Case 36 To 40
fraction = 54
Case 41 To 45
fraction = 58
Case 46 To 50
fraction = 62
Case 51 To 55
fraction = 66
Case 56 To 60
fraction = 7
Case 61 To 65
fraction = 74
Case 66 To 70
fraction = 78
Case 71 To 75
fraction = 82
Case 76 To 80
fraction = 86
Case 81 To 85
fraction = 9
Case 86 To 90
fraction = 94
Case 91 To 95
fraction = 98
Case 96 To 100
fraction = 100
Default
ProcedureReturn price
EndSelect
ProcedureReturn fraction / 100
EndProcedure
 
If OpenConsole()
Define x.f, i
For i = 1 To 10
x = Random(10000)/10000
PrintN(StrF(x, 4) + " -> " + StrF(PriceFraction(x), 2))
Next
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf</lang>
{{out}}
<pre>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
0.9560 -> 1.00</pre>
 
=={{header|Python}}==
Using the [http://docs.python.org/library/bisect.html bisect] standard module to reduce the comparisons with members of the cin array.
 
<langsyntaxhighlight lang="python">>>> import bisect
>>> _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]
>>> def pricerounder(pricein):
return _cout[ bisect.bisect_right(_cin, pricein) ]</langsyntaxhighlight>
 
When dealing with money it is good to think about possible loss of precision. If we change the units to be integer cents we could use the following exact routine:
<langsyntaxhighlight lang="python">>>> import bisect
>>> _cin = [ 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96, 101]
>>> _cout = [10, 18, 26, 32, 38, 44, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 100]
>>> def centsrounder(centsin):
return _cout[ bisect.bisect_right(_cin, centsin) ]</langsyntaxhighlight>
Other options are to use the fractions or decimals modules for calculating money to a known precision.
 
<br>'''Bisection library code'''<br>
:The <code>bisect</code> Python standard library function uses the following code that improves on a simple linear scan through a sorted list:
:<langsyntaxhighlight lang="python">def bisect_right(a, x, lo=0, hi=None):
"""Return the index where to insert item x in list a, assuming a is sorted.
 
Line 2,767 ⟶ 4,205:
if x < a[mid]: hi = mid
else: lo = mid+1
return lo</langsyntaxhighlight>
 
=={{header|Quackery}}==
This program uses the bignum rationals provided by <code>bigrat.qky</code>, so it avoids the pitfalls of storing money as floating point numbers.
<syntaxhighlight lang="quackery">[ $ 'bigrat.qky' loadfile ] now!
 
[ 2over 2over v< if 2swap 2drop ] is vmax ( n/d n/d --> n/d )
 
[ 100 1 v* 1 1 v-
0 1 vmax 5 1 v/ /
[ table
10 18 26 32 38
44 50 54 58 62
66 70 74 78 82
86 90 94 98 100 ] 100 ] is scale ( n/d --> n/d )
 
[ swap echo sp echo ] is br ( n/d --> )
 
[ 2dup br say ' --> '
scale br cr ] is test ( n/d --> )
 
0 100 test
50 100 test
65 100 test
66 100 test
100 100 test
7368 10000 test
 
( Show how to enter and display results as a decimal too. )
$ '0.7368' dup echo$
say ' --> '
$->v drop scale
2 point$ echo$</syntaxhighlight>
{{out}}
<pre>
0 100 --> 10 100
50 100 --> 62 100
65 100 --> 74 100
66 100 --> 78 100
100 100 --> 100 100
7368 10000 --> 82 100
0.7368 --> 0.82
</pre>
 
=={{header|R}}==
<syntaxhighlight lang="r">
<lang r>
price_fraction <- function(x)
{
Line 2,782 ⟶ 4,262:
#Example usage:
price_fraction(c(0, .01, 0.06, 0.25, 1)) # 0.10 0.10 0.18 0.38 1.00
</syntaxhighlight>
</lang>
 
You can extract the contents of the table as follows:
 
<syntaxhighlight lang="r">
<lang r>
dfr <- read.table(tc <- textConnection(
">= 0.00 < 0.06 := 0.10
Line 2,810 ⟶ 4,290:
breaks <- dfr$V4
values <- dfr$V6
</syntaxhighlight>
</lang>
 
=={{header|Racket}}==
 
<syntaxhighlight lang="racket">
<lang Racket>
#lang racket
 
Line 2,826 ⟶ 4,306:
;; returns #f for negatives or values >= 1.01
(define (convert x) (for/or ([c table]) (and (< x (car c)) (cadr c))))
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
Line 2,832 ⟶ 4,312:
 
Simple solution, doing a linear search.<br>
Note that in Perl&nbsp;6Raku we don't have to worry about floating-point misrepresentations of decimals, because decimal fractions are stored as rationals.
 
{{works with|rakudo|2016.07}}
<syntaxhighlight lang="raku" perl6line>sub price-fraction ($n where 0..1) {
when $n < 0.06 { 0.10 }
when $n < 0.11 { 0.18 }
Line 2,860 ⟶ 4,340:
while prompt("value: ") -> $value {
say price-fraction(+$value);
}</langsyntaxhighlight>
 
If we expect to rescale many prices, a better approach would be to build a look-up array of 101 entries.
Memory is cheap, and array indexing is blazing fast.
 
<syntaxhighlight lang="raku" perl6line>my @price = map *.value, flat
( 0 ..^ 6 X=> 0.10),
( 6 ..^ 11 X=> 0.18),
Line 2,890 ⟶ 4,370:
while prompt("value: ") -> $value {
say @price[$value * 100] // "Out of range";
}</langsyntaxhighlight>
 
We can also build this same look-up array by parsing the table as formatted in the task description:
 
{{works with|rakudo|2016.07}}
<syntaxhighlight lang="raku" perl6line>my $table = q:to/END/;
>= 0.00 < 0.06 := 0.10
>= 0.06 < 0.11 := 0.18
Line 2,927 ⟶ 4,407:
while prompt("value: ") -> $value {
say @price[$value * 100] // "Out of range";
}</langsyntaxhighlight>
 
=={{header|Raven}}==
{{trans|JavaScript}}
<langsyntaxhighlight Ravenlang="raven">define getScaleFactor use $v
[ 0.1 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 ] as $vals
$v 100 * 1 - 5 / 20 min 0 max 1 prefer dup $v "val: %g indx: %d\n" print $vals swap get
 
0 100 9 range each
100.0 / dup getScaleFactor swap "%.2g -> %.2g\n" print</langsyntaxhighlight>
{{out}}
<pre>0 -> 0.1
Line 2,954 ⟶ 4,434:
=={{header|REXX}}==
===version 1===
<langsyntaxhighlight lang="rexx">/*REXX program to rescalere─scales a (decimal fraction) price (in the range of: 0.99¢ ──► $1.00). */
pad= ' ' /*for inserting spaces into msga message. */
do j=0 to 1 by .01; if j==0 then j=0.00 /*specialprocess the prices from 0¢ to ≤ $1 case.*/
if j==0 then j= 0.00 /*handle the special case of zero cents*/
say pad 'original price ──►' j pad adjPrice(j) " ◄── adjusted price"
say pad 'original price ──►' j pad adjPrice(j) " ◄── adjusted price"
end /*j*/
exit end /*stick a fork in it, we're done.j*/
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────ADJPRICE subroutine─────────────────*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
adjPrice: procedure; parse arg ?
adjPrice: procedure; parse arg ? /*a table is used to facilitate changes*/
select
when ?<0.06 then ?=0.10 select
when ?<0.1106 then ?= 0.1810
when ?<0.1611 then ?= 0.2618
when ?<0.2116 then ?= 0.3226
when ?<0.2621 then ?= 0.3832
when ?<0.3126 then ?= 0.4438
when ?<0.3631 then ?= 0.5044
when ?<0.4136 then ?= 0.5450
when ?<0.4641 then ?= 0.5854
when ?<0.5146 then ?= 0.6258
when ?<0.5651 then ?= 0.6662
when ?<0.6156 then ?= 0.7066
when ?<0.6661 then ?= 0.7470
when ?<0.7166 then ?= 0.7874
when ?<0.7671 then ?= 0.8278
when ?<0.8176 then ?= 0.8682
when ?<0.8681 then ?= 0.9086
when ?<0.9186 then ?= 0.9490
when ?<0.9691 then ?= 0.9894
when ?<10.0196 then ?=1 0.0098
otherwise nop when ?<1.01 then ?= 1.00
end /*select*/ otherwise nop
end /*select*/
return ?</lang>
return ?</syntaxhighlight>
{{out}}
{{out|output|text=:}}
<pre style="height:30ex">
<pre style="height:66ex">
original price ──► 0.00 0.10 ◄── adjusted price
original price ──► 0.01 0.10 ◄── adjusted price
Line 3,092 ⟶ 4,573:
 
===version 2===
<langsyntaxhighlight lang="rexx">/* REXX ***************************************************************
* Inspired by some other solutions tested with version 1 (above)
* 20.04.2013 Walter Pachl
Line 3,113 ⟶ 4,594:
adjprice2: Procedure Expose r.
i=((100*arg(1)-1)%5+1)
Return r.i</langsyntaxhighlight>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
see pricefraction(0.5)
Line 3,141 ⟶ 4,622:
return 1
</syntaxhighlight>
</lang>
 
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪ → input
≪ { 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.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 }
1 '''WHILE''' GETI input < '''REPEAT END'''
'''IF''' DUP 1 == '''THEN''' DROP DUP SIZE '''ELSE''' 1 - '''END'''
SWAP DROP GET 2 FIX
≫ ≫ ''''PRICE'''' STO
|
'''PRICE''' ''( gross -- net ) ''
list of net values
.
.
list of thresholds
.
.
scan thresholds until passed
1 step down
forget thresholds and get net value with 2 decimals
.
|}
 
{{in}}
<pre>
0 PRICE
0.25 PRICE
0.5 PRICE
0.75 PRICE
1 PRICE
</pre>
 
{{out}}
<pre>
5: 0.10
4: 0.38
3: 0.62
2: 0.82
1: 1.00
</pre>
 
=={{header|Ruby}}==
A simple function with hardcoded values.
<langsyntaxhighlight lang="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
Line 3,168 ⟶ 4,699:
elsif value < 1.01 then 1.00
end
end</langsyntaxhighlight>
 
Or, where we can cut and paste the textual table in one place
Line 3,175 ⟶ 4,706:
For Ruby 1.8.6, use <code>String#each_line</code>
 
<langsyntaxhighlight lang="ruby">class Price
ConversionTable = <<-END_OF_TABLE
>= 0.00 < 0.06 := 0.10
Line 3,222 ⟶ 4,753:
end
attr_reader :standard_value
end</langsyntaxhighlight>
 
And a test suite
<langsyntaxhighlight lang="ruby">require 'test/unit'
 
class PriceFractionTests < Test::Unit::TestCase
Line 3,251 ⟶ 4,782:
end
end
end</langsyntaxhighlight>
 
{{out}}
Line 3,260 ⟶ 4,791:
 
1 tests, 22 assertions, 0 failures, 0 errors, 0 skips</pre>
Another option is using a built-in binary search:
<syntaxhighlight lang="ruby">
keys = [ 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]
prices = [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]
 
tests = [0.3793, 0.4425, 0.0746, 0.6918, 0.2993, 0.5486, 0.7849, 0.9383, 0.2292]
=={{header|Run BASIC}}==
tests.each do |test|
<lang runbasic>data .06, .1,.11,.18,.16,.26,.21,.32,.26,.38,.31,.44,.36,.50,.41,.54,.46,.58,.51,.62
price = prices[ keys.bsearch_index{|key| key >= test } ]
data .56,.66,.61,.70,.66,.74,.71,.78,.76,.82,.81,.86,.86,.90,.91,.94,.96,.98
puts [test, price].join(": ")
 
end
dim od(100)
</syntaxhighlight>
dim nd(100)
for i = 1 to 19
read oldDec
read newDec
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]</lang>
<pre>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</pre>
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">fn fix_price(num: f64) -> f64 {
match num {
0.96...1.00 => 1.00,
Line 3,337 ⟶ 4,851:
input_price += 0.01;
}
}</langsyntaxhighlight>
 
{{out}}
Line 3,370 ⟶ 4,884:
 
=={{header|Scala}}==
<langsyntaxhighlight lang="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
Line 3,379 ⟶ 4,893:
 
def testPriceFraction()=
for(n <- 0.00 to (1.00, 0.01)) println("%.2f %.2f".format(n, priceFraction(n)))</langsyntaxhighlight>
{{out}}
<pre>
Line 3,420 ⟶ 4,934:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "float.s7i";
 
Line 3,447 ⟶ 4,961:
writeln(flt(i) / 100.0 digits 2 <& " " <& computePrice(flt(i) / 100.0) digits 2);
end for;
end func;</langsyntaxhighlight>
 
The following variant of ''computePrice'' works with a table and raises RANGE_ERROR when x < 0.0 or x >= 1.01 holds:
<langsyntaxhighlight lang="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),
Line 3,470 ⟶ 4,984:
raise RANGE_ERROR;
end if;
end func;</langsyntaxhighlight>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="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
Line 3,507 ⟶ 5,021:
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);
}</langsyntaxhighlight>
{{out}}
<pre>
Line 3,523 ⟶ 5,037:
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<langsyntaxhighlight lang="smalltalk">"Table driven rescale"
Object subclass: PriceRescale [
|table|
Line 3,571 ⟶ 5,085:
 
"get a price"
(pr rescale: ( (Random between: 0 and: 100)/100 )) displayNl.</langsyntaxhighlight>
 
=={{header|Swift}}==
 
<langsyntaxhighlight lang="swift">let ranges = [
(0.00..<0.06, 0.10),
(0.06..<0.11, 0.18),
Line 3,606 ⟶ 5,120:
 
print("\(strFmt(val)) -> \(strFmt(adjustDouble(val, accordingTo: ranges) ?? val))")
}</langsyntaxhighlight>
 
{{out}}
Line 3,714 ⟶ 5,228:
=={{header|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.
<langsyntaxhighlight lang="tcl"># Used once to turn the table into a "nice" form
proc parseTable table {
set map {}
Line 3,736 ⟶ 5,250:
# Failed to map; return the input
return $value
}</langsyntaxhighlight>
How it is used:
<langsyntaxhighlight lang="tcl"># Make the mapping
set inputTable {
>= 0.00 < 0.06 := 0.10
Line 3,766 ⟶ 5,280:
foreach example {.7388727 .8593103 .826687 .3444635 .0491907} {
puts "$example -> [priceFraction $map $example]"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 3,777 ⟶ 5,291:
 
=={{header|Ursala}}==
<langsyntaxhighlight Ursalalang="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)</langsyntaxhighlight>
main points:
* <code>~&p(le,out)</code> zips the pair of lists <code>le</code> and <code>out</code> into a list of pairs
Line 3,791 ⟶ 5,305:
 
test program:
<langsyntaxhighlight Ursalalang="ursala">#cast %eL
 
test = price_fraction* <0.34,0.070145,0.06,0.05,0.50214,0.56,1.,0.99,0.>
</syntaxhighlight>
</lang>
{{out}}
<pre><
Line 3,806 ⟶ 5,320:
1.000000e+00,
1.000000e-01></pre>
 
=={{header|VBA}}==
<lang 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</lang>
{{Out}}
<pre>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</pre>
 
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
<lang vb>
Function pf(p)
If p < 0.06 Then
Line 3,889 ⟶ 5,371:
WScript.Echo pf(0.826687)
WScript.Echo pf(0.3444635)
</syntaxhighlight>
</lang>
 
{{Out}}
Line 3,897 ⟶ 5,379:
0.9
0.5
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./fmt" for Fmt
 
var rescale = Fn.new { |v|
return (v < 0.06) ? 0.10 :
(v < 0.11) ? 0.18 :
(v < 0.16) ? 0.26 :
(v < 0.21) ? 0.32 :
(v < 0.26) ? 0.38 :
(v < 0.31) ? 0.44 :
(v < 0.36) ? 0.50 :
(v < 0.41) ? 0.54 :
(v < 0.46) ? 0.58 :
(v < 0.51) ? 0.62 :
(v < 0.56) ? 0.66 :
(v < 0.61) ? 0.70 :
(v < 0.66) ? 0.74 :
(v < 0.71) ? 0.78 :
(v < 0.76) ? 0.82 :
(v < 0.81) ? 0.86 :
(v < 0.86) ? 0.90 :
(v < 0.91) ? 0.94 :
(v < 0.96) ? 0.98 : 1.00
}
 
var tests = [0.49, 0.79, 1.00, 0.83, 0.99, 0.23, 0.12, 0.28, 0.72, 0.37, 0.95, 0.51, 0.43, 0.52, 0.84, 0.89, 0.48, 0.48, 0.30, 0.01]
for (test in tests) {
Fmt.print("$4.2f -> $4.2f", test, rescale.call(test))
}</syntaxhighlight>
 
{{out}}
<pre>
0.49 -> 0.62
0.79 -> 0.86
1.00 -> 1.00
0.83 -> 0.90
0.99 -> 1.00
0.23 -> 0.38
0.12 -> 0.26
0.28 -> 0.44
0.72 -> 0.82
0.37 -> 0.54
0.95 -> 0.98
0.51 -> 0.66
0.43 -> 0.58
0.52 -> 0.66
0.84 -> 0.90
0.89 -> 0.94
0.48 -> 0.62
0.48 -> 0.62
0.30 -> 0.44
0.01 -> 0.10
</pre>
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations
 
func real Price(V); \Convert to standard value
Line 3,932 ⟶ 5,469:
RlOut(0, Price(0.10)); CrLf(0);
RlOut(0, Price(1.0)); CrLf(0);
]</langsyntaxhighlight>
 
{{out}}
Line 3,942 ⟶ 5,479:
 
=={{header|zkl}}==
<langsyntaxhighlight lang="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),
Line 3,952 ⟶ 5,489:
T(0.96, 0.98), T(1.01, 1.00), );
vert.filter1('wrap([(a,_)]){ price<a })[1]
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">fcn convert2(price){ // shifting the fractional part to the integer portion
var vert=T(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);
vert[(price*100-1)/005];
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">T(0.7388727, 0.8593103, 0.826687, 0.3444635, 0.0491907).apply(convert) .println();
T(0.7388727, 0.8593103, 0.826687, 0.3444635, 0.0491907).apply(convert2).println();</langsyntaxhighlight>
{{out}}
<pre>
Langurmonkey
885

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/143371...364150"