Rosetta Code

Price fraction: Difference between revisions

Page Discussion

Price fraction (view source)

Revision as of 13:55, 14 April 2024

16,035 bytes added ,  1 month ago
→‎{{header|langur}}
m (→‎{{header|Phix}}: syntax coloured)
(18 intermediate revisions by 12 users not shown)
Line 32:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F bisect_right(a, x)
V lo = 0
V hi = a.len
Line 49:
 
L(i) 0..10
print(‘#.2 #.2’.format(i / 10, pricerounder(i / 10)))</langsyntaxhighlight>
 
{{out}}
Line 67:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="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]
Line 103:
FI
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Price_fraction.png Screenshot from Atari 8-bit computer]
Line 131:
 
=={{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 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 177:
end loop;
end Test_Price_Fraction;
</syntaxhighlight>
</lang>
{{out}}
<div style="height: 200px;overflow:scroll">
Line 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 321:
 
printf(($"Value : "z.2dl,"Converted to standard : "z.2dl$, price, std val))
)</langsyntaxhighlight>
{{out}}
<pre>
Line 332:
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:
 
<langsyntaxhighlight lang="applescript">-- This handler just returns the standardised real value. It's up to external processes to format it for display.
 
on standardisePrice(input)
Line 366:
set output to linefeed & "Originals: " & originals & linefeed & "Standardised: " & standardised
set AppleScript's text item delimiters to astid
return output</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight 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"</langsyntaxhighlight>
 
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.
 
<langsyntaxhighlight 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)
Line 403:
set output to linefeed & "Originals: " & originals & linefeed & "Standardised: " & standardised
set AppleScript's text item delimiters to astid
return output</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight 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"</langsyntaxhighlight>
 
===Functional===
<langsyntaxhighlight lang="applescript">---------------------- PRICE FRACTION ----------------------
 
property table : [¬
Line 809:
end tell
end if
end zipWith</langsyntaxhighlight>
{{Out}}
<pre>Price adjustments:
Line 839:
=={{header|Arturo}}==
 
<langsyntaxhighlight 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
Line 857:
loop tests 'test [
print [test "=>" getPricePoint test]
]</langsyntaxhighlight>
 
{{out}}
Line 872:
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">; Submitted by MasterFocus --- http://tiny.cc/iTunis
 
Loop
Line 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 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 993 ⟶ 991:
PriceFraction! = price
END SELECT
END FUNCTION</langsyntaxhighlight>
 
{{out}} (run 5 times):
Line 1,002 ⟶ 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 1,028 ⟶ 1,066:
520 next i
530 np=1:return
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,056 ⟶ 1,094:
ready.</pre>
 
==={{header|BASIC256FreeBASIC}}===
<syntaxhighlight lang="freebasic">' FB 1.050.0 Win64
{{trans|Gambas}}
<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}
 
Function rescale(price As Double) As Double
for byCount = 1 to 100
If price < 0.00 OrElse price > 1.00 Then Return price
for byCheck = 0 to byLimit[?]
Select Case price
if byCount < byLimit[byCheck] then exit for
Case Is < 0.06 : Return 0.10
next byCheck
Case Is < 0.11 : Return 0.18
print ljust((byCount/100),4," "); " -> "; ljust((byValue[byCheck]/100),4," "); chr(9);
ifCase byCountIs mod 5 =< 0.16 then: printReturn 0.26
Case Is < 0.21 : Return 0.32
next byCount
Case Is < 0.26 : Return 0.38
end</lang>
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
=={{header|BBC BASIC}}==
Dim d As Double = i/100.0
<lang bbcbasic> PRINT FNpricefraction(0.5)
Print Using "#.##"; d;
END
Print " -> ";
Print Using "#.##"; rescale(d);
DEF FNpricefraction(p)
Print " ";
IF p < 0.06 THEN = 0.10
If i Mod 5 IF p <= 0.11 THENThen = 0.18Print
Next
IF p < 0.16 THEN = 0.26
 
IF p < 0.21 THEN = 0.32
Print
IF p < 0.26 THEN = 0.38
Print "Press any key to quit"
IF p < 0.31 THEN = 0.44
Sleep</syntaxhighlight>
IF p < 0.36 THEN = 0.50
 
