Data commit

Task/Price-fraction/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Price_fraction
+note: Financial operations

Task/Price-fraction/00-TASK.txt

@@ -0,0 +1,28 @@
+A friend of mine runs a pharmacy.   He has a specialized function in his Dispensary application which receives a decimal value of currency and replaces it to a standard value.   This value is regulated by a government department.
+
+
+;Task:
+Given a floating point value between   0.00   and   1.00,   rescale according to the following table:
+
+ >=  0.00  <  0.06  :=  0.10
+ >=  0.06  <  0.11  :=  0.18
+ >=  0.11  <  0.16  :=  0.26
+ >=  0.16  <  0.21  :=  0.32
+ >=  0.21  <  0.26  :=  0.38
+ >=  0.26  <  0.31  :=  0.44
+ >=  0.31  <  0.36  :=  0.50
+ >=  0.36  <  0.41  :=  0.54
+ >=  0.41  <  0.46  :=  0.58
+ >=  0.46  <  0.51  :=  0.62
+ >=  0.51  <  0.56  :=  0.66
+ >=  0.56  <  0.61  :=  0.70
+ >=  0.61  <  0.66  :=  0.74
+ >=  0.66  <  0.71  :=  0.78
+ >=  0.71  <  0.76  :=  0.82
+ >=  0.76  <  0.81  :=  0.86
+ >=  0.81  <  0.86  :=  0.90
+ >=  0.86  <  0.91  :=  0.94
+ >=  0.91  <  0.96  :=  0.98
+ >=  0.96  <  1.01  :=  1.00
+<br><br>
+

Task/Price-fraction/11l/price-fraction.11l

@@ -0,0 +1,18 @@
+F bisect_right(a, x)
+   V lo = 0
+   V hi = a.len
+   L lo < hi
+      V mid = (lo + hi) I/ 2
+      I x < a[mid]
+         hi = mid
+      E
+         lo = mid + 1
+   R lo
+
+V _cin  = [0.06, 0.11, 0.16, 0.21, 0.26, 0.31, 0.36, 0.41, 0.46, 0.51, 0.56, 0.61, 0.66, 0.71, 0.76, 0.81, 0.86, 0.91, 0.96, 1.01]
+V _cout = [0.10, 0.18, 0.26, 0.32, 0.38, 0.44, 0.50, 0.54, 0.58, 0.62, 0.66, 0.70, 0.74, 0.78, 0.82, 0.86, 0.90, 0.94, 0.98, 1.00]
+F pricerounder(pricein)
+   R :_cout[bisect_right(:_cin, pricein)]
+
+L(i) 0..10
+   print(‘#.2 #.2’.format(i / 10, pricerounder(i / 10)))

Task/Price-fraction/ALGOL-68/price-fraction.alg

@@ -0,0 +1,30 @@
+main:
+(
+    # Just get a random price between 0 and 1 #
+    # srand(time(NIL)); #
+    REAL price := random;
+    REAL tops := 0.06;
+    REAL std val := 0.10;
+
+    # Conditionals are a little odd here "(price-0.001 < tops AND
+    price+0.001 > tops)" is to check if they are equal. Stupid
+    C floats, right?   :) #
+    WHILE ( price>tops OR (price-0.001 < tops AND price+0.001 > tops) ) AND tops<=1.01
+    DO
+        tops+:=0.05;
+
+        IF std val < 0.26 THEN
+                std val +:= 0.08
+        ELIF std val < 0.50 THEN
+                std val +:= 0.06
+        ELSE
+                std val +:= 0.04
+        FI;
+
+        IF std val > 0.98 THEN
+                std val := 1.0
+        FI
+    OD;
+
+    printf(($"Value :   "z.2dl,"Converted to standard :   "z.2dl$, price, std val))
+)

Task/Price-fraction/AWK/price-fraction.awk

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

Task/Price-fraction/Action-/price-fraction.action

