Price fraction: Difference between revisions
→{{header|langur}}
(Added uBasic/4tH version) |
Langurmonkey (talk | contribs) |
||
(20 intermediate revisions by 13 users not shown) | |||
Line 32:
{{trans|Python}}
<
V lo = 0
V hi = a.len
Line 49:
L(i) 0..10
print(‘#.2 #.2’.format(i / 10, pricerounder(i / 10)))</
{{out}}
Line 67:
=={{header|Action!}}==
<
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</
{{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">
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>
The solution uses fixed point type to prevent rounding and representation issues. With the above declarations a full coverage test:
<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
procedure Test_Price_Fraction is
Line 177:
end loop;
end Test_Price_Fraction;
</syntaxhighlight>
{{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}}
<
(
# Just get a random price between 0 and 1 #
Line 321:
printf(($"Value : "z.2dl,"Converted to standard : "z.2dl$, price, std val))
)</
{{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:
<
on standardisePrice(input)
Line 366:
set output to linefeed & "Originals: " & originals & linefeed & "Standardised: " & standardised
set AppleScript's text item delimiters to astid
return output</
{{output}}
<
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"</
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.
<
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</
{{output}}
<
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"</
===Functional===
<
property table : [¬
Line 809:
end tell
end if
end zipWith</
{{Out}}
<pre>Price adjustments:
Line 839:
=={{header|Arturo}}==
<
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]
]</
{{out}}
Line 872:
=={{header|AutoHotkey}}==
<
Loop
Line 905:
Return 0 ; returns 0, indicating failure (shouldn't be reached though)
}</
=={{header|AWK}}==
<syntaxhighlight 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>
=={{header|BASIC}}==
{{works with|QBasic}}
This could also be done by building an array, but I felt that this was simpler.
<
RANDOMIZE TIMER
Line 993 ⟶ 991:
PriceFraction! = price
END SELECT
END FUNCTION</
{{out}} (run 5 times):
Line 1,002 ⟶ 1,000:
.0491907 .1
==={{header|
{{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.
<
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>
{{out}}
Line 1,056 ⟶ 1,094:
ready.</pre>
==={{header|
<syntaxhighlight lang="freebasic">' FB 1.050.0 Win64
Function rescale(price As Double) As Double
If price < 0.00 OrElse price > 1.00 Then Return price
Select Case price
Case Is < 0.06 : Return 0.10
Case Is < 0.11 : Return 0.18
Case Is < 0.21 : Return 0.32
Case Is < 0.26 : Return 0.38
Case Is < 0.31 : Return 0.44
Case Is < 0.36 : Return 0.50
Case Is < 0.41 : Return 0.54
Case Is < 0.46 : Return 0.58
Case Is < 0.51 : Return 0.62
Case Is < 0.56 : Return 0.66
Case Is < 0.61 : Return 0.70
Case Is < 0.66 : Return 0.74
Case Is < 0.71 : Return 0.78
Case Is < 0.76 : Return 0.82
Case Is < 0.81 : Return 0.86
Case Is < 0.86 : Return 0.90
Case Is < 0.91 : Return 0.94
Case Is < 0.96 : Return 0.98
End Select
Return 1.00
End Function
For i As Integer = 1 To 100
Dim d As Double = i/100.0
Print Using "#.##"; d;
Print " ->
Print Using "#.##"; rescale(d);
Print " ";
If i Mod 5
Next
Print
Print "Press any key to quit"
Sleep</syntaxhighlight>
{{out}}
<pre>
0.01 -> 0.10 0.02 ->
0.06 -> 0.18 0.07 ->
0.11 -> 0.26 0.12 ->
0.16 -> 0.32 0.17 ->
0.21 -> 0.38 0.22 ->
0.26 -> 0.44 0.27 ->
0.31 -> 0.50 0.32 ->
0.36 -> 0.54 0.37 ->
0.41 -> 0.58 0.42 ->
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}}==
<
record a_table
Line 1,134 ⟶ 1,537:
if v < table[ix].value
log "{v} => {table[ix].rescaled}"
exit</
{{out}}
<pre>0.05 => 0.1
Line 1,144 ⟶ 1,547:
=={{header|Bracmat}}==
<
=
. ("0.06"."0.10")
Line 1,181 ⟶ 1,584:
& out$(!a "-->" convert$!a)
)
)</
{{out}}
<pre>0.00 --> 0.10
Line 1,222 ⟶ 1,625:
=={{header|C}}==
<
double table[][2] = {
Line 1,249 ⟶ 1,652:
return 0;
}</
=={{header|C sharp|C#}}==
<
{
class Program
Line 1,304 ⟶ 1,707:
}
}
}</
=={{header|C++}}==
<
#include <cmath>
Line 1,337 ⟶ 1,740:
return 0 ;
}
</syntaxhighlight>
{{out}}
Line 1,355 ⟶ 1,758:
=={{header|Clipper}}==
<
LOCAL aPriceFraction := { {0,.06,.1},;
{.06,.11,.18}, ;
Line 1,387 ⟶ 1,790:
nResult := aPriceFraction[ nScan ][ 3 ]
END IF
RETURN nResult</
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:
<
Local i
For i := -0.02 to 1.02 STEP 0.03
Line 1,436 ⟶ 1,839:
nResult := NIL
Endif
Return nResult</
{{out}}
Line 1,477 ⟶ 1,880:
=={{header|Clojure}}==
{{trans|JavaScript}}
<
(defn price [v]
(format "%.2f" (double (/ (values (int (/ (- (* v 100) 1) 5))) 100))))</
Line 1,513 ⟶ 1,916:
=={{header|Common Lisp}}==
<
(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))))</
=={{header|D}}==
<
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;
}</
{{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">
class
APPLICATION
Line 1,599 ⟶ 2,210:
end
</syntaxhighlight>
<syntaxhighlight lang="eiffel">
class
PRICE_FRACTION
Line 1,642 ⟶ 2,253:
end
</syntaxhighlight>
{{out}}
<pre>
Line 1,665 ⟶ 2,276:
Given: 0.95 Adjusted:0.98
</pre>
=={{header|Elixir}}==
<
@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)</
{{out}}
Line 1,709 ⟶ 2,319:
=={{header|Erlang}}==
<
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.</
=={{header|Euphoria}}==
{{trans|C}}
<
{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</
=={{header|F_Sharp|F#}}==
Inspired by Python's bisect solution. Using decimal (System.Decimal) to avoid number representation problems with floats.
<
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))</
{{out}}
The same as shown by Ada as of 2013-11-03T17:42Z (apart from whitespace formatting)
=={{header|Factor}}==
<
{ 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</
{{out}}
Line 1,810 ⟶ 2,420:
=={{header|Fantom}}==
<
class Defn // to hold the three numbers from a 'row' in the table
{
Line 1,880 ⟶ 2,490:
}
}
</syntaxhighlight>
=={{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.
<
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@ ;</
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</
Output:
<pre>
Line 1,936 ⟶ 2,546:
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
implicit none
Line 1,954 ⟶ 2,564:
end do
end program price_fraction</
{{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</
=={{header|
<syntaxhighlight lang="futurebasic">
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
NSUInteger i
for i = 1 to 100
printf @"%.2f -> %.2f\t\b", d, fn PriceFraction( d )
next
end fn
fn GetPriceFractions
NSLog( @"%@", fn WindowPrintViewString( 1 ) )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
0.01 -> 0.10
0.06 -> 0.18
0.11 -> 0.26
0.16 -> 0.32
0.21 -> 0.38
0.26 -> 0.44
0.31 -> 0.50
0.36 -> 0.54
0.41 -> 0.58
0.46 -> 0.62
0.51 -> 0.66
0.56 -> 0.70
0.61 -> 0.74
0.66 -> 0.78
0.71 -> 0.82
0.76 -> 0.86
0.81 -> 0.90
0.86 -> 0.94
0.91 -> 0.98
0.96 -> 1.00
</pre>
=={{header|Go}}==
<
import "fmt"
Line 2,129 ⟶ 2,702:
fmt.Printf("%0.4f -> %0.2f\n", v, pf(v))
}
}</
<pre>
Line 2,145 ⟶ 2,718:
=={{header|Groovy}}==
<
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)}"
}</
{{out}}
<div style="height: 200px;overflow:scroll">
Line 2,268 ⟶ 2,841:
=={{header|Haskell}}==
<
| 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</
Alternative {{trans|OCaml}}:
<
(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</
=={{header|HicEst}}==
<
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</
<pre>0.589230 0.70
0.017623 0.10
Line 2,326 ⟶ 2,899:
=={{header|Icon}} and {{header|Unicon}}==
<syntaxhighlight lang="icon">
record Bounds(low,high,new)
Line 2,366 ⟶ 2,939:
}
end
</syntaxhighlight>
{{out}}
Line 2,386 ⟶ 2,959:
Inform doesn't have native floating-point support; this version uses fixed point numbers with two decimal places.
<
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.</
=={{header|J}}==
'''Solution:'''
<
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. -</
'''Example:'''
<
0.5 0.18 0.18 0.1 0.62 0.7 1 1 0.1</
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}}==
<
public class Main {
Line 2,474 ⟶ 3,047:
}
}
}</
{{out}}
<pre>0.149969 -> 0.26
Line 2,493 ⟶ 3,066:
Passing a value outside the range 0 <= x < 1.01 will return undefined.
<
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];
}</
=={{header|jq}}==
The solution given here is based on the JavaScript solution.
<
["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 ] ;</
The full coverage test as given in the Ada example:
<
(range(0;10) | "0.0\(.) -> \( 0.01 * . | getScaleFactor)"),
(range(10;100) | "0.\(.) -> \( 0.01 * . | getScaleFactor)");
test</
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>.<</code>) of this value to the cut-off array.
<syntaxhighlight 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>
{{out}}
Line 2,588 ⟶ 3,161:
Translation of the J solution:
<syntaxhighlight 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>
{{out}}
<pre>
Line 2,601 ⟶ 3,174:
=={{header|Kotlin}}==
<
fun rescale(price: Double): Double =
Line 2,634 ⟶ 3,207:
if (i % 5 == 0) println()
}
}</
{{out}}
Line 2,663 ⟶ 3,236:
Langur uses decimal floating point.
<
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"
}}
writeln .pricefrac(0.17)
writeln .pricefrac(0.71)</
{{out}}
<pre>0.32
0.82</pre>
=={{header|Lua}}==
<
{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</
{{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}}==
<
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;</
{{out}}
<pre>0.524386 --> 0.66
Line 2,792 ⟶ 3,413:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
{.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]</
=={{header|MATLAB}} / {{header|Octave}}==
<
L = [0,.06:.05:1.02];
Line 2,812 ⟶ 3,433:
t=0:0.001:1;
plot(t,rescale(t)); </
=={{header|Mercury}}==
<
:- interface.
:- import_module int.
Line 2,858 ⟶ 3,479:
rule(86, 91, 94),
rule(91, 96, 98),
rule(96, 101, 100)].</
A build system might turn the text of the table into the definition of a hundred-element array of adjustments. In that case,
<
=={{header|MUMPS}}==
<
;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</
{{out}}
<pre>USER>W $$PRICFRAC^ROSETTA(.04)
Line 2,889 ⟶ 3,511:
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 2,946 ⟶ 3,568:
end tv
return test_vals
</syntaxhighlight>
{{out}}
<pre>
Line 2,958 ⟶ 3,580:
=={{header|Nim}}==
<
# 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()}"</
{{out}}
A random output looking something like this:
Line 3,007 ⟶ 3,629:
=={{header|Objeck}}==
{{trans|C#}}
<
function : Main(args : String[]) ~ Nil {
for(i := 0; i < 5; i++;) {
Line 3,041 ⟶ 3,663:
return inValue;
}
}</
{{output}}
Line 3,054 ⟶ 3,676:
=={{header|OCaml}}==
<
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;
]</
<
let ok_tests = [
(0.3793, 0.54);
Line 3,087 ⟶ 3,709:
Printf.printf " %6g %g %b\n" v r (r = ok);
) ok_tests;
;;</
=={{header|Oforth}}==
<
[.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 ;</
{{Out}}
Line 3,110 ⟶ 3,732:
i.e. a value that throws an exception when it is accessed.
<
OutOfRange = {Value.failed outOfRange(X)}
in
Line 3,124 ⟶ 3,746:
if X < Limit then {Return Result} end
end
end</
=={{header|PARI/GP}}==
<
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"
};</
=={{header|Pascal}}==
<
const
Line 3,162 ⟶ 3,784:
writeln (cost:6:4, ' -> ', price[j+1]:4:2);
end;
end.</
{{out}}
<pre>% ./PriceFraction
Line 3,177 ⟶ 3,799:
=={{header|Perl}}==
<
>= 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>
=={{header|Phix}}==
<!--<syntaxhighlight lang="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;">"""
>= 0.91 < 0.96 := 0.98
>= 0.96 < 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;">">= %.2f < %.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}}==
<
(
Line 3,302 ⟶ 3,929:
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}}==
<
(de price (Pr)
Line 3,335 ⟶ 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)) )</
{{out}}
<pre>0.54
Line 3,349 ⟶ 4,074:
=={{header|PL/I}}==
===version 1===
<
.06, .11, .16, .21, .26, .31, .36, .41, .46, .51,
.56, .61, .66, .71, .76, .81, .86, .91, .96, 1.01);
Line 3,362 ⟶ 4,087:
if x < t(i) then
do; d = r(i); leave loop; end;
end;</
===version 2===
{{trans|REXX version2}}
<
Dcl x Dec Fixed(4,2);
Do x=0 To 1 By 0.01;
Line 3,380 ⟶ 4,105:
Return(r(i));
End;
End;</
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function Convert-PriceFraction
{
Line 3,429 ⟶ 4,154:
}
}
</syntaxhighlight>
<syntaxhighlight lang="powershell">
.7388727, .8593103, .826687, .3444635, .0491907 | Convert-PriceFraction | ForEach-Object {"{0:C}" -f $_}
</syntaxhighlight>
{{Out}}
<pre>
Line 3,441 ⟶ 4,166:
$0.10
</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.
<
>>> _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) ]</
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:
<
>>> _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) ]</
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:
:<
"""Return the index where to insert item x in list a, assuming a is sorted.
Line 3,556 ⟶ 4,205:
if x < a[mid]: hi = mid
else: lo = mid+1
return lo</
=={{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.
<
[ 2over 2over v< if 2swap 2drop ] is vmax ( n/d n/d --> n/d )
Line 3,588 ⟶ 4,237:
say ' --> '
$->v drop scale
2 point$ echo$</
{{out}}
<pre>
Line 3,601 ⟶ 4,250:
=={{header|R}}==
<syntaxhighlight lang="r">
price_fraction <- function(x)
{
Line 3,613 ⟶ 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>
You can extract the contents of the table as follows:
<syntaxhighlight lang="r">
dfr <- read.table(tc <- textConnection(
">= 0.00 < 0.06 := 0.10
Line 3,641 ⟶ 4,290:
breaks <- dfr$V4
values <- dfr$V6
</syntaxhighlight>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
Line 3,657 ⟶ 4,306:
;; returns #f for negatives or values >= 1.01
(define (convert x) (for/or ([c table]) (and (< x (car c)) (cadr c))))
</syntaxhighlight>
=={{header|Raku}}==
Line 3,666 ⟶ 4,315:
{{works with|rakudo|2016.07}}
<syntaxhighlight lang="raku"
when $n < 0.06 { 0.10 }
when $n < 0.11 { 0.18 }
Line 3,691 ⟶ 4,340:
while prompt("value: ") -> $value {
say price-fraction(+$value);
}</
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"
( 0 ..^ 6 X=> 0.10),
( 6 ..^ 11 X=> 0.18),
Line 3,721 ⟶ 4,370:
while prompt("value: ") -> $value {
say @price[$value * 100] // "Out of range";
}</
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"
>= 0.00 < 0.06 := 0.10
>= 0.06 < 0.11 := 0.18
Line 3,758 ⟶ 4,407:
while prompt("value: ") -> $value {
say @price[$value * 100] // "Out of range";
}</
=={{header|Raven}}==
{{trans|JavaScript}}
<
[ 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</
{{out}}
<pre>0 -> 0.1
Line 3,785 ⟶ 4,434:
=={{header|REXX}}==
===version 1===
<
pad= ' ' /*for inserting spaces into a message. */
do j=0 to 1 by .01 /*process the prices from 0¢ to ≤ $1 */
Line 3,817 ⟶ 4,466:
otherwise nop
end /*select*/
return ?</
{{out|output|text=:}}
<pre style="height:66ex">
Line 3,924 ⟶ 4,573:
===version 2===
<
* Inspired by some other solutions tested with version 1 (above)
* 20.04.2013 Walter Pachl
Line 3,945 ⟶ 4,594:
adjprice2: Procedure Expose r.
i=((100*arg(1)-1)%5+1)
Return r.i</
=={{header|Ring}}==
<
see pricefraction(0.5)
Line 3,973 ⟶ 4,622:
return 1
</syntaxhighlight>
=={{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.
<
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,000 ⟶ 4,699:
elsif value < 1.01 then 1.00
end
end</
Or, where we can cut and paste the textual table in one place
Line 4,007 ⟶ 4,706:
For Ruby 1.8.6, use <code>String#each_line</code>
<
ConversionTable = <<-END_OF_TABLE
>= 0.00 < 0.06 := 0.10
Line 4,054 ⟶ 4,753:
end
attr_reader :standard_value
end</
And a test suite
<
class PriceFractionTests < Test::Unit::TestCase
Line 4,083 ⟶ 4,782:
end
end
end</
{{out}}
Line 4,092 ⟶ 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]
tests.each do |test|
price = prices[ keys.bsearch_index{|key| key >= test } ]
puts [test, price].join(": ")
end
</syntaxhighlight>
=={{header|Rust}}==
<
match num {
0.96...1.00 => 1.00,
Line 4,169 ⟶ 4,851:
input_price += 0.01;
}
}</
{{out}}
Line 4,202 ⟶ 4,884:
=={{header|Scala}}==
<
case n if n>=0 && n<0.06 => 0.10
case n if n<0.11 => 0.18
Line 4,211 ⟶ 4,893:
def testPriceFraction()=
for(n <- 0.00 to (1.00, 0.01)) println("%.2f %.2f".format(n, priceFraction(n)))</
{{out}}
<pre>
Line 4,252 ⟶ 4,934:
=={{header|Seed7}}==
<
include "float.s7i";
Line 4,279 ⟶ 4,961:
writeln(flt(i) / 100.0 digits 2 <& " " <& computePrice(flt(i) / 100.0) digits 2);
end for;
end func;</
The following variant of ''computePrice'' works with a table and raises RANGE_ERROR when x < 0.0 or x >= 1.01 holds:
<
[] (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,302 ⟶ 4,984:
raise RANGE_ERROR;
end if;
end func;</
=={{header|Sidef}}==
<
>= 0.00 < 0.06 := 0.10
>= 0.06 < 0.11 := 0.18
Line 4,339 ⟶ 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);
}</
{{out}}
<pre>
Line 4,355 ⟶ 5,037:
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<
Object subclass: PriceRescale [
|table|
Line 4,403 ⟶ 5,085:
"get a price"
(pr rescale: ( (Random between: 0 and: 100)/100 )) displayNl.</
=={{header|Swift}}==
<
(0.00..<0.06, 0.10),
(0.06..<0.11, 0.18),
Line 4,438 ⟶ 5,120:
print("\(strFmt(val)) -> \(strFmt(adjustDouble(val, accordingTo: ranges) ?? val))")
}</
{{out}}
Line 4,546 ⟶ 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.
<
proc parseTable table {
set map {}
Line 4,568 ⟶ 5,250:
# Failed to map; return the input
return $value
}</
How it is used:
<
set inputTable {
>= 0.00 < 0.06 := 0.10
Line 4,598 ⟶ 5,280:
foreach example {.7388727 .8593103 .826687 .3444635 .0491907} {
puts "$example -> [priceFraction $map $example]"
}</
{{out}}
<pre>
Line 4,608 ⟶ 5,290:
</pre>
=={{header|Ursala}}==
<
le = <0.06,.11,.16,.21,.26,.31,.36,.41,.46,.51,.56,.61,.66,.71,.76,.81,.86,.91,.96,1.01>
out = <0.10,.18,.26,.32,.38,.44,.50,.54,.58,.62,.66,.70,.74,.78,.82,.86,.90,.94,.98,1.>
price_fraction = fleq@rlPlX*|rhr\~&p(le,out)</
main points:
* <code>~&p(le,out)</code> zips the pair of lists <code>le</code> and <code>out</code> into a list of pairs
Line 4,670 ⟶ 5,305:
test program:
<
test = price_fraction* <0.34,0.070145,0.06,0.05,0.50214,0.56,1.,0.99,0.>
</syntaxhighlight>
{{out}}
<pre><
Line 4,685 ⟶ 5,320:
1.000000e+00,
1.000000e-01></pre>
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Function pf(p)
If p < 0.06 Then
Line 4,768 ⟶ 5,371:
WScript.Echo pf(0.826687)
WScript.Echo pf(0.3444635)
</syntaxhighlight>
{{Out}}
Line 4,780 ⟶ 5,383:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<
var rescale = Fn.new { |v|
Line 4,807 ⟶ 5,410:
for (test in tests) {
Fmt.print("$4.2f -> $4.2f", test, rescale.call(test))
}</
{{out}}
Line 4,834 ⟶ 5,437:
=={{header|XPL0}}==
<
func real Price(V); \Convert to standard value
Line 4,866 ⟶ 5,469:
RlOut(0, Price(0.10)); CrLf(0);
RlOut(0, Price(1.0)); CrLf(0);
]</
{{out}}
Line 4,876 ⟶ 5,479:
=={{header|zkl}}==
<
// < -->, 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,886 ⟶ 5,489:
T(0.96, 0.98), T(1.01, 1.00), );
vert.filter1('wrap([(a,_)]){ price<a })[1]
}</
<
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];
}</
<
T(0.7388727, 0.8593103, 0.826687, 0.3444635, 0.0491907).apply(convert2).println();</
{{out}}
<pre>
|