IF p < 0.41 THEN = 0.54
{{out}}
IF p < 0.46 THEN = 0.58
<pre>
IF p < 0.51 THEN = 0.62
0.01 -> 0.10 0.02 -> IF0.10 p <0.03 -> 0.5610 THEN =0.04 -> 0.10 0.05 -> 0.6610
0.06 -> 0.18 0.07 -> IF0.18 p <0.08 -> 0.6118 THEN =0.09 -> 0.18 0.10 -> 0.7018
0.11 -> 0.26 0.12 -> IF0.26 p <0.13 -> 0.6626 THEN =0.14 -> 0.26 0.15 -> 0.7426
0.16 -> 0.32 0.17 -> IF0.32 p <0.18 -> 0.7132 THEN =0.19 -> 0.32 0.20 -> 0.7832
0.21 -> 0.38 0.22 -> IF0.38 p <0.23 -> 0.7638 THEN =0.24 -> 0.38 0.25 -> 0.8238
0.26 -> 0.44 0.27 -> IF0.44 p <0.28 -> 0.8144 THEN =0.29 -> 0.44 0.30 -> 0.8644
0.31 -> 0.50 0.32 -> IF0.50 p <0.33 -> 0.8650 THEN =0.34 -> 0.50 0.35 -> 0.9050
0.36 -> 0.54 0.37 -> IF0.54 p <0.38 -> 0.9154 THEN =0.39 -> 0.54 0.40 -> 0.9454
0.41 -> 0.58 0.42 -> IF0.58 p <0.43 -> 0.9658 THEN =0.44 -> 0.58 0.45 -> 0.9858
0.46 -> 0.62 0.47 -> 0.62 0.48 -> 0.62 0.49 -> 0.62 0.50 -> 0.62
= 1.00</lang>
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}}==
<langsyntaxhighlight Beadslang="beads">beads 1 program 'Price fraction'
 
record a_table
Line 1,134 ⟶ 1,537:
if v < table[ix].value
log "{v} => {table[ix].rescaled}"
exit</langsyntaxhighlight>
{{out}}
<pre>0.05 => 0.1
Line 1,144 ⟶ 1,547:
 
=={{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 1,181 ⟶ 1,584:
& out$(!a "-->" convert$!a)
)
)</langsyntaxhighlight>
{{out}}
<pre>0.00 --> 0.10
Line 1,222 ⟶ 1,625:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include<stdio.h>
 
double table[][2] = {
Line 1,249 ⟶ 1,652:
 
return 0;
}</langsyntaxhighlight>
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">namespace ConsoleApplication1
{
class Program
Line 1,304 ⟶ 1,707:
}
}
}</langsyntaxhighlight>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <cmath>
 
Line 1,337 ⟶ 1,740:
return 0 ;
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,355 ⟶ 1,758:
 
=={{header|Clipper}}==
<langsyntaxhighlight lang="dbase">FUNCTION PriceFraction( npQuantDispensed )
LOCAL aPriceFraction := { {0,.06,.1},;
{.06,.11,.18}, ;
Line 1,387 ⟶ 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 1,393 ⟶ 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 1,436 ⟶ 1,839:
nResult := NIL
Endif
Return nResult</langsyntaxhighlight>
 
{{out}}
Line 1,477 ⟶ 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 1,513 ⟶ 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 1,535 ⟶ 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 1,556 ⟶ 1,959:
foreach (const price; [0.7388727, 0.8593103, 0.826687, 0.3444635])
price.priceRounder.writeln;
}</langsyntaxhighlight>
{{out}}
<pre>0.82
Line 1,562 ⟶ 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 1,599 ⟶ 2,210:
 
end
</syntaxhighlight>
</lang>
<syntaxhighlight lang="eiffel">
<lang Eiffel>
class
PRICE_FRACTION
Line 1,642 ⟶ 2,253:
 
end
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,665 ⟶ 2,276:
Given: 0.95 Adjusted:0.98
</pre>
 
 
=={{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 1,683 ⟶ 2,293:
Enum.each(val, fn x ->
:io.format "~5.2f ->~5.2f~n", [x, Price.fraction(x)]
end)</langsyntaxhighlight>
 
{{out}}
Line 1,709 ⟶ 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,730 ⟶ 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,753 ⟶ 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,773 ⟶ 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,802 ⟶ 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,810 ⟶ 2,420:
=={{header|Fantom}}==
 
<langsyntaxhighlight lang="fantom">
class Defn // to hold the three numbers from a 'row' in the table
{
Line 1,880 ⟶ 2,490:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Forth}}==
Line 1,886 ⟶ 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,897 ⟶ 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 / ;
Line 1,908 ⟶ 2,518:
: test cr 101 0 ?do i print i 2 spaces normalize print cr 5 +loop ;
 
test</langsyntaxhighlight>
Output:
<pre>
Line 1,936 ⟶ 2,546:
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<langsyntaxhighlight lang="fortran">program price_fraction
 
implicit none
Line 1,954 ⟶ 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,965 ⟶ 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 2,129 ⟶ 2,702:
fmt.Printf("%0.4f -> %0.2f\n", v, pf(v))
}
}</langsyntaxhighlight>
 