@@ -0,0 +1,37 @@
+DEFINE COUNT="20"
+BYTE ARRAY levels=[6 11 16 21 26 31 36 41 46 51 56 61 66 71 76 81 86 91 96 101]
+BYTE ARRAY values=[10 18 26 32 38 44 50 54 58 62 66 70 74 78 82 86 90 94 98 100]
+
+PROC PrintValue(BYTE v)
+  PrintB(v/100) Put('.)
+  v=v MOD 100
+  PrintB(v/10)
+  v=v MOD 10
+  PrintB(v)
+RETURN
+
+BYTE FUNC Map(BYTE v)
+  BYTE i
+
+  FOR i=0 TO COUNT-1
+  DO
+    IF v<levels(i) THEN
+      RETURN (values(i))
+    FI
+  OD
+RETURN (v)
+
+PROC Main()
+  BYTE i,v
+
+  FOR i=0 TO 100
+  DO
+    v=Map(i)
+    PrintValue(v)
+    IF i MOD 5=4 THEN
+      PutE()
+    ELSE
+      Put(' )
+    FI
+  OD
+RETURN

Task/Price-fraction/Ada/price-fraction-1.ada

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

Task/Price-fraction/Ada/price-fraction-2.ada

@@ -0,0 +1,11 @@
+with Ada.Text_IO; use Ada.Text_IO;
+procedure Test_Price_Fraction is
+   -- Put the declarations here
+   Value : Price := Price'First;
+begin
+   loop
+      Put_Line (Price'Image (Value) & "->" & Price'Image (Scale (Value)));
+      exit when Value = Price'Last;
+      Value := Price'Succ (Value);
+   end loop;
+end Test_Price_Fraction;

Task/Price-fraction/AppleScript/price-fraction-1.applescript

@@ -0,0 +1,35 @@
+-- This handler just returns the standardised real value. It's up to external processes to format it for display.
+
+on standardisePrice(input)
+    set integerPart to input div 1.0
+    set fractionalPart to input mod 1.0
+
+    if (fractionalPart is 0.0) then
+        return input as real
+    else if (fractionalPart < 0.06) then
+        return integerPart + 0.1
+    else if (fractionalPart < 0.16) then
+        return integerPart + 0.18 + (fractionalPart - 0.06) div 0.05 * 0.08
+    else if (fractionalPart < 0.36) then
+        return integerPart + 0.32 + (fractionalPart - 0.16) div 0.05 * 0.06
+    else if (fractionalPart < 0.96) then
+        return integerPart + 0.54 + (fractionalPart - 0.36) div 0.05 * 0.04
+    else
+        return integerPart + 1.0
+    end if
+end standardisePrice
+
+-- Test code:
+set originals to {}
+set standardised to {}
+repeat 20 times
+    set price to (random number 100) / 100
+    set end of originals to text 2 thru -2 of ((price + 10.001) as text)
+    set end of standardised to text 2 thru -2 of ((standardisePrice(price) + 10.001) as text)
+end repeat
+
+set astid to AppleScript's text item delimiters
+set AppleScript's text item delimiters to ", "
+set output to linefeed & "Originals:    " & originals & linefeed & "Standardised: " & standardised
+set AppleScript's text item delimiters to astid
+return output

Task/Price-fraction/AppleScript/price-fraction-2.applescript

@@ -0,0 +1,3 @@
+"
+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"

Task/Price-fraction/AppleScript/price-fraction-3.applescript

@@ -0,0 +1,29 @@
+-- This handler just returns the standardised real value. It's up to external processes to format it for display.
+
+on standardisePrice(input, table)
+    set integerPart to input div 1.0
+    set fractionalPart to input mod 1.0
+
+    if (fractionalPart is 0.0) then return input as real
+    repeat with thisEntry in table
+        if (fractionalPart ≤ beginning of thisEntry) then return integerPart + (end of thisEntry)
+    end repeat
+end standardisePrice
+
+-- Test code:
+-- The conceit here is that the conversion table has been obtained from a file or from a spreadsheet application.
+set table to {{0.05, 0.1}, {0.1, 0.18}, {0.15, 0.26}, {0.2, 0.32}, {0.25, 0.38}, {0.3, 0.44}, {0.35, 0.5}, {0.4, 0.54}, {0.45, 58}, {0.5, 0.62}, {0.55, 0.66}, {0.6, 0.7}, {0.65, 0.74}, {0.7, 0.78}, {0.75, 0.82}, {0.8, 0.86}, {0.85, 0.9}, {0.9, 0.94}, {0.95, 0.98}, {0.99, 1.0}}
+
+set originals to {}
+set standardised to {}
+repeat 20 times
+    set price to (random number 100) / 100
+    set end of originals to text 2 thru -2 of ((price + 10.001) as text)
+    set end of standardised to text 2 thru -2 of ((standardisePrice(price, table) + 10.001) as text)
+end repeat
+
+set astid to AppleScript's text item delimiters
+set AppleScript's text item delimiters to ", "
+set output to linefeed & "Originals:    " & originals & linefeed & "Standardised: " & standardised
+set AppleScript's text item delimiters to astid
+return output

Task/Price-fraction/AppleScript/price-fraction-4.applescript

@@ -0,0 +1,3 @@
+"
+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"

Task/Price-fraction/AppleScript/price-fraction-5.applescript

@@ -0,0 +1,399 @@
+---------------------- PRICE FRACTION ----------------------
+
+property table : [¬
+    {0.06, 0.1}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32}, {0.26, 0.38}, ¬
+    {0.31, 0.44}, {0.36, 0.5}, {0.41, 0.54}, {0.46, 0.58}, {0.51, 0.62}, ¬
+    {0.56, 0.66}, {0.61, 0.7}, {0.66, 0.74}, {0.71, 0.78}, {0.76, 0.82}, ¬
+    {0.81, 0.86}, {0.86, 0.9}, {0.91, 0.94}, {0.96, 0.98}, {1.01, 1.0}]
+
+
+-- rescaled :: [(Float, Float)] -> Float -> Float
+on rescaled(table)
+    script
+        on |λ|(x)
+            if 0 > x or 1.01 < x then
+                |Left|("Out of range.")
+            else
+                |Right|(snd(my head(dropWhile(compose(ge(x), my fst), table))))
+            end if
+        end |λ|
+    end script
+end rescaled
+
+
+--------------------------- TEST ---------------------------
+on run
+    fTable("Price adjustments:\n", ¬
+        showReal(2), either(identity, showReal(2)), ¬
+        rescaled(table), enumFromThenTo(-0.05, 0, 1.1))
+end run
+
+
+----------- GENERAL AND REUSABLE PURE FUNCTIONS ------------
+
+-- Left :: a -> Either a b
+on |Left|(x)
+    {type:"Either", |Left|:x, |Right|:missing value}
+end |Left|
+
+
+-- Right :: b -> Either a b
+on |Right|(x)
+    {type:"Either", |Left|:missing value, |Right|:x}
+end |Right|
+
+
+-- compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
+on compose(f, g)
+    script
+        property mf : mReturn(f)
+        property mg : mReturn(g)
+        on |λ|(x)
+            mf's |λ|(mg's |λ|(x))
+        end |λ|
+    end script
+end compose
+
+
+-- drop :: Int -> [a] -> [a]
+-- drop :: Int -> String -> String
+on drop(n, xs)
+    set c to class of xs
+    if script is not c then
+        if string is not c then
+            if n < length of xs then
+                items (1 + n) thru -1 of xs
+            else
+                {}
+            end if
+        else
+            if n < length of xs then
+                text (1 + n) thru -1 of xs
+            else
+                ""
+            end if
+        end if
+    else
+        take(n, xs) -- consumed
+        return xs
+    end if
+end drop
+
+
+-- dropWhile :: (a -> Bool) -> [a] -> [a]
+-- dropWhile :: (Char -> Bool) -> String -> String
+on dropWhile(p, xs)
+    set lng to length of xs
+    set i to 1
+    tell mReturn(p)
+        repeat while i ≤ lng and |λ|(item i of xs)
+            set i to i + 1
+        end repeat
+    end tell
+    drop(i - 1, xs)
+end dropWhile
+
+
+-- either :: (a -> c) -> (b -> c) -> Either a b -> c
+on either(lf, rf)
+    script
+        on |λ|(e)
+            if missing value is |Left| of e then
+                tell mReturn(rf) to |λ|(|Right| of e)
+            else
+                tell mReturn(lf) to |λ|(|Left| of e)
+            end if
+        end |λ|
+    end script
+end either
+
+
+-- enumFromThenTo :: Int -> Int -> Int -> [Int]
+on enumFromThenTo(x1, x2, y)
+    set xs to {}
+    set d to x2 - x1
+    set v to x1
+    repeat until v ≥ y
+        set end of xs to v
+        set v to d + v
+    end repeat
+    return xs
+end enumFromThenTo
+
+
+-- foldl :: (a -> b -> a) -> a -> [b] -> a
+on foldl(f, startValue, xs)
+    tell mReturn(f)
+        set v to startValue
+        set lng to length of xs
+        repeat with i from 1 to lng
+            set v to |λ|(v, item i of xs, i, xs)
+        end repeat
+        return v
+    end tell
+end foldl
+
+
+-- fst :: (a, b) -> a
+on fst(tpl)
+    if class of tpl is record then
+        |1| of tpl
+    else
+        item 1 of tpl
+    end if
+end fst
+
+
+-- fTable :: String -> (a -> String) -> (b -> String) -> (a -> b) -> [a] -> String
+on fTable(s, xShow, fxShow, f, xs)
+    set ys to map(xShow, xs)
+    set w to maximum(map(my |length|, ys))
+    script arrowed
+        on |λ|(a, b)
+            justifyRight(w, space, a) & " -> " & b
+        end |λ|
+    end script
+    s & linefeed & unlines(zipWith(arrowed, ¬
+        ys, map(compose(fxShow, f), xs)))
+end fTable
+
+
+-- ge :: Ord a => a -> a -> Bool
+on ge(a)
+    -- True if a is greater
+    -- than or equal to b.
+    script
+        on |λ|(b)
+            a ≥ b
+        end |λ|
+    end script
+end ge
+
+
+-- head :: [a] -> a
+on head(xs)
+    if xs = {} then
+        missing value
+    else
+        item 1 of xs
+    end if
+end head
+
+
+-- identity :: a -> a
+on identity(x)
+    -- The argument unchanged.
+    x
+end identity
+
+
+-- justifyLeft :: Int -> Char -> String -> String
+on justifyLeft(n, cFiller, strText)
+    if n > length of strText then
+        text 1 thru n of (strText & replicate(n, cFiller))
+    else
+        strText
+    end if
+end justifyLeft
+
+
+-- justifyRight :: Int -> Char -> String -> String
+on justifyRight(n, cFiller, strText)
+    if n > length of strText then
+        text -n thru -1 of ((replicate(n, cFiller) as text) & strText)
+    else
+        strText
+    end if
+end justifyRight
+
+
+-- length :: [a] -> Int
+on |length|(xs)
+    set c to class of xs
+    if list is c or string is c then
+        length of xs
+    else
+        (2 ^ 29 - 1) -- (maxInt - simple proxy for non-finite)
+    end if
+end |length|
+
+
+-- map :: (a -> b) -> [a] -> [b]
+on map(f, xs)
+    -- The list obtained by applying f
+    -- to each element of xs.
+    tell mReturn(f)
+        set lng to length of xs
+        set lst to {}
+        repeat with i from 1 to lng
+            set end of lst to |λ|(item i of xs, i, xs)
+        end repeat
+        return lst
+    end tell
+end map
+
+
+-- max :: Ord a => a -> a -> a
+on max(x, y)
+    if x > y then
+        x
+    else
+        y
+    end if
+end max
+
+
+-- maximum :: Ord a => [a] -> a
+on maximum(xs)
+    script
+        on |λ|(a, b)
+            if a is missing value or b > a then
+                b
+            else
+                a
+            end if
+        end |λ|
+    end script
+
+    foldl(result, missing value, xs)
+end maximum
+
+
+-- min :: Ord a => a -> a -> a
+on min(x, y)
+    if y < x then
+        y
+    else
+        x
+    end if
+end min
+
+
+-- mReturn :: First-class m => (a -> b) -> m (a -> b)
+on mReturn(f)
+    -- 2nd class handler function lifted into 1st class script wrapper.
+    if script is class of f then
+        f
+    else
+        script
+            property |λ| : f
+        end script
+    end if
+end mReturn
+
+
+-- Egyptian multiplication - progressively doubling a list, appending
+-- stages of doubling to an accumulator where needed for binary
+-- assembly of a target length
+-- replicate :: Int -> a -> [a]
+on replicate(n, a)
+    set out to {}
+    if 1 > n then return out
+    set dbl to {a}
+
+    repeat while (1 < n)
+        if 0 < (n mod 2) then set out to out & dbl
+        set n to (n div 2)
+        set dbl to (dbl & dbl)
+    end repeat
+    return out & dbl
+end replicate
+
+
+-- showReal :: Num b => Int -> b -> String
+on showReal(n)
+    script
+        on |λ|(x)
+            set {l, r} to splitOn(".", (x as real) as string)
+            l & "." & justifyLeft(n, "0", r)
+        end |λ|
+    end script
+end showReal
+
+
+-- snd :: (a, b) -> b
+on snd(tpl)
+    if class of tpl is record then
+        |2| of tpl
+    else
+        item 2 of tpl
+    end if
+end snd
+
+
+-- splitOn :: String -> String -> [String]
+on splitOn(pat, src)
+    set {dlm, my text item delimiters} to ¬
+        {my text item delimiters, pat}
+    set xs to text items of src
+    set my text item delimiters to dlm
+    return xs
+end splitOn
+
+
+-- str :: a -> String
+on str(x)
+    x as text
+end str
+
+
+-- take :: Int -> [a] -> [a]
+-- take :: Int -> String -> String
+on take(n, xs)
+    set c to class of xs
+    if list is c then
+        if 0 < n then
+            items 1 thru min(n, length of xs) of xs
+        else
+            {}
+        end if
+    else if string is c then
+        if 0 < n then
+            text 1 thru min(n, length of xs) of xs
+        else
+            ""
+        end if
+    else if script is c then
+        set ys to {}
+        repeat with i from 1 to n
+            set v to |λ|() of xs
+            if missing value is v then
+                return ys
+            else
+                set end of ys to v
+            end if
+        end repeat
+        return ys
+    else
+        missing value
+    end if
+end take
+
+
+-- unlines :: [String] -> String
+on unlines(xs)
+    -- A single string formed by the intercalation
+    -- of a list of strings with the newline character.
+    set {dlm, my text item delimiters} to ¬
+        {my text item delimiters, linefeed}
+    set s to xs as text
+    set my text item delimiters to dlm
+    s
+end unlines
+
+
+-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+on zipWith(f, xs, ys)
+    set lng to min(length of xs, length of ys)
+    set lst to {}
+    if 1 > lng then
+        return {}
+    else
+        tell mReturn(f)
+            repeat with i from 1 to lng
+                set end of lst to |λ|(item i of xs, item i of ys)
+            end repeat
+            return lst
+        end tell
+    end if
+end zipWith

Task/Price-fraction/Arturo/price-fraction.arturo

@@ -0,0 +1,19 @@
+pricePoints: [
+    0.06 0.10       0.11 0.18       0.16 0.26       0.21 0.32
+    0.26 0.38       0.31 0.44       0.36 0.50       0.41 0.54
+    0.46 0.58       0.51 0.62       0.56 0.66       0.61 0.70
+    0.66 0.74       0.71 0.78       0.76 0.82       0.81 0.86
+    0.86 0.90       0.91 0.94       0.96 0.98       1.01 1.00
+]
+
+getPricePoint: function [price][
+    loop pricePoints [limit,correct][
+        if price < limit -> return correct
+    ]
+]
+
+tests: [0.3793 0.4425 0.0746 0.6918 0.2993 0.5486 0.7849 0.9383 0.2292]
+
+loop tests 'test [
+    print [test "=>" getPricePoint test]
+]

Task/Price-fraction/AutoHotkey/price-fraction.ahk

@@ -0,0 +1,34 @@
+; Submitted by MasterFocus --- http://tiny.cc/iTunis
+
+Loop
+{
+  InputBox, OutputVar, Price Fraction Example, Insert the value to be rounded.`n* [ 0 < value < 1 ]`n* Press ESC or Cancel to exit, , 200, 150
+  If ErrorLevel
+    Break
+  MsgBox % "Input: " OutputVar "`nResult: " PriceFraction( OutputVar )
+}
+
+;-----------------------------------------
+
+PriceFraction( p_Input )
+{
+
+  If p_Input is not float ; returns 0 if input is not a float
+    Return 0
+
+  If ( ( p_Input <= 0 ) OR ( p_Input >= 1 ) ) ; returns 0 is input is out of range
+    Return 0
+
+  ; declaring the table (arbitrary delimiters in use are '§' and '|')
+  l_List := "0.06|0.10§0.11|0.18§0.16|0.26§0.21|0.32§0.26|0.38§0.31|0.44§0.36|0.50§0.41|0.54§0.46|0.58§0.51|0.62§0.56|0.66§0.61|0.70§0.66|0.74§0.71|0.78§0.76|0.82§0.81|0.86§0.86|0.90§0.91|0.94§0.96|0.98§1.01|1.00"
+
+  Loop, Parse, l_List, § ; retrieves each field (delimited by '§')
+  {
+    StringSplit, l_Array, A_LoopField, | ; splits current field (using delimiter '|')
+    If ( p_Input <= l_Array1 )
+      Return l_Array2 ; returns the second value if input <= first value
+  }
+
+  Return 0 ; returns 0, indicating failure (shouldn't be reached though)
+
+}

Task/Price-fraction/BASIC/price-fraction.basic

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

Task/Price-fraction/BASIC256/price-fraction.basic

@@ -0,0 +1,12 @@
+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

Task/Price-fraction/BBC-BASIC/price-fraction.basic

@@ -0,0 +1,24 @@
+      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

Task/Price-fraction/Beads/price-fraction.beads

@@ -0,0 +1,37 @@
+beads 1 program 'Price fraction'
+
+record a_table
+	value
+	rescaled
+	
+const table : array of a_table = [<
+	value, rescaled
+	0.06,  0.10
+	0.11,  0.18
+	0.16,  0.26
+	0.21,  0.32
+	0.26,  0.38
+	0.31,  0.44
+	0.36,  0.50
+	0.41,  0.54
+	0.46,  0.58
+	0.51,  0.62
+	0.56,  0.66
+	0.61,  0.70
+	0.66,  0.74
+	0.71,  0.78
+	0.76,  0.82
+	0.81,  0.86
+	0.86,  0.90
+	0.91,  0.94
+	0.96,  0.98
+	1.01,  1.00 >]
+
+const a_test = [0.05 0.62 0.34 0.93 0.45]
+
+calc main_init
+	loop across:a_test val:v
+		loop across:table index:ix
+			if v < table[ix].value
+				log "{v} => {table[ix].rescaled}"
+				exit

Task/Price-fraction/Bracmat/price-fraction.bracmat

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

Task/Price-fraction/C++/price-fraction.cpp

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

Task/Price-fraction/C-sharp/price-fraction.cs

@@ -0,0 +1,53 @@
+namespace ConsoleApplication1
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            for (int x = 0; x < 10; x++)
+            {
+                Console.WriteLine("In: {0:0.00}, Out: {1:0.00}", ((double)x) / 10, SpecialRound(((double)x) / 10));
+            }
+
+            Console.WriteLine();
+
+            for (int x = 0; x < 10; x++)
+            {
+                Console.WriteLine("In: {0:0.00}, Out: {1:0.00}", ((double)x) / 10 + 0.05, SpecialRound(((double)x) / 10 + 0.05));
+            }
+
+            Console.WriteLine();
+            Console.WriteLine("In: {0:0.00}, Out: {1:0.00}", 1.01, SpecialRound(1.01));
+
+            Console.Read();
+        }
+
+        private static double SpecialRound(double inValue)
+        {
+            if (inValue > 1) return 1;
+
+            double[] Splitters = new double[] {
+                   0.00 , 0.06 , 0.11 , 0.16 , 0.21 ,
+                   0.26 , 0.31 , 0.36 , 0.41 , 0.46 ,
+                   0.51 , 0.56 , 0.61 , 0.66 , 0.71 ,
+                   0.76 , 0.81 , 0.86 , 0.91 , 0.96 };
+
+            double[] replacements = new double[] {
+                    0.10 , 0.18 , 0.26 , 0.32 , 0.38 ,
+                    0.44 , 0.50 , 0.54 , 0.58 , 0.62 ,
+                    0.66 , 0.70 , 0.74 , 0.78 , 0.82 ,
+                    0.86 , 0.90 , 0.94 , 0.98 , 1.00 };
+
+            for (int x = 0; x < Splitters.Length - 1; x++)
+            {
+                if (inValue >= Splitters[x] &&
+                    inValue < Splitters[x + 1])
+                {
+                    return replacements[x];
+                }
+            }
+
+            return inValue;
+        }
+    }
+}

Task/Price-fraction/C/price-fraction.c

@@ -0,0 +1,28 @@
+#include<stdio.h>
+
+double table[][2] = {
+	{0.06, 0.10}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32},
+	{0.26, 0.38}, {0.31, 0.44}, {0.36, 0.50}, {0.41, 0.54},
+	{0.46, 0.58}, {0.51, 0.62}, {0.56, 0.66}, {0.61, 0.70},
+	{0.66, 0.74}, {0.71, 0.78}, {0.76, 0.82}, {0.81, 0.86},
+	{0.86, 0.90}, {0.91, 0.94}, {0.96, 0.98}, {1.01, 1.00},
+	{-1, 0}, /* guarding element */
+};
+
+double price_fix(double x)
+{
+	int i;
+	for (i = 0; table[i][0] > 0; i++)
+		if (x < table[i][0]) return table[i][1];
+
+	abort(); /* what else to do? */
+}
+
+int main()
+{
+	int i;
+	for (i = 0; i <= 100; i++)
+		printf("%.2f %.2f\n", i / 100., price_fix(i / 100.));
+
+	return 0;
+}

Task/Price-fraction/Clipper/price-fraction-1.clipper

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

Task/Price-fraction/Clipper/price-fraction-2.clipper

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

Task/Price-fraction/Clojure/price-fraction.clj

@@ -0,0 +1,4 @@
+(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))))

Task/Price-fraction/Commodore-BASIC/price-fraction.basic

@@ -0,0 +1,22 @@
+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
+20 data 0.41,0.54,0.46,0.58,0.51,0.62,0.56,0.66,0.61,0.70,0.66,0.74,0.71,0.78
+30 data 0.76,0.82,0.81,0.86,0.86,0.90,0.91,0.94,0.96,0.98,1.01,1.0
+35 rem up=user price, th=threshold,            pr=price, np=new price
+40 dim th(20),pr(20):th(0)=0:pr(0)=0
+45 for i=1 to 20:read th(i),pr(i):next
+50 print chr$(147);chr$(14);"Price Fraction":print
+60 print "What is the value to calculate (between 0.0 and 1.0)";:input up
+65 if up<0 or up>1.0 then goto 60
+70 gosub 500
+80 print:print "You entered";up;chr$(157);", the new value is";np
+90 print:print "Again (Y/N)? ";
+95 get k$:if k$<>"y" and k$<>"n" then 95
+100 print k$
+110 if k$="y" then goto 50
+115 end
+500 for i=0 to 20
+510 if up<th(i) then np=pr(i):return
+520 next i
+530 np=1:return

Task/Price-fraction/Common-Lisp/price-fraction.lisp

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

Task/Price-fraction/D/price-fraction.d

@@ -0,0 +1,19 @@
+import std.stdio, std.range;
+
+double priceRounder(in double price) pure nothrow
+in {
+    assert(price >= 0 && price <= 1.0);
+} body {
+    static immutable cin  = [.06, .11, .16, .21, .26, .31, .36, .41,
+                             .46, .51, .56, .61, .66, .71, .76, .81,
+                             .86, .91, .96, 1.01],
+                     cout = [.10, .18, .26, .32, .38, .44, .50, .54,
+                             .58, .62, .66, .70, .74, .78, .82, .86,
+                             .90, .94, .98, 1.00];
+    return cout[cin.assumeSorted.lowerBound(price).length];
+}
+
+void main() {
+    foreach (const price; [0.7388727, 0.8593103, 0.826687, 0.3444635])
+        price.priceRounder.writeln;
+}

Task/Price-fraction/Eiffel/price-fraction-1.e

@@ -0,0 +1,31 @@
+class
+	APPLICATION
+
+create
+	make
+
+feature
+
+	make
+			--Tests the price_adjusted feature.
+		local
+			i: REAL
+		do
+			create price_fraction.initialize
+			from
+				i := 5
+			until
+				i = 100
+			loop
+				io.put_string ("Given: ")
+				io.put_real (i / 100)
+				io.put_string ("%TAdjusted:")
+				io.put_real (price_fraction.adjusted_price (i / 100))
+				io.new_line
+				i := i + 5
+			end
+		end
+
+	price_fraction: PRICE_FRACTION
+
+end

Task/Price-fraction/Eiffel/price-fraction-2.e

@@ -0,0 +1,41 @@
+class
+	PRICE_FRACTION
+
+create
+	initialize
+
+feature
+
+	initialize
+			-- Initializes limit and price to the given values.
+		do
+			limit := <<0.06, 0.11, 0.16, 0.21, 0.26, 0.31, 0.36, 0.41, 0.46, 0.51, 0.56, 0.61, 0.66, 0.71, 0.76, 0.81, 0.86, 0.91, 0.96, 1.01>>
+			price := <<0.10, 0.18, 0.26, 0.32, 0.38, 0.44, 0.50, 0.54, 0.58, 0.62, 0.66, 0.70, 0.74, 0.78, 0.81, 0.86, 0.90, 0.94, 0.98, 1.00>>
+		end
+
+	adjusted_price (n: REAL): REAL
+			-- Adjusted price according to the given price values.
+		local
+			i: INTEGER
+			found: BOOLEAN
+		do
+			from
+				i := 1
+			until
+				i > limit.count or found
+			loop
+				if n <= limit [i] then
+					Result := (price [i])
+					found := True
+				end
+				i := i + 1
+			end
+		end
+
+feature {NONE}
+
+	limit: ARRAY [REAL]
+
+	price: ARRAY [REAL]
+
+end

Task/Price-fraction/Elixir/price-fraction.elixir

@@ -0,0 +1,16 @@
+defmodule Price do
+  @table [ {0.06, 0.10}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32}, {0.26, 0.38},
+           {0.31, 0.44}, {0.36, 0.50}, {0.41, 0.54}, {0.46, 0.58}, {0.51, 0.62},
+           {0.56, 0.66}, {0.61, 0.70}, {0.66, 0.74}, {0.71, 0.78}, {0.76, 0.82},
+           {0.81, 0.86}, {0.86, 0.90}, {0.91, 0.94}, {0.96, 0.98}, {1.01, 1.00} ]
+
+  def fraction(value) when value in 0..1 do
+    {_, standard_value} = Enum.find(@table, fn {upper_limit, _} -> value < upper_limit end)
+    standard_value
+  end
+end
+
+val = for i <- 0..100, do: i/100
+Enum.each(val, fn x ->
+  :io.format "~5.2f ->~5.2f~n", [x, Price.fraction(x)]
+end)