<pre>
Line 2,145 ⟶ 2,718:
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">def priceFraction(value) {
assert value >= 0.0 && value <= 1.0
 
Line 2,161 ⟶ 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 2,268 ⟶ 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 2,289 ⟶ 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 2,300 ⟶ 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 2,312 ⟶ 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 2,326 ⟶ 2,899:
=={{header|Icon}} and {{header|Unicon}}==
 
<syntaxhighlight lang="icon">
<lang Icon>
record Bounds(low,high,new)
 
Line 2,366 ⟶ 2,939:
}
end
</syntaxhighlight>
</lang>
 
{{out}}
Line 2,386 ⟶ 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 2,422 ⟶ 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 2,440 ⟶ 3,013:
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.util.Random;
 
public class Main {
Line 2,474 ⟶ 3,047:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>0.149969 -> 0.26
Line 2,493 ⟶ 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 2,500 ⟶ 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 2,534 ⟶ 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 2,550 ⟶ 3,123:
println(@sprintf " %.4f -> %.4f" t pricefraction(t))
end
</syntaxhighlight>
</lang>
 
{{out}}
Line 2,588 ⟶ 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 2,601 ⟶ 3,174:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.0.6
 
fun rescale(price: Double): Double =
Line 2,634 ⟶ 3,207:
if (i % 5 == 0) println()
}
}</langsyntaxhighlight>
 
{{out}}
Line 2,663 ⟶ 3,236:
Langur uses decimal floating point.
 