Task/Price-fraction/Erlang/price-fraction.erl

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

Task/Price-fraction/Euphoria/price-fraction.euphoria

@@ -0,0 +1,20 @@
+constant table = {
+    {0.06, 0.10}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32},
+    {0.26, 0.38}, {0.31, 0.44}, {0.36, 0.50}, {0.41, 0.54},
+    {0.46, 0.58}, {0.51, 0.62}, {0.56, 0.66}, {0.61, 0.70},
+    {0.66, 0.74}, {0.71, 0.78}, {0.76, 0.82}, {0.81, 0.86},
+    {0.86, 0.90}, {0.91, 0.94}, {0.96, 0.98}, {1.01, 1.00}
+}
+
+function price_fix(atom x)
+    for i = 1 to length(table) do
+        if x < table[i][1] then
+            return table[i][2]
+        end if
+    end for
+    return -1
+end function
+
+for i = 0 to 99 do
+    printf(1, "%.2f %.2f\n", { i/100, price_fix(i/100) })
+end for

Task/Price-fraction/F-Sharp/price-fraction.fs

@@ -0,0 +1,17 @@
+let cin = [ 0.06m .. 0.05m ..1.01m ]
+let cout = [0.1m; 0.18m] @ [0.26m .. 0.06m .. 0.44m] @ [0.50m .. 0.04m .. 0.98m] @ [1.m]
+
+let priceadjuster p =
+    let rec bisect lo hi =
+        if lo < hi then
+            let mid = (lo+hi)/2.
+            let left = p < cin.[int mid]
+            bisect (if left then lo else mid+1.) (if left then mid else hi)
+        else lo
+
+    if p < 0.m || 1.m < p then p
+    else cout.[int (bisect 0. (float cin.Length))]
+
+[ 0.m .. 0.01m .. 1.m ]
+|> Seq.ofList
+|> Seq.iter (fun p -> printfn "%.2f -> %.2f" p (priceadjuster p))

Task/Price-fraction/Factor/price-fraction.factor

@@ -0,0 +1,25 @@
+CONSTANT: dispensary-data {
+{ 0.06 0.10 }
+{ 0.11 0.18 }
+{ 0.16 0.26 }
+{ 0.21 0.32 }
+{ 0.26 0.38 }
+{ 0.31 0.44 }
+{ 0.36 0.50 }
+{ 0.41 0.54 }
+{ 0.46 0.58 }
+{ 0.51 0.62 }
+{ 0.56 0.66 }
+{ 0.61 0.70 }
+{ 0.66 0.74 }
+{ 0.71 0.78 }
+{ 0.76 0.82 }
+{ 0.81 0.86 }
+{ 0.86 0.90 }
+{ 0.91 0.94 }
+{ 0.96 0.98 }
+{ 1.01 1.00 } }
+
+: price-fraction ( n -- n ) dispensary-data [ first over >= ] find 2nip second ;
+
+{ 0 0.5 0.65 0.66 1 } [ price-fraction ] map

Task/Price-fraction/Fantom/price-fraction.fantom

@@ -0,0 +1,69 @@
+class Defn // to hold the three numbers from a 'row' in the table
+{
+  Float low
+  Float high
+  Float value
+  new make (Float low, Float high, Float value)
+  {
+    this.low = low
+    this.high = high
+    this.value = value
+  }
+}
+
+class PriceConverter
+{
+  Defn[] defns := [,]
+  new make (Str table) // process given table and store numbers from each row in a defn
+  {
+    table.split('\n').each |Str line|
+    {
+      data := line.split
+      defns.add (Defn(Float.fromStr(data[1]), Float.fromStr(data[3]), Float.fromStr(data[5])))
+    }
+  }
+
+  public Float convert (Float price) // convert by looking through list of defns
+  {
+    Float result := price
+    defns.each |Defn defn|
+    {
+      if (price >= defn.low && price < defn.high)
+        result = defn.value
+    }
+    return result
+  }
+}
+
+class Main
+{
+  public static Void main ()
+  {
+    table := ">=  0.00  <  0.06  :=  0.10
+              >=  0.06  <  0.11  :=  0.18
+              >=  0.11  <  0.16  :=  0.26
+              >=  0.16  <  0.21  :=  0.32
+              >=  0.21  <  0.26  :=  0.38
+              >=  0.26  <  0.31  :=  0.44
+              >=  0.31  <  0.36  :=  0.50
+              >=  0.36  <  0.41  :=  0.54
+              >=  0.41  <  0.46  :=  0.58
+              >=  0.46  <  0.51  :=  0.62
+              >=  0.51  <  0.56  :=  0.66
+              >=  0.56  <  0.61  :=  0.70
+              >=  0.61  <  0.66  :=  0.74
+              >=  0.66  <  0.71  :=  0.78
+              >=  0.71  <  0.76  :=  0.82
+              >=  0.76  <  0.81  :=  0.86
+              >=  0.81  <  0.86  :=  0.90
+              >=  0.86  <  0.91  :=  0.94
+              >=  0.91  <  0.96  :=  0.98
+              >=  0.96  <  1.01  :=  1.00"
+    converter := PriceConverter (table)
+    10.times  // simple test with random values
+    {
+      price := (0..100).random.toFloat / 100
+      echo ("$price -> ${converter.convert (price)}")
+    }
+  }
+}

Task/Price-fraction/Forth/price-fraction-1.fth

@@ -0,0 +1,12 @@
+: as begin parse-word dup while evaluate , repeat 2drop ;
+
+create bounds   as  96 91 86 81 76 71 66 61 56 51 46 41 36 31 26 21 16 11  6  0
+create official as 100 98 94 90 86 82 78 74 70 66 62 58 54 50 44 38 32 26 18 10
+
+: official@ ( a-bounds -- +n )
+  \ (a+n) - a + b = (a+n) + (b - a) = (b+n)
+  [ official bounds - ] literal + @ ;
+
+: round ( n-cents -- n-cents' )
+  >r bounds begin dup @ r@ > while cell+ repeat
+  r> drop official@ ;

Task/Price-fraction/Forth/price-fraction-2.fth

@@ -0,0 +1,10 @@
+: ?adjust 1+ over and if 2* 15 and >r 2 - r> then ;
+: accumulate >r dup >r + r> r> ;
+: classify dup 0> if 1- then 5 / ;
+: calculate do i ?adjust accumulate loop drop drop 100 min ;
+: normalize classify >r 0 10 2 r> 1+ 0 calculate ;
+: print s>d <# # # [char] . hold #s #> type ;
+
+: test cr 101 0 ?do i print i 2 spaces normalize print cr 5 +loop ;
+
+test

Task/Price-fraction/Fortran/price-fraction-1.f

@@ -0,0 +1,19 @@
+program price_fraction
+
+  implicit none
+  integer, parameter :: i_max = 10
+  integer :: i
+  real, dimension (20), parameter :: in =                           &
+    & (/0.00, 0.06, 0.11, 0.16, 0.21, 0.26, 0.31, 0.36, 0.41, 0.46, &
+    &   0.51, 0.56, 0.61, 0.66, 0.71, 0.76, 0.81, 0.86, 0.91, 0.96/)
+  real, dimension (20), parameter :: out =                          &
+    & (/0.10, 0.18, 0.26, 0.32, 0.38, 0.44, 0.50, 0.54, 0.58, 0.62, &
+    &   0.66, 0.70, 0.74, 0.78, 0.82, 0.86, 0.90, 0.94, 0.98, 1.00/)
+  real :: r
+
+  do i = 1, i_max
+    call random_number (r)
+    write (*, '(f8.6, 1x, f4.2)') r, out (maxloc (in, r >= in))
+  end do
+
+end program price_fraction

Task/Price-fraction/Fortran/price-fraction-2.f

@@ -0,0 +1,10 @@
+0.997560 1.00
+0.566825 0.70
+0.965915 1.00
+0.747928 0.82
+0.367391 0.54
+0.480637 0.62
+0.073754 0.18
+0.005355 0.10
+0.347081 0.50
+0.342244 0.50

Task/Price-fraction/FreeBASIC/price-fraction.basic

@@ -0,0 +1,40 @@
+' FB 1.050.0 Win64
+
+Function rescale(price As Double) As Double
+  If price < 0.00 OrElse price > 1.00 Then Return price
+  Select Case price
+    Case Is < 0.06 : Return 0.10
+    Case Is < 0.11 : Return 0.18
+    Case Is < 0.16 : Return 0.26
+    Case Is < 0.21 : Return 0.32
+    Case Is < 0.26 : Return 0.38
+    Case Is < 0.31 : Return 0.44
+    Case Is < 0.36 : Return 0.50
+    Case Is < 0.41 : Return 0.54
+    Case Is < 0.46 : Return 0.58
+    Case Is < 0.51 : Return 0.62
+    Case Is < 0.56 : Return 0.66
+    Case Is < 0.61 : Return 0.70
+    Case Is < 0.66 : Return 0.74
+    Case Is < 0.71 : Return 0.78
+    Case Is < 0.76 : Return 0.82
+    Case Is < 0.81 : Return 0.86
+    Case Is < 0.86 : Return 0.90
+    Case Is < 0.91 : Return 0.94
+    Case Is < 0.96 : Return 0.98
+  End Select
+  Return 1.00
+End Function
+
+For i As Integer = 1 To 100
+  Dim d As Double = i/100.0
+  Print Using "#.##"; d;
+  Print " -> ";
+  Print Using "#.##"; rescale(d);
+  Print "  ";
+  If i Mod 5 = 0 Then Print
+Next
+
+Print
+Print "Press any key to quit"
+Sleep

Task/Price-fraction/FutureBasic/price-fraction.basic

@@ -0,0 +1,41 @@
+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
+    double d = i/100.0
+    printf @"%.2f -> %.2f\t\b", d, fn PriceFraction( d )
+    if i mod 5 == 0 then print
+  next
+end fn
+
+fn GetPriceFractions
+
+NSLog( @"%@", fn WindowPrintViewString( 1 ) )
+
+HandleEvents

Task/Price-fraction/Gambas/price-fraction.gambas

@@ -0,0 +1,14 @@
+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

Task/Price-fraction/Go/price-fraction.go

@@ -0,0 +1,55 @@
+package main
+
+import "fmt"
+
+func pf(v float64) float64 {
+    switch {
+    case v < .06:
+        return .10
+    case v < .11:
+        return .18
+    case v < .16:
+        return .26
+    case v < .21:
+        return .32
+    case v < .26:
+        return .38
+    case v < .31:
+        return .44
+    case v < .36:
+        return .50
+    case v < .41:
+        return .54
+    case v < .46:
+        return .58
+    case v < .51:
+        return .62
+    case v < .56:
+        return .66
+    case v < .61:
+        return .70
+    case v < .66:
+        return .74
+    case v < .71:
+        return .78
+    case v < .76:
+        return .82
+    case v < .81:
+        return .86
+    case v < .86:
+        return .90
+    case v < .91:
+        return .94
+    case v < .96:
+        return .98
+    }
+    return 1
+}
+
+func main() {
+    tests := []float64{0.3793, 0.4425, 0.0746, 0.6918, 0.2993,
+        0.5486, 0.7848, 0.9383, 0.2292, 0.9760}
+    for _, v := range tests {
+        fmt.Printf("%0.4f -> %0.2f\n", v, pf(v))
+    }
+}

Task/Price-fraction/Groovy/price-fraction.groovy

@@ -0,0 +1,17 @@
+def priceFraction(value) {
+    assert value >= 0.0 && value <= 1.0
+
+    def priceMappings = [(0.06): 0.10, (0.11): 0.18, (0.16): 0.26, (0.21): 0.32, (0.26): 0.38,
+         (0.31): 0.44, (0.36): 0.50, (0.41): 0.54, (0.46): 0.58, (0.51): 0.62,
+         (0.56): 0.66, (0.61): 0.70, (0.66): 0.74, (0.71): 0.78, (0.76): 0.82,
+         (0.81): 0.86, (0.86): 0.90, (0.91): 0.94, (0.96): 0.98]
+
+    for (price in priceMappings.keySet()) {
+        if (value < price) return priceMappings[price]
+    }
+    1.00
+}
+
+for (def v = 0.00; v <= 1.00; v += 0.01) {
+    println "$v --> ${priceFraction(v)}"
+}

Task/Price-fraction/Haskell/price-fraction-1.hs

@@ -0,0 +1,22 @@
+price_fraction n
+  | n < 0 || n > 1 = error "Values must be between 0 and 1."
+  | n < 0.06 = 0.10
+  | n < 0.11 = 0.18
+  | n < 0.16 = 0.26
+  | n < 0.21 = 0.32
+  | n < 0.26 = 0.38
+  | n < 0.31 = 0.44
+  | n < 0.36 = 0.50
+  | n < 0.41 = 0.54
+  | n < 0.46 = 0.58
+  | n < 0.51 = 0.62
+  | n < 0.56 = 0.66
+  | n < 0.61 = 0.70
+  | n < 0.66 = 0.74
+  | n < 0.71 = 0.78
+  | n < 0.76 = 0.82
+  | n < 0.81 = 0.86
+  | n < 0.86 = 0.90
+  | n < 0.91 = 0.94
+  | n < 0.96 = 0.98
+  | otherwise = 1.00

Task/Price-fraction/Haskell/price-fraction-2.hs

@@ -0,0 +1,10 @@
+table = [
+    (0.06, 0.10),   (0.11, 0.18),   (0.16, 0.26),   (0.21, 0.32),   (0.26, 0.38),
+    (0.31, 0.44),   (0.36, 0.50),   (0.41, 0.54),   (0.46, 0.58),   (0.51, 0.62),
+    (0.56, 0.66),   (0.61, 0.70),   (0.66, 0.74),   (0.71, 0.78),   (0.76, 0.82),
+    (0.81, 0.86),   (0.86, 0.90),   (0.91, 0.94),   (0.96, 0.98),   (1.01, 1.00),
+  ]
+
+price_fraction n
+  | n < 0 || n > 1 = error "Values must be between 0 and 1."
+  | otherwise = snd $ head $ dropWhile ((<= n) . fst) table

Task/Price-fraction/HicEst/price-fraction.hicest

@@ -0,0 +1,10 @@
+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)
+
+DO test = 1, 10
+  value = RAN(0.5, 0.5)
+  temp = value > upperbound
+  PriceFraction = rescaleTo( INDEX(temp, 0) )
+  WRITE(Format="F8.6, F6.2") value, PriceFraction
+ENDDO

Task/Price-fraction/Icon/price-fraction.icon

@@ -0,0 +1,39 @@
+record Bounds(low,high,new)
+
+# rescale given value according to a list of bounds
+procedure rescale (i, bounds)
+  every bound := !bounds do
+    if bound.low <= i < bound.high
+      then return bound.new
+  return fail # could not find i in bounds
+end
+
+procedure main ()
+  bounds := [
+    Bounds(0.00, 0.06, 0.10),
+    Bounds(0.06, 0.11, 0.18),
+    Bounds(0.11, 0.16, 0.26),
+    Bounds(0.16, 0.21, 0.32),
+    Bounds(0.21, 0.26, 0.38),
+    Bounds(0.26, 0.31, 0.44),
+    Bounds(0.31, 0.36, 0.50),
+    Bounds(0.36, 0.41, 0.54),
+    Bounds(0.41, 0.46, 0.58),
+    Bounds(0.46, 0.51, 0.62),
+    Bounds(0.51, 0.56, 0.66),
+    Bounds(0.56, 0.61, 0.70),
+    Bounds(0.61, 0.66, 0.74),
+    Bounds(0.66, 0.71, 0.78),
+    Bounds(0.71, 0.76, 0.82),
+    Bounds(0.76, 0.81, 0.86),
+    Bounds(0.81, 0.86, 0.90),
+    Bounds(0.86, 0.91, 0.94),
+    Bounds(0.91, 0.96, 0.98),
+    Bounds(0.96, 1.01, 1.00)
+  ]
+
+  # test the procedure
+  every i := 0.00 to 1.00 by 0.1 do {
+    write (i || " rescaled is " || rescale(i, bounds))
+  }
+end

Task/Price-fraction/Inform-7/price-fraction.inf

@@ -0,0 +1,37 @@
+Home is a room.
+
+Price is a kind of value. 0.99 specifies a price.
+
+Table of Price Standardization
+upper bound	replacement
+0.06		0.10
+0.11		0.18
+0.16		0.26
+0.21		0.32
+0.26		0.38
+0.31		0.44
+0.36		0.50
+0.41		0.54
+0.46		0.58
+0.51		0.62
+0.56		0.66
+0.61		0.70
+0.66		0.74
+0.71		0.78
+0.76		0.82
+0.81		0.86
+0.86		0.90
+0.91		0.94
+0.96		0.98
+1.01		1.00
+
+To decide which price is the standardized value of (P - price):
+	repeat with N running from 1 to the number of rows in the Table of Price Standardization:
+		choose row N in the Table of Price Standardization;
+		if P is less than the upper bound entry, decide on the replacement entry.
+
+When play begins:
+	repeat with N running from 1 to 5:
+		let P be a random price between 0.00 and 1.00;
+		say "[P] -> [standardized value of P].";
+	end the story.

Task/Price-fraction/J/price-fraction-1.j

@@ -0,0 +1,4 @@
+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. -

Task/Price-fraction/J/price-fraction-2.j

@@ -0,0 +1,2 @@
+   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

Task/Price-fraction/Java/price-fraction.java

@@ -0,0 +1,35 @@
+import java.util.Random;
+
+public class Main {
+	private static float priceFraction(float f) {
+		if (0.00f <= f && f < 0.06f) return 0.10f;
+		else if (f < 0.11f) return 0.18f;
+		else if (f < 0.16f) return 0.26f;
+		else if (f < 0.21f) return 0.32f;
+		else if (f < 0.26f) return 0.38f;
+		else if (f < 0.31f) return 0.44f;
+		else if (f < 0.36f) return 0.50f;
+		else if (f < 0.41f) return 0.54f;
+		else if (f < 0.46f) return 0.58f;
+		else if (f < 0.51f) return 0.62f;
+		else if (f < 0.56f) return 0.66f;
+		else if (f < 0.61f) return 0.70f;
+		else if (f < 0.66f) return 0.74f;
+		else if (f < 0.71f) return 0.78f;
+		else if (f < 0.76f) return 0.82f;
+		else if (f < 0.81f) return 0.86f;
+		else if (f < 0.86f) return 0.90f;
+		else if (f < 0.91f) return 0.94f;
+		else if (f < 0.96f) return 0.98f;
+		else if (f < 1.01f) return 1.00f;
+		else throw new IllegalArgumentException();
+	}
+
+	public static void main(String[] args) {
+		Random rnd = new Random();
+		for (int i = 0; i < 5; i++) {
+			float f = rnd.nextFloat();
+			System.out.format("%8.6f -> %4.2f%n", f, priceFraction(f));
+		}
+	}
+}

Task/Price-fraction/JavaScript/price-fraction.js

@@ -0,0 +1,8 @@
+function getScaleFactor(v) {
+
+  var values = ['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'];
+
+  return values[(v * 100 - 1) / 5 | 0];
+}

Task/Price-fraction/Jq/price-fraction-1.jq

@@ -0,0 +1,5 @@
+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 ] ;

Task/Price-fraction/Jq/price-fraction-2.jq

@@ -0,0 +1,5 @@
+def test:
+  (range(0;10)  | "0.0\(.) -> \( 0.01 * . | getScaleFactor)"),
+  (range(10;100) | "0.\(.) -> \( 0.01 * . | getScaleFactor)");
+
+test

Task/Price-fraction/Julia/price-fraction.julia

@@ -0,0 +1,15 @@
+const PFCUT = [6:5:101]//100
+const PFVAL = [10:8:26, 32:6:50, 54:4:98, 100]//100
+
+function pricefraction{T<:FloatingPoint}(a::T)
+    zero(T) <= a || error("a = ", a, ", but it must be >= 0.")
+    a <= one(T) || error("a = ", a, ", but it must be <= 1.")
+    convert(T, PFVAL[findfirst(a .< PFCUT)])
+end
+
+test = [0.:0.05:1., 0.51, 0.56, 0.61, rand(), rand(), rand(), rand()]
+
+println("Testing the price fraction function")
+for t in test
+    println(@sprintf "    %.4f -> %.4f" t pricefraction(t))
+end

Task/Price-fraction/K/price-fraction.k

@@ -0,0 +1,4 @@
+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]}'