<langsyntaxhighlight lang="langur">#val using.pricefrac an= impliedfn(.f) parameterswitch[and] .f ...{
val .pricefrac = f given .f {
case >= 0.00, < 0.06: 0.10
case >= 0.06, < 0.11: 0.18
Line 2,686 ⟶ 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,748 ⟶ 3,289:
print("Adjusted price:", rescale(rnd))
print()
end</langsyntaxhighlight>
{{out}}
<pre>Random value: 0.61946413522022
Line 2,764 ⟶ 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,783 ⟶ 3,404:
for i to 5 do
priceFraction (rand(0.0..1.0)());
end do;</langsyntaxhighlight>
{{out}}
<pre>0.524386 --> 0.66
Line 2,792 ⟶ 3,413:
 
=={{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,812 ⟶ 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,858 ⟶ 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,875 ⟶ 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,889 ⟶ 3,511:
 
=={{header|NetRexx}}==
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols nobinary
 
Line 2,946 ⟶ 3,568:
end tv
return test_vals
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,958 ⟶ 3,580:
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">import random, strformat
 
# Representation of a standard value as an int (actual value * 100).
Line 2,990 ⟶ 3,612:
for _ in 0 .. 10:
let price = rand(1.01)
echo &"Price for {price:.2f} is {price.toStandardValue()}"</langsyntaxhighlight>
{{out}}
A random output looking something like this:
Line 3,007 ⟶ 3,629:
=={{header|Objeck}}==
{{trans|C#}}
<langsyntaxhighlight lang="objeck">class PriceFraction {
function : Main(args : String[]) ~ Nil {
for(i := 0; i < 5; i++;) {
Line 3,041 ⟶ 3,663:
return inValue;
}
}</langsyntaxhighlight>
 
{{output}}
Line 3,054 ⟶ 3,676:
=={{header|OCaml}}==
 
<langsyntaxhighlight lang="ocaml">let price_fraction v =
if v < 0.0 || v >= 1.01 then
invalid_arg "price_fraction";
Line 3,068 ⟶ 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 3,087 ⟶ 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 3,097 ⟶ 3,719:
| i |
IN size loop: i [ f IN at(i) < ifTrue: [ OUT at(i) return ] ]
null ;</langsyntaxhighlight>
 
{{Out}}
Line 3,110 ⟶ 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 3,124 ⟶ 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 3,135 ⟶ 3,757:
);
"nasal demons"
};</langsyntaxhighlight>
 
=={{header|Pascal}}==
<langsyntaxhighlight lang="pascal">Program PriceFraction(output);
 
const
Line 3,162 ⟶ 3,784:
writeln (cost:6:4, ' -> ', price[j+1]:4:2);
end;
end.</langsyntaxhighlight>
{{out}}
<pre>% ./PriceFraction
Line 3,177 ⟶ 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 3,213 ⟶ 3,835:
printf "%.3f -> %g\n", $m, convert($m);
}
</syntaxhighlight>
</lang>
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<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;">"""
Line 3,263 ⟶ 3,885:
<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>
<!--</langsyntaxhighlight>-->
 
=={{header|Phixmonti}}==
<langsyntaxhighlight Phixmontilang="phixmonti">include ..\Utilitys.pmt
 
(
Line 3,307 ⟶ 3,929:
dup print 9 tochar print price_fix print nl
endfor
</syntaxhighlight>
</lang>
 
=={{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 3,340 ⟶ 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 3,354 ⟶ 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 3,367 ⟶ 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 3,385 ⟶ 4,105:
Return(r(i));
End;
End;</langsyntaxhighlight>
 
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
<lang PowerShell>
function Convert-PriceFraction
{
Line 3,434 ⟶ 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 3,446 ⟶ 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 3,561 ⟶ 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.
<langsyntaxhighlight lang="quackery">[ $ 'bigrat.qky' loadfile ] now!
 
[ 2over 2over v< if 2swap 2drop ] is vmax ( n/d n/d --> n/d )
Line 3,593 ⟶ 4,237:
say ' --> '
$->v drop scale
2 point$ echo$</langsyntaxhighlight>
{{out}}
<pre>
Line 3,606 ⟶ 4,250:
 
=={{header|R}}==
<syntaxhighlight lang="r">
<lang r>
price_fraction <- function(x)
{
Line 3,618 ⟶ 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 3,646 ⟶ 4,290:
breaks <- dfr$V4
values <- dfr$V6
</syntaxhighlight>
</lang>
 
=={{header|Racket}}==
 
<syntaxhighlight lang="racket">
<lang Racket>
#lang racket
 
Line 3,662 ⟶ 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 3,671 ⟶ 4,315:
 
{{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 3,696 ⟶ 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 3,726 ⟶ 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 3,763 ⟶ 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 3,790 ⟶ 4,434:
=={{header|REXX}}==
===version 1===
<langsyntaxhighlight lang="rexx">/*REXX program re─scales a (decimal fraction) price (in the range of: 0¢ ──► $1). */
pad= ' ' /*for inserting spaces into a message. */
do j=0 to 1 by .01 /*process the prices from 0¢ to ≤ $1 */
Line 3,822 ⟶ 4,466:
otherwise nop
end /*select*/
return ?</langsyntaxhighlight>
{{out|output|text=:}}
<pre style="height:66ex">
Line 3,929 ⟶ 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,950 ⟶ 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,978 ⟶ 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 4,005 ⟶ 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 4,012 ⟶ 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 4,059 ⟶ 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 4,088 ⟶ 4,782:
end
end
end</langsyntaxhighlight>
 
{{out}}
Line 4,097 ⟶ 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 4,174 ⟶ 4,851:
input_price += 0.01;
}
}</langsyntaxhighlight>
 
{{out}}
Line 4,207 ⟶ 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 4,216 ⟶ 4,893:
 
def testPriceFraction()=
for(n <- 0.00 to (1.00, 0.01)) println("%.2f %.2f".format(n, priceFraction(n)))</langsyntaxhighlight>
{{out}}
<pre>
Line 4,257 ⟶ 4,934:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "float.s7i";
 
Line 4,284 ⟶ 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 4,307 ⟶ 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 4,344 ⟶ 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 4,360 ⟶ 5,037:
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<langsyntaxhighlight lang="smalltalk">"Table driven rescale"
Object subclass: PriceRescale [
|table|
Line 4,408 ⟶ 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 4,443 ⟶ 5,120:
 
print("\(strFmt(val)) -> \(strFmt(adjustDouble(val, accordingTo: ranges) ?? val))")
}</langsyntaxhighlight>
 
{{out}}
Line 4,551 ⟶ 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 4,573 ⟶ 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 4,603 ⟶ 5,280:
foreach example {.7388727 .8593103 .826687 .3444635 .0491907} {
puts "$example -> [priceFraction $map $example]"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 4,613 ⟶ 5,290:
</pre>
 
=={{header|uBasic/4tH}}==
{{trans|Forth}}
{{works with|R3}}
<lang>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)</lang>
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|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 4,675 ⟶ 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 4,690 ⟶ 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 4,773 ⟶ 5,371:
WScript.Echo pf(0.826687)
WScript.Echo pf(0.3444635)
</syntaxhighlight>
</lang>
 
{{Out}}
Line 4,785 ⟶ 5,383:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./fmt" for Fmt
 
var rescale = Fn.new { |v|
Line 4,812 ⟶ 5,410:
for (test in tests) {
Fmt.print("$4.2f -> $4.2f", test, rescale.call(test))
}</langsyntaxhighlight>
 
{{out}}
Line 4,839 ⟶ 5,437:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations
 
func real Price(V); \Convert to standard value
Line 4,871 ⟶ 5,469:
RlOut(0, Price(0.10)); CrLf(0);
RlOut(0, Price(1.0)); CrLf(0);
]</langsyntaxhighlight>
 
{{out}}
Line 4,881 ⟶ 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 4,891 ⟶ 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/143393...363631"