Task/Price-fraction/Kotlin/price-fraction.kotlin

@@ -0,0 +1,34 @@
+// version 1.0.6
+
+fun rescale(price: Double): Double =
+    when {
+        price < 0.06 ->  0.10
+        price < 0.11 ->  0.18
+        price < 0.16 ->  0.26
+        price < 0.21 ->  0.32
+        price < 0.26 ->  0.38
+        price < 0.31 ->  0.44
+        price < 0.36 ->  0.50
+        price < 0.41 ->  0.54
+        price < 0.46 ->  0.58
+        price < 0.51 ->  0.62
+        price < 0.56 ->  0.66
+        price < 0.61 ->  0.70
+        price < 0.66 ->  0.74
+        price < 0.71 ->  0.78
+        price < 0.76 ->  0.82
+        price < 0.81 ->  0.86
+        price < 0.86 ->  0.90
+        price < 0.91 ->  0.94
+        price < 0.96 ->  0.98
+        else         ->  1.00
+    }
+
+fun main(args: Array<String>) {
+    var d: Double
+    for (i in 1..100) {
+        d = i / 100.0
+        print(String.format("%4.2f -> %4.2f  ", d, rescale(d)))
+        if (i % 5 == 0) println()
+    }
+}

Task/Price-fraction/Langur/price-fraction.langur

@@ -0,0 +1,31 @@
+# using an implied parameter .f ...
+val .pricefrac = f given .f {
+    case >= 0.00, < 0.06: 0.10
+    case >= 0.06, < 0.11: 0.18
+    case >= 0.11, < 0.16: 0.26
+    case >= 0.16, < 0.21: 0.32
+    case >= 0.21, < 0.26: 0.38
+    case >= 0.26, < 0.31: 0.44
+    case >= 0.31, < 0.36: 0.50
+    case >= 0.36, < 0.41: 0.54
+    case >= 0.41, < 0.46: 0.58
+    case >= 0.46, < 0.51: 0.62
+    case >= 0.51, < 0.56: 0.66
+    case >= 0.56, < 0.61: 0.70
+    case >= 0.61, < 0.66: 0.74
+    case >= 0.66, < 0.71: 0.78
+    case >= 0.71, < 0.76: 0.82
+    case >= 0.76, < 0.81: 0.86
+    case >= 0.81, < 0.86: 0.90
+    case >= 0.86, < 0.91: 0.94
+    case >= 0.91, < 0.96: 0.98
+    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)

Task/Price-fraction/Liberty-BASIC/price-fraction.basic

@@ -0,0 +1,23 @@
+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

Task/Price-fraction/Lua/price-fraction.lua

@@ -0,0 +1,22 @@
+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},
+    {0.46, 0.58}, {0.51, 0.62}, {0.56, 0.66}, {0.61, 0.70},
+    {0.66, 0.74}, {0.71, 0.78}, {0.76, 0.82}, {0.81, 0.86},
+    {0.86, 0.90}, {0.91, 0.94}, {0.96, 0.98}, {1.01, 1.00}
+}
+
+function rescale (price)
+    if price < 0 or price > 1 then return "Out of range!" end
+    for k, v in pairs(scaleTable) do
+        if price < v[1] then return v[2] end
+    end
+end
+
+math.randomseed(os.time())
+for i = 1, 5 do
+    rnd = math.random()
+    print("Random value:", rnd)
+    print("Adjusted price:", rescale(rnd))
+    print()
+end

Task/Price-fraction/M2000-Interpreter/price-fraction.m2000

@@ -0,0 +1,58 @@
+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

Task/Price-fraction/MATLAB/price-fraction.m

@@ -0,0 +1,13 @@
+  function y = rescale(x)
+	
+     L = [0,.06:.05:1.02];
+     V = [.1,.18,.26,.32,.38,.44,.50,.54,.58,.62,.66,.70,.74,.78,.82,.86,.9,.94,.98,1];
+
+     y = x;
+     for k=1:numel(x);
+        y(k) = V(sum(L<=x(k)));
+     end;
+  end;
+
+   t=0:0.001:1;
+   plot(t,rescale(t));

Task/Price-fraction/MUMPS/price-fraction.mumps

@@ -0,0 +1,11 @@
+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
+ ;to convert to are encoded in the PFRES string.
+ NEW PFMAX,PFRES,I,RESULT
+ SET PFMAX=".06^.11^.16^.21^.26^.31^.36^.41^.46^.51^.56^.61^.66^.71^.76^.81^.86^.91^.96^1.01"
+ SET PFRES=".10^.18^.26^.32^.38^.44^.50^.54^.58^.62^.66^.70^.74^.78^.82^.86^.90^.94^.98^1.00"
+ Q:(X<0)!(X>1.01) ""
+ 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

Task/Price-fraction/Maple/price-fraction.maple

@@ -0,0 +1,18 @@
+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,
+			 0.66, 0.71, 0.76, 0.81, 0.86, 0.91, 0.96, 1.01];
+	standard := [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 to numelems(standard) do
+		if price >= values[i] and price < values[i+1] then
+			newPrice := standard[i];
+		end if;
+	end do;
+	printf("%f --> %.2f\n", price, newPrice);
+end proc:
+
+randomize():
+for i to 5 do
+	priceFraction (rand(0.0..1.0)());
+end do;

Task/Price-fraction/Mathematica/price-fraction.math

@@ -0,0 +1,5 @@
+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]

Task/Price-fraction/Mercury/price-fraction-1.mercury

@@ -0,0 +1,44 @@
+:- module price.
+:- interface.
+:- import_module int.
+:- type price == int.
+:- func standard(price) = price.
+
+:- implementation.
+:- import_module require, list.
+
+standard(P) = SP :-
+        require(P >= 0, "P must be positive"),
+        Cents = P `mod` 100,
+        P + adjust(Cents) = SP.
+
+:- func adjust(int) = int.
+adjust(Cents) = adjust(Cents, rules).
+
+:- func adjust(int, list(price_rule)) = int.
+adjust(_, []) = unexpected("price", "adjust/2", "exhausted rules").
+adjust(N, [rule(Low, High, To)|T]) = R :-
+        ( N >= Low, N < High -> To - N = R ; adjust(N, T) = R ).
+
+:- type price_rule ---> rule(int, int, int).
+:- func rules = list(price_rule).
+rules = [rule(00, 06, 10),
+        rule(06, 11, 18),
+        rule(11, 16, 26),
+        rule(16, 21, 32),
+        rule(21, 26, 38),
+        rule(26, 31, 44),
+        rule(31, 36, 50),
+        rule(36, 41, 54),
+        rule(41, 46, 58),
+        rule(46, 51, 62),
+        rule(51, 56, 66),
+        rule(56, 61, 70),
+        rule(61, 66, 74),
+        rule(66, 71, 78),
+        rule(71, 76, 82),
+        rule(76, 81, 86),
+        rule(81, 86, 90),
+        rule(86, 91, 94),
+        rule(91, 96, 98),
+        rule(96, 101, 100)].

Task/Price-fraction/Mercury/price-fraction-2.mercury

@@ -0,0 +1 @@
+adjust(Cents) = array.lookup(price_table, Cents).

Task/Price-fraction/NetRexx/price-fraction.netrexx

@@ -0,0 +1,57 @@
+/* NetRexx */
+options replace format comments java crossref symbols nobinary
+
+runSample(arg)
+return
+
+-- -----------------------------------------------------------------------------
+method runSample(arg) public static
+  parse arg in_val .
+  if in_val \= '' then test_vals = [in_val]
+  else                 test_vals = getTestData()
+
+  say 'Input Adjustment'
+  loop tv = 0 to test_vals.length - 1
+    in_val = test_vals[tv]
+    adjust = priceFraction(in_val)
+    say in_val.format(null, 2).right(5) adjust.format(null, 2).right(10)
+    end tv
+
+  return
+
+-- -----------------------------------------------------------------------------
+method priceFraction(in_val) public static
+  out_val = -1
+  limit_table = getLimitTable()
+  limit_table_K = limit_table.length
+  loop p1 = 0 to limit_table_K - 1
+    pair = limit_table[p1]
+    hi_limit = pair[0]
+    adjustmt = pair[1]
+    if in_val < hi_limit then do
+      out_val = adjustmt
+      leave p1
+      end
+    end p1
+  if out_val = -1 then signal IllegalArgumentException('Input' in_val 'is outside of acceptable range.')
+
+  return out_val
+
+-- -----------------------------------------------------------------------------
+method getLimitTable() public static returns Rexx[,]
+  limit_table = [ -
+    [0.06, 0.10], [0.11, 0.18], [0.16, 0.26], [0.21, 0.32], [0.26, 0.38], -
+    [0.31, 0.44], [0.36, 0.50], [0.41, 0.54], [0.46, 0.58], [0.51, 0.62], -
+    [0.56, 0.66], [0.61, 0.70], [0.66, 0.74], [0.71, 0.78], [0.76, 0.82], -
+    [0.81, 0.86], [0.86, 0.90], [0.91, 0.94], [0.96, 0.98], [1.01, 1.00]  -
+  ]
+  return limit_table
+
+-- -----------------------------------------------------------------------------
+method getTestData() private static returns Rexx[]
+  test_vals = Rexx[5]
+  rng = Random(1024)
+  loop tv = 0 to test_vals.length - 1
+    test_vals[tv] = rng.nextFloat()
+    end tv
+  return test_vals

Task/Price-fraction/Nim/price-fraction.nim

@@ -0,0 +1,33 @@
+import random, strformat
+
+# Representation of a standard value as an int (actual value * 100).
+type StandardValue = distinct int
+
+proc `<`(a, b: StandardValue): bool {.borrow.}
+
+const Pricemap = [10, 18, 26, 32, 38, 44, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 100]
+
+
+proc toStandardValue(f: float): StandardValue =
+  ## Convert a float to a standard value (decimal value multiplied by 100).
+  ## Index: 0.01..0.05 -> 0, 0.06..0.10 -> 1, 0.11..0.15 -> 2...
+  var value = int(f * 100)
+  if value == 0: return StandardValue(10)
+  dec value
+  # Increment index every 5 of value, so value in 1..100 translates to index in 0..19.
+  let index = 2 * (value div 10) + (value mod 10) div 5
+  result = StandardValue(Pricemap[index])
+
+
+proc `$`(price: StandardValue): string =
+  ## Return the string representation of a standard value.
+  if price < StandardValue(10): "0.0" & $int(price)
+  elif price < StandardValue(100): "0." & $int(price)
+  else: "1.00"
+
+
+when isMainModule:
+  randomize()
+  for _ in 0 .. 10:
+    let price = rand(1.01)
+    echo &"Price for {price:.2f} is {price.toStandardValue()}"

Task/Price-fraction/OCaml/price-fraction-1.ocaml

@@ -0,0 +1,15 @@
+let price_fraction v =
+  if v < 0.0 || v >= 1.01 then
+    invalid_arg "price_fraction";
+  let rec aux = function
+  | (x,r)::tl ->
+      if v < x then r
+      else aux tl
+  | [] -> assert false
+  in
+  aux [
+    0.06, 0.10;   0.11, 0.18;   0.16, 0.26;   0.21, 0.32;   0.26, 0.38;
+    0.31, 0.44;   0.36, 0.50;   0.41, 0.54;   0.46, 0.58;   0.51, 0.62;
+    0.56, 0.66;   0.61, 0.70;   0.66, 0.74;   0.71, 0.78;   0.76, 0.82;
+    0.81, 0.86;   0.86, 0.90;   0.91, 0.94;   0.96, 0.98;   1.01, 1.00;
+  ]

Task/Price-fraction/OCaml/price-fraction-2.ocaml

@@ -0,0 +1,18 @@
+let () =
+  let ok_tests = [
+    (0.3793, 0.54);
+    (0.4425, 0.58);
+    (0.0746, 0.18);
+    (0.6918, 0.78);
+    (0.2993, 0.44);
+    (0.5486, 0.66);
+    (0.7848, 0.86);
+    (0.9383, 0.98);
+    (0.2292, 0.38);
+  ] in
+  Printf.printf " input   res   ok\n";
+  List.iter (fun (v,ok) ->
+    let r = price_fraction v in
+    Printf.printf " %6g  %g  %b\n" v r (r = ok);
+  ) ok_tests;
+;;

Task/Price-fraction/Objeck/price-fraction.objeck

@@ -0,0 +1,35 @@
+class PriceFraction {
+  function : Main(args : String[]) ~ Nil {
+    for(i := 0; i < 5; i++;) {
+      f := Float->Random();
+      r := SpecialRound(f);
+      "{$f} -> {$r}"->PrintLine();
+    };
+  }
+
+  function : SpecialRound(inValue : Float) ~ Float {
+    if (inValue > 1) {
+      return 1;
+    };
+
+    splitters := [
+      0.00 , 0.06 , 0.11 , 0.16 , 0.21 ,
+      0.26 , 0.31 , 0.36 , 0.41 , 0.46 ,
+      0.51 , 0.56 , 0.61 , 0.66 , 0.71 ,
+      0.76 , 0.81 , 0.86 , 0.91 , 0.96 ];
+
+    replacements := [
+      0.10 , 0.18 , 0.26 , 0.32 , 0.38 ,
+      0.44 , 0.50 , 0.54 , 0.58 , 0.62 ,
+      0.66 , 0.70 , 0.74 , 0.78 , 0.82 ,
+      0.86 , 0.90 , 0.94 , 0.98 , 1.00 ];
+
+    for(x := 0; x < splitters->Size() - 1; x+=1;) {
+      if (inValue >= splitters[x] & inValue < splitters[x + 1]) {
+        return replacements[x];
+      };
+    };
+
+    return inValue;
+  }
+}

Task/Price-fraction/Oforth/price-fraction.fth

@@ -0,0 +1,7 @@
+[.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
+
+: priceFraction(f)
+| i |
+   IN size loop: i [ f IN at(i) < ifTrue: [ OUT at(i) return ] ]
+   null ;

Task/Price-fraction/Oz/price-fraction.oz

@@ -0,0 +1,15 @@
+fun {PriceFraction X}
+   OutOfRange = {Value.failed outOfRange(X)}
+in
+   for Limit#Result in
+      [0.00#OutOfRange
+       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.5
+       0.41#0.54 0.46#0.58 0.51#0.62 0.56#0.66 0.61#0.70 0.66#0.74 0.71#0.78
+       0.76#0.82 0.81#0.86 0.86#0.90 0.91#0.94 0.96#0.98 1.01#1.00
+      ]
+      return:Return
+      default:OutOfRange
+   do
+      if X < Limit then {Return Result} end
+   end
+end

Task/Price-fraction/PARI-GP/price-fraction.parigp

@@ -0,0 +1,9 @@
+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)={
+  x*=100;
+  for(i=1,19,
+    if(x<priceLookup[i], return(priceReplace[i]))
+  );
+  "nasal demons"
+};

Task/Price-fraction/PL-I/price-fraction-1.pli

@@ -0,0 +1,14 @@
+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);
+declare r(20) fixed decimal (3,2) static initial (
+   .10, .18, .26, .32, .38, .44, .50, .54, .58, .62,
+   .66, .70, .74, .78, .82, .86, .90, .94, .98, 1);
+declare x float, d fixed decimal (3,2);
+declare i fixed binary;
+
+loop:
+   do i = 1 to 20;
+      if x < t(i) then
+         do; d = r(i); leave loop; end;
+   end;

Task/Price-fraction/PL-I/price-fraction-2.pli

@@ -0,0 +1,15 @@
+cpt: Proc Options(main);
+ Dcl x Dec Fixed(4,2);
+ Do x=0 To 1 By 0.01;
+   Put Edit(x,' -> ',cp(x))(Skip,f(4,2),a,f(4,2));
+   End;
+ cp: Proc(p) Returns(Dec Fixed(4,2));
+ Dcl r(20) Dec Fixed(4,2) static init(
+   .10, .18, .26, .32, .38, .44, .50, .54, .58, .62,
+   .66, .70, .74, .78, .82, .86, .90, .94, .98, 1);
+ Dcl p Dec Fixed(4,2);
+ Dcl i Bin Fixed;
+ i=trunc((100*p-1)/5)+1;
+ Return(r(i));
+ End;
+ End;

Task/Price-fraction/Pascal/price-fraction.pas

@@ -0,0 +1,25 @@
+Program PriceFraction(output);
+
+const
+  limit: array [1..20] of real =
+           (0.06, 0.11, 0.16, 0.21, 0.26, 0.31, 0.36, 0.41, 0.46, 0.51,
+            0.56, 0.61, 0.66, 0.71, 0.76, 0.81, 0.86, 0.91, 0.96, 1.01);
+  price: array [1..20] of real =
+           (0.10, 0.18, 0.26, 0.32, 0.38, 0.44, 0.50, 0.54, 0.58, 0.62,
+            0.66, 0.70, 0.74, 0.78, 0.81, 0.86, 0.90, 0.94, 0.98, 1.00);
+
+var
+  cost: real;
+  i, j: integer;
+
+begin
+  randomize;
+  for i := 1 to 10 do
+  begin
+    cost := random;
+    j := high(limit);
+    while cost < limit[j] do
+      dec(j);
+    writeln (cost:6:4, ' -> ', price[j+1]:4:2);
+  end;
+end.

Task/Price-fraction/Perl/price-fraction.pl

@@ -0,0 +1,36 @@
+my @table = map [ /([\d\.]+)/g ], split "\n", <<'TBL';
+>=  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
+TBL
+
+sub convert {
+        my $money = shift;
+        for (@table) {
+                return $_->[2] if $_->[0] <= $money and $_->[1] > $money
+        }
+        die "Can't find currency conversion for $money. Counterfeit?"
+}
+
+# try it out
+for (1 .. 10) {
+        my $m = rand(1);
+        printf "%.3f -> %g\n", $m, convert($m);
+}

Task/Price-fraction/Phix/price-fraction.phix

@@ -0,0 +1,48 @@
+(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;">"""
+ &gt;=  0.00  &lt;  0.06  :=  0.10
+ &gt;=  0.06  &lt;  0.11  :=  0.18
+ &gt;=  0.11  &lt;  0.16  :=  0.26
+ &gt;=  0.16  &lt;  0.21  :=  0.32
+ &gt;=  0.21  &lt;  0.26  :=  0.38
+ &gt;=  0.26  &lt;  0.31  :=  0.44
+ &gt;=  0.31  &lt;  0.36  :=  0.50
+ &gt;=  0.36  &lt;  0.41  :=  0.54
+ &gt;=  0.41  &lt;  0.46  :=  0.58
+ &gt;=  0.46  &lt;  0.51  :=  0.62
+ &gt;=  0.51  &lt;  0.56  :=  0.66
+ &gt;=  0.56  &lt;  0.61  :=  0.70
+ &gt;=  0.61  &lt;  0.66  :=  0.74
+ &gt;=  0.66  &lt;  0.71  :=  0.78
+ &gt;=  0.71  &lt;  0.76  :=  0.82
+ &gt;=  0.76  &lt;  0.81  :=  0.86
+ &gt;=  0.81  &lt;  0.86  :=  0.90
+ &gt;=  0.86  &lt;  0.91  :=  0.94
+ &gt;=  0.91  &lt;  0.96  :=  0.98
+ &gt;=  0.96  &lt;  1.01  :=  1.00"""</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\n'</span><span style="color: #0000FF;">)</span>
+
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">limits</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">},</span>
+          <span style="color: #000000;">prices</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}</span>
+ <span style="color: #004080;">atom</span> <span style="color: #000000;">pl</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">plt</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">price</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">TBL</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+     <span style="color: #0000FF;">{</span><span style="color: #000000;">pl</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">price</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">TBL</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"&gt;=  %.2f  &lt;  %.2f  :=  %.2f"</span><span style="color: #0000FF;">)[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
+     <span style="color: #7060A8;">assert</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pl</span><span style="color: #0000FF;">==</span><span style="color: #000000;">plt</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">plt</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">lt</span>
+     <span style="color: #000000;">limits</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">limits</span><span style="color: #0000FF;">,</span><span style="color: #000000;">lt</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">prices</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">prices</span><span style="color: #0000FF;">,</span><span style="color: #000000;">price</span><span style="color: #0000FF;">)</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">price_fix</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">limits</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">p</span><span style="color: #0000FF;"><</span><span style="color: #000000;">limits</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
+             <span style="color: #008080;">return</span> <span style="color: #000000;">prices</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">101</span> <span style="color: #008080;">do</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"%5.2f %5.2f\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">/</span><span style="color: #000000;">100</span><span style="color: #0000FF;">,</span><span style="color: #000000;">price_fix</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">/</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+<!--

Task/Price-fraction/Phixmonti/price-fraction.phixmonti

@@ -0,0 +1,41 @@
+include ..\Utilitys.pmt
+
+(
+( 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 ) )
+
+def price_fix
+    var p
+    len for
+        get
+        3 get swap 1 get swap 2 get nip
+        p swap < swap p swap >=
+        and if
+            exitfor
+        else
+            drop
+        endif
+    endfor
+enddef
+
+( 0.00 1.01 0.01 ) for
+    dup print 9 tochar print price_fix print nl
+endfor

Task/Price-fraction/Picat/price-fraction-1.picat

@@ -0,0 +1,37 @@
+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.

Task/Price-fraction/Picat/price-fraction-2.picat

@@ -0,0 +1,32 @@
+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).

Task/Price-fraction/PicoLisp/price-fraction.l

@@ -0,0 +1,31 @@
+(scl 2)
+
+(de price (Pr)
+   (format
+      (cdr
+         (rank Pr
+            (quote
+               (0.00 . 0.10)
+               (0.06 . 0.18)
+               (0.11 . 0.26)
+               (0.16 . 0.32)
+               (0.21 . 0.38)
+               (0.26 . 0.44)
+               (0.31 . 0.50)
+               (0.36 . 0.54)
+               (0.41 . 0.58)
+               (0.46 . 0.62)
+               (0.51 . 0.66)
+               (0.56 . 0.70)
+               (0.61 . 0.74)
+               (0.66 . 0.78)
+               (0.71 . 0.82)
+               (0.76 . 0.86)
+               (0.81 . 0.90)
+               (0.86 . 0.94)
+               (0.91 . 0.98)
+               (0.96 . 1.00) ) ) )
+      *Scl ) )
+
+(for N (0.3793 0.4425 0.0746 0.6918 0.2993 0.5486 0.7848 0.9383 0.2292)
+   (prinl (price N)) )

Task/Price-fraction/PowerShell/price-fraction-1.psh

@@ -0,0 +1,45 @@
+function Convert-PriceFraction
+{
+    [CmdletBinding()]
+    [OutputType([double])]
+    Param
+    (
+        [Parameter(Mandatory=$true,
+                   ValueFromPipeline=$true,
+                   ValueFromPipelineByPropertyName=$true,
+                   Position=0)]
+        [ValidateScript({$_ -ge 0.0 -and $_ -le 1.0})]
+        [double]
+        $InputObject
+    )
+
+    Process
+    {
+        foreach ($fraction in $InputObject)
+        {
+            switch ($fraction)
+            {
+                {$_ -lt 0.06} {0.10; break}
+                {$_ -lt 0.11} {0.18; break}
+                {$_ -lt 0.16} {0.26; break}
+                {$_ -lt 0.21} {0.32; break}
+                {$_ -lt 0.26} {0.38; break}
+                {$_ -lt 0.31} {0.44; break}
+                {$_ -lt 0.36} {0.50; break}
+                {$_ -lt 0.41} {0.54; break}
+                {$_ -lt 0.46} {0.58; break}
+                {$_ -lt 0.51} {0.62; break}
+                {$_ -lt 0.56} {0.66; break}
+                {$_ -lt 0.61} {0.70; break}
+                {$_ -lt 0.66} {0.74; break}
+                {$_ -lt 0.71} {0.78; break}
+                {$_ -lt 0.76} {0.82; break}
+                {$_ -lt 0.81} {0.86; break}
+                {$_ -lt 0.86} {0.90; break}
+                {$_ -lt 0.91} {0.94; break}
+                {$_ -lt 0.96} {0.98; break}
+                Default       {1.00}
+            }
+        }
+    }
+}

Task/Price-fraction/PowerShell/price-fraction-2.psh

@@ -0,0 +1 @@
+.7388727, .8593103, .826687, .3444635, .0491907 | Convert-PriceFraction | ForEach-Object {"{0:C}" -f $_}

Task/Price-fraction/PureBasic/price-fraction.basic

@@ -0,0 +1,63 @@
+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

Task/Price-fraction/Python/price-fraction-1.py

@@ -0,0 +1,5 @@
+>>> 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) ]

Task/Price-fraction/Python/price-fraction-2.py

@@ -0,0 +1,5 @@
+>>> 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) ]

Task/Price-fraction/Python/price-fraction-3.py

@@ -0,0 +1,20 @@
+def bisect_right(a, x, lo=0, hi=None):
+    """Return the index where to insert item x in list a, assuming a is sorted.
+
+    The return value i is such that all e in a[:i] have e <= x, and all e in
+    a[i:] have e > x.  So if x already appears in the list, a.insert(x) will
+    insert just after the rightmost x already there.
+
+    Optional args lo (default 0) and hi (default len(a)) bound the
+    slice of a to be searched.
+    """
+
+    if lo < 0:
+        raise ValueError('lo must be non-negative')
+    if hi is None:
+        hi = len(a)
+    while lo < hi:
+        mid = (lo+hi)//2
+        if x < a[mid]: hi = mid
+        else: lo = mid+1
+    return lo

Task/Price-fraction/Quackery/price-fraction.quackery

@@ -0,0 +1,29 @@
+[ $ 'bigrat.qky' loadfile ] now!
+
+[ 2over 2over v< if 2swap 2drop ] is vmax  ( n/d n/d --> n/d )
+
+[ 100 1 v* 1 1 v-
+  0 1 vmax 5 1 v/ /
+  [ table
+    10 18 26 32 38
+    44 50 54 58 62
+    66 70 74 78 82
+    86 90 94 98 100 ] 100 ]       is scale ( n/d     --> n/d )
+
+[ swap echo sp echo ]             is br    ( n/d     -->     )
+
+[ 2dup br say ' --> '
+  scale br cr ]                   is test  ( n/d     -->     )
+
+0 100 test
+50 100 test
+65 100 test
+66 100 test
+100 100 test
+7368 10000 test
+
+( Show how to enter and display results as a decimal too. )
+$ '0.7368' dup echo$
+say ' --> '
+$->v drop scale
+2 point$ echo$

Task/Price-fraction/R/price-fraction-1.r

@@ -0,0 +1,11 @@
+price_fraction <- function(x)
+{
+  stopifnot(all(x >= 0 & x <= 1))
+  breaks <- seq(0.06, 1.01, 0.05)
+  values <- c(.1, .18, .26, .32, .38, .44, .5, .54, .58, .62, .66, .7, .74, .78, .82, .86, .9, .94, .98, 1)
+  indices <- sapply(x, function(x) which(x < breaks)[1])
+  values[indices]
+}
+
+#Example usage:
+price_fraction(c(0, .01, 0.06, 0.25, 1))                # 0.10 0.10 0.18 0.38 1.00

Task/Price-fraction/R/price-fraction-2.r

@@ -0,0 +1,23 @@
+dfr <- read.table(tc <- textConnection(
+">=  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")); close(tc)
+breaks <- dfr$V4
+values <- dfr$V6

Task/Price-fraction/REXX/price-fraction-1.rexx

@@ -0,0 +1,33 @@
+/*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 */
+          if j==0  then j= 0.00                  /*handle the special case of zero cents*/
+          say pad  'original price ──►'    j   pad   adjPrice(j)     " ◄── adjusted price"
+          end   /*j*/
+exit 0                                           /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+adjPrice: procedure;  parse arg ?                /*a table is used to facilitate changes*/
+                                     select
+                                     when ?<0.06  then ?= 0.10
+                                     when ?<0.11  then ?= 0.18
+                                     when ?<0.16  then ?= 0.26
+                                     when ?<0.21  then ?= 0.32
+                                     when ?<0.26  then ?= 0.38
+                                     when ?<0.31  then ?= 0.44
+                                     when ?<0.36  then ?= 0.50
+                                     when ?<0.41  then ?= 0.54
+                                     when ?<0.46  then ?= 0.58
+                                     when ?<0.51  then ?= 0.62
+                                     when ?<0.56  then ?= 0.66
+                                     when ?<0.61  then ?= 0.70
+                                     when ?<0.66  then ?= 0.74
+                                     when ?<0.71  then ?= 0.78
+                                     when ?<0.76  then ?= 0.82
+                                     when ?<0.81  then ?= 0.86
+                                     when ?<0.86  then ?= 0.90
+                                     when ?<0.91  then ?= 0.94
+                                     when ?<0.96  then ?= 0.98
+                                     when ?<1.01  then ?= 1.00
+                                     otherwise    nop
+                                     end   /*select*/
+          return ?

Task/Price-fraction/REXX/price-fraction-2.rexx

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

Task/Price-fraction/Racket/price-fraction.rkt

@@ -0,0 +1,11 @@
+#lang racket
+
+(define table
+  '([0 #f]
+    [0.06 0.10] [0.11 0.18] [0.16 0.26] [0.21 0.32] [0.26 0.38] [0.31 0.44]
+    [0.36 0.50] [0.41 0.54] [0.46 0.58] [0.51 0.62] [0.56 0.66] [0.61 0.70]
+    [0.66 0.74] [0.71 0.78] [0.76 0.82] [0.81 0.86] [0.86 0.90] [0.91 0.94]
+    [0.96 0.98] [1.01 1.00])
+
+  ;; returns #f for negatives or values >= 1.01
+(define (convert x) (for/or ([c table]) (and (< x (car c)) (cadr c))))

Task/Price-fraction/Raku/price-fraction-1.raku

@@ -0,0 +1,26 @@
+sub price-fraction ($n where 0..1) {
+    when $n < 0.06 { 0.10 }
+    when $n < 0.11 { 0.18 }
+    when $n < 0.16 { 0.26 }
+    when $n < 0.21 { 0.32 }
+    when $n < 0.26 { 0.38 }
+    when $n < 0.31 { 0.44 }
+    when $n < 0.36 { 0.50 }
+    when $n < 0.41 { 0.54 }
+    when $n < 0.46 { 0.58 }
+    when $n < 0.51 { 0.62 }
+    when $n < 0.56 { 0.66 }
+    when $n < 0.61 { 0.70 }
+    when $n < 0.66 { 0.74 }
+    when $n < 0.71 { 0.78 }
+    when $n < 0.76 { 0.82 }
+    when $n < 0.81 { 0.86 }
+    when $n < 0.86 { 0.90 }
+    when $n < 0.91 { 0.94 }
+    when $n < 0.96 { 0.98 }
+    default        { 1.00 }
+}
+
+while prompt("value: ") -> $value {
+    say price-fraction(+$value);
+}