Price fraction: Difference between revisions

{{trans|Python}}

 

V lo = 0

V hi = a.len

 

L(i) 0..10

 

{{out}}

 

=={{header|Action!}}==

BYTE ARRAY levels=[6 11 16 21 26 31 36 41 46 51 56 61 66 71 76 81 86 91 96 101]

BYTE ARRAY values=[10 18 26 32 38 44 50 54 58 62 66 70 74 78 82 86 90 94 98 100]

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Price_fraction.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

type Price is delta 0.01 digits 3 range 0.0..1.0;

function Scale (Value : Price) return Price is

end loop;

end Scale;

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

with Ada.Text_IO; use Ada.Text_IO;

procedure Test_Price_Fraction is

end loop;

end Test_Price_Fraction;

{{out}}

<div style="height: 200px;overflow:scroll">

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

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

(

# Just get a random price between 0 and 1 #

 

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

{{out}}

<pre>

The task description doesn't make a lot of sense, implying that the pharmacist charges no more than 1.00 for his wares and that even whole-number prices are nudged by 0.10 and odd ones aren't. This offering takes any decimal currency value and standardises just the fractional part:

 

 

on standardisePrice(input)

set output to linefeed & "Originals: " & originals & linefeed & "Standardised: " & standardised

set AppleScript's text item delimiters to astid

 

{{output}}

Originals: 0.49, 0.79, 1.00, 0.83, 0.99, 0.23, 0.12, 0.28, 0.72, 0.37, 0.95, 0.51, 0.43, 0.52, 0.84, 0.89, 0.48, 0.48, 0.30, 0.01

 

An alternative that would save editing the handler in the event of the government department changing its directive would be to feed it a conversion table of up-to and standardised prices stored elsewhere.

 

 

on standardisePrice(input, table)

set output to linefeed & "Originals: " & originals & linefeed & "Standardised: " & standardised

set AppleScript's text item delimiters to astid

 

{{output}}

Originals: 0.92, 0.86, 0.10, 0.40, 0.00, 0.34, 0.44, 0.77, 0.67, 0.19, 1.00, 0.02, 0.49, 0.40, 0.61, 0.91, 0.85, 0.54, 0.01, 0.04

 

===Functional===

 

property table : [¬

end tell

end if

{{Out}}

<pre>Price adjustments:

=={{header|Arturo}}==

 

0.06 0.10 0.11 0.18 0.16 0.26 0.21 0.32

0.26 0.38 0.31 0.44 0.36 0.50 0.41 0.54

loop tests 'test [

print [test "=>" getPricePoint test]

 

{{out}}

 

=={{header|AutoHotkey}}==

 

Loop

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

 

 

=={{header|AWK}}==

BEGIN {

O = ".06 .11 .16 .21 .26 .31 .36 .41 .46 .51 .56 .61 .66 .71 .76 .81 .86 .91 .96 1.01"

}

}

 

=={{header|BASIC}}==

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

 

 

RANDOMIZE TIMER

PriceFraction! = price

END SELECT

 

{{out}} (run 5 times):

We'll use a couple of arrays for translation. Should work for several other 8-bit BASICs after converting the screen control codes.

 

2 rem rosetta code

10 data 0.06,0.1,0.11,0.18,0.16,0.26,0.21,0.32,0.26,0.38,0.31,0.44,0.36,0.5

520 next i

530 np=1:return

 

{{out}}

=={{header|BASIC256}}==

{{trans|Gambas}}

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}

if byCount mod 5 = 0 then print

next byCount

 

=={{header|BBC BASIC}}==

END

IF p < 0.91 THEN = 0.94

IF p < 0.96 THEN = 0.98

 

=={{header|Beads}}==

 

record a_table

if v < table[ix].value

log "{v} => {table[ix].rescaled}"

{{out}}

<pre>0.05 => 0.1

=={{header|Bracmat}}==

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

=

. ("0.06"."0.10")

& out$(!a "-->" convert$!a)

)

{{out}}

<pre>0.00 --> 0.10

 

=={{header|C}}==

 

double table[][2] = {

 

return 0;

 

=={{header|C sharp|C#}}==

{

class Program

}

}

 

=={{header|C++}}==

#include <cmath>

 

return 0 ;

}

 

{{out}}

 

=={{header|Clipper}}==

LOCAL aPriceFraction := { {0,.06,.1},;

{.06,.11,.18}, ;

nResult := aPriceFraction[ nScan ][ 3 ]

END IF

 

The function above crashes with an array access bound error if the value passed is negative.

The following is a more concise solution:

 

Local i

For i := -0.02 to 1.02 STEP 0.03

nResult := NIL

Endif

 

{{out}}

=={{header|Clojure}}==

{{trans|JavaScript}}

 

(defn price [v]

 

 

 

=={{header|Common Lisp}}==

(cond ((minusp value) (error "invalid value: ~A" value))

((< value 0.06) 0.10)

((< value 0.96) 0.98)

((< value 1.01) 1.00)

 

=={{header|D}}==

 

double priceRounder(in double price) pure nothrow

foreach (const price; [0.7388727, 0.8593103, 0.826687, 0.3444635])

price.priceRounder.writeln;

{{out}}

<pre>0.82

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

class

PRICE_FRACTION

 

end

{{out}}

<pre>

 

=={{header|Elixir}}==

@table [ {0.06, 0.10}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32}, {0.26, 0.38},

{0.31, 0.44}, {0.36, 0.50}, {0.41, 0.54}, {0.46, 0.58}, {0.51, 0.62},

Enum.each(val, fn x ->

:io.format "~5.2f ->~5.2f~n", [x, Price.fraction(x)]

 

{{out}}

 

=={{header|Erlang}}==

erlang:error('Values must be between 0 and 1.');

priceFraction(N) when N < 0.06 -> 0.10;

priceFraction(N) when N < 0.91 -> 0.94;

priceFraction(N) when N < 0.96 -> 0.98;

 

=={{header|Euphoria}}==

{{trans|C}}

{0.06, 0.10}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32},

{0.26, 0.38}, {0.31, 0.44}, {0.36, 0.50}, {0.41, 0.54},

for i = 0 to 99 do

printf(1, "%.2f %.2f\n", { i/100, price_fix(i/100) })

 

=={{header|F_Sharp|F#}}==

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

let cout = [0.1m; 0.18m] @ [0.26m .. 0.06m .. 0.44m] @ [0.50m .. 0.04m .. 0.98m] @ [1.m]

 

[ 0.m .. 0.01m .. 1.m ]

|> Seq.ofList

{{out}}

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

 

=={{header|Factor}}==

{ 0.06 0.10 }

{ 0.11 0.18 }

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

 

 

{{out}}

=={{header|Fantom}}==

 

class Defn // to hold the three numbers from a 'row' in the table

{

}

}

 

=={{header|Forth}}==

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

 

 

create bounds as 96 91 86 81 76 71 66 61 56 51 46 41 36 31 26 21 16 11 6 0

: round ( n-cents -- n-cents' )

>r bounds begin dup @ r@ > while cell+ repeat

This one is done in the spirit of "Thinking Forth" and doesn't use any tables at all.

: accumulate >r dup >r + r> r> ;

: classify dup 0> if 1- then 5 / ;

: test cr 101 0 ?do i print i 2 spaces normalize print cr 5 +loop ;

 

Output:

<pre>

=={{header|Fortran}}==

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

 

implicit none

end do

 

{{out}}

0.566825 0.70

0.965915 1.00

0.005355 0.10

0.347081 0.50

 

=={{header|FreeBASIC}}==

 

Function rescale(price As Double) As Double

Print

Print "Press any key to quit"

 

{{out}}

=={{header|Gambas}}==

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

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]

Next

 

Output:

<pre>

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf("%0.4f -> %0.2f\n", v, pf(v))

}

 

<pre>

 

=={{header|Groovy}}==

assert value >= 0.0 && value <= 1.0

 

for (def v = 0.00; v <= 1.00; v += 0.01) {

println "$v --> ${priceFraction(v)}"

{{out}}

<div style="height: 200px;overflow:scroll">

 

=={{header|Haskell}}==

| n < 0 || n > 1 = error "Values must be between 0 and 1."

| n < 0.06 = 0.10

| n < 0.91 = 0.94

| n < 0.96 = 0.98

Alternative {{trans|OCaml}}:

(0.06, 0.10), (0.11, 0.18), (0.16, 0.26), (0.21, 0.32), (0.26, 0.38),

(0.31, 0.44), (0.36, 0.50), (0.41, 0.54), (0.46, 0.58), (0.51, 0.62),

price_fraction n

| n < 0 || n > 1 = error "Values must be between 0 and 1."

 

=={{header|HicEst}}==

upperbound = (.06,.11,.16,.21,.26,.31,.36,.41,.46,.51,.56,.61,.66,.71,.76,.81,.86,.91,.96,1.01)

rescaleTo = (.10,.18,.26,.32,.38,.44,.50,.54,.58,.62,.66,.70,.74,.78,.82,.86,.90,.94,.98,1.00)

PriceFraction = rescaleTo( INDEX(temp, 0) )

WRITE(Format="F8.6, F6.2") value, PriceFraction

<pre>0.589230 0.70

0.017623 0.10

=={{header|Icon}} and {{header|Unicon}}==

 

record Bounds(low,high,new)

 

}

end

 

{{out}}

Inform doesn't have native floating-point support; this version uses fixed point numbers with two decimal places.

 

 

Price is a kind of value. 0.99 specifies a price.

let P be a random price between 0.00 and 1.00;

say "[P] -> [standardized value of P].";

 

=={{header|J}}==

'''Solution:'''

out =: 1.00 0.98 0.94 0.90 0.86 0.82 0.78 0.74 0.70 0.66 0.62 0.58 0.54 0.50 0.44 0.38 0.32 0.26 0.18 0.1

 

 

'''Example:'''

 

This implementation performs a binary search on the boundary values, and then uses the resulting index to select from the result values.

 

=={{header|Java}}==

 

public class Main {

}

}

{{out}}

<pre>0.149969 -> 0.26

Passing a value outside the range 0 <= x < 1.01 will return undefined.

 

 

var values = ['0.10','0.18','0.26','0.32','0.38','0.44','0.50','0.54',

 

return values[(v * 100 - 1) / 5 | 0];

 

=={{header|jq}}==

The solution given here is based on the JavaScript solution.

["0.10","0.18","0.26","0.32","0.38","0.44","0.50","0.54",

"0.58","0.62","0.66","0.70","0.74","0.78","0.82","0.86",

"0.90","0.94","0.98","1.00"] as $values

The full coverage test as given in the Ada example:

(range(0;10) | "0.0\(.) -> \( 0.01 * . | getScaleFactor)"),

(range(10;100) | "0.\(.) -> \( 0.01 * . | getScaleFactor)");

 

Run the test, showing the first few lines of output:

<pre>

=={{header|Julia}}==

This solution is somewhat straightforward but does highlight a couple of Julia features. The interval cut-offs and values are exactly represented by rational numbers. The interval to which an input value belongs is identified by applying the <code>findfirst</code> (true value) function to an element-wise comparison (<code>.&lt;</code>) of this value to the cut-off array.

const PFCUT = [6:5:101]//100

const PFVAL = [10:8:26, 32:6:50, 54:4:98, 100]//100

println(@sprintf " %.4f -> %.4f" t pricefraction(t))

end

 

{{out}}

Translation of the J solution:

 

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]}'

{{out}}

<pre>

 

=={{header|Kotlin}}==

 

fun rescale(price: Double): Double =

if (i % 5 == 0) println()

}

 

{{out}}

Langur uses decimal floating point.

 

val .pricefrac = f given .f {

case >= 0.00, < 0.06: 0.10

 

writeln .pricefrac(0.17)

 

{{out}}

 

=={{header|Liberty BASIC}}==

dim DR(38) 'decimal range

dim PF(38) 'corresponding price fraction

next

end function

 

=={{header|Lua}}==

{0.06, 0.10}, {0.11, 0.18}, {0.16, 0.26}, {0.21, 0.32},

{0.26, 0.38}, {0.31, 0.44}, {0.36, 0.50}, {0.41, 0.54},

print("Adjusted price:", rescale(rnd))

print()

{{out}}

<pre>Random value: 0.61946413522022

 

=={{header|Maple}}==

local values, standard, newPrice, i;

values := [0, 0.06, 0.11, 0.16, 0.21, 0.26, 0.31, 0.36, 0.41, 0.46, 0.51, 0.56, 0.61,

for i to 5 do

priceFraction (rand(0.0..1.0)());

{{out}}

<pre>0.524386 --> 0.66

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{.32, x < .21}, {.38, x < .26}, {.44, x < 0.31}, {.5, x < .36},

{.54, x < .41}, {.58, x < .46}, {.62, x < .51}, {.66, x < .56},

{.70, x < .61}, {.74, x < .66}, {.78, x < .71}, {.82, x < .76},

 

=={{header|MATLAB}} / {{header|Octave}}==

 

L = [0,.06:.05:1.02];

 

t=0:0.001:1;

 

=={{header|Mercury}}==

:- interface.

:- import_module int.

rule(86, 91, 94),

rule(91, 96, 98),

 

A build system might turn the text of the table into the definition of a hundred-element array of adjustments. In that case,

 

 

=={{header|MUMPS}}==

;Outputs a specified value dependent upon the input value

;The non-inclusive upper limits are encoded in the PFMAX string, and the values

FOR I=1:1:$LENGTH(PFMAX,"^") Q:($DATA(RESULT)'=0) SET:X<$P(PFMAX,"^",I) RESULT=$P(PFRES,"^",I)

KILL PFMAX,PFRES,I

{{out}}

<pre>USER>W $$PRICFRAC^ROSETTA(.04)

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

end tv

return test_vals

{{out}}

<pre>

 

=={{header|Nim}}==

 

# Representation of a standard value as an int (actual value * 100).

for _ in 0 .. 10:

let price = rand(1.01)

{{out}}

A random output looking something like this:

=={{header|Objeck}}==

{{trans|C#}}

function : Main(args : String[]) ~ Nil {

for(i := 0; i < 5; i++;) {

return inValue;

}

 

{{output}}

=={{header|OCaml}}==

 

if v < 0.0 || v >= 1.01 then

invalid_arg "price_fraction";

0.56, 0.66; 0.61, 0.70; 0.66, 0.74; 0.71, 0.78; 0.76, 0.82;

0.81, 0.86; 0.86, 0.90; 0.91, 0.94; 0.96, 0.98; 1.01, 1.00;

 

let ok_tests = [

(0.3793, 0.54);

Printf.printf " %6g %g %b\n" v r (r = ok);

) ok_tests;

 

=={{header|Oforth}}==

 

[.10, .18, .26, .32, .38, .44, .50, .54, .58, .62, .66, .70, .74, .78, .82, .86, .90, .94, .98, 1.00] const: OUT

 

| i |

IN size loop: i [ f IN at(i) < ifTrue: [ OUT at(i) return ] ]

 

{{Out}}

i.e. a value that throws an exception when it is accessed.

 

OutOfRange = {Value.failed outOfRange(X)}

in

if X < Limit then {Return Result} end

end

 

=={{header|PARI/GP}}==

priceReplace=[10,18,26,32,38,44,50,54,58,62,66,70,74,78,82,86,90,94,98,100];

pf(x)={

);

"nasal demons"

 

=={{header|Pascal}}==

 

const

writeln (cost:6:4, ' -> ', price[j+1]:4:2);

end;

{{out}}

<pre>% ./PriceFraction

 

=={{header|Perl}}==

>= 0.00 < 0.06 := 0.10

>= 0.06 < 0.11 := 0.18

printf "%.3f -> %g\n", $m, convert($m);

}

 

=={{header|Phix}}==

<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;">"""

<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>

 

=={{header|Phixmonti}}==

 

(

dup print 9 tochar print price_fix print nl

endfor

 

=={{header|Picat}}==

===Approach 1===

_ = random2(),

D = [

 

% Getting numbers of precision 2

 

{{out}}

 

===Using a fact table===

_ = random2(),

foreach(_ in 1..10)

r(0.86,0.91,0.94).

r(0.91,0.96,0.98).

 

{{out}}

 

=={{header|PicoLisp}}==

 

(de price (Pr)

 

(for N (0.3793 0.4425 0.0746 0.6918 0.2993 0.5486 0.7848 0.9383 0.2292)

{{out}}

<pre>0.54

=={{header|PL/I}}==

===version 1===

.06, .11, .16, .21, .26, .31, .36, .41, .46, .51,

.56, .61, .66, .71, .76, .81, .86, .91, .96, 1.01);

if x < t(i) then

do; d = r(i); leave loop; end;

 

===version 2===

{{trans|REXX version2}}

Dcl x Dec Fixed(4,2);

Do x=0 To 1 By 0.01;

Return(r(i));

End;

 

=={{header|PowerShell}}==

function Convert-PriceFraction

{

}

}

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

{{Out}}

<pre>

 

=={{header|PureBasic}}==

;returns price unchanged if value is invalid

Protected fraction

Input()

CloseConsole()

{{out}}

<pre>0.3793 -> 0.54

Using the [http://docs.python.org/library/bisect.html bisect] standard module to reduce the comparisons with members of the cin array.

 

>>> _cin = [.06, .11, .16, .21, .26, .31, .36, .41, .46, .51, .56, .61, .66, .71, .76, .81, .86, .91, .96, 1.01]

>>> _cout = [.10, .18, .26, .32, .38, .44, .50, .54, .58, .62, .66, .70, .74, .78, .82, .86, .90, .94, .98, 1.00]

>>> def pricerounder(pricein):

 

When dealing with money it is good to think about possible loss of precision. If we change the units to be integer cents we could use the following exact routine:

>>> _cin = [ 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81, 86, 91, 96, 101]

>>> _cout = [10, 18, 26, 32, 38, 44, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 100]

>>> def centsrounder(centsin):

Other options are to use the fractions or decimals modules for calculating money to a known precision.

 

<br>'''Bisection library code'''<br>

:The <code>bisect</code> Python standard library function uses the following code that improves on a simple linear scan through a sorted list:

"""Return the index where to insert item x in list a, assuming a is sorted.

 

if x < a[mid]: hi = mid

else: lo = mid+1

 

=={{header|Quackery}}==

This program uses the bignum rationals provided by <code>bigrat.qky</code>, so it avoids the pitfalls of storing money as floating point numbers.

 

[ 2over 2over v< if 2swap 2drop ] is vmax ( n/d n/d --> n/d )

say ' --> '

$->v drop scale

{{out}}

<pre>

 

=={{header|R}}==

price_fraction <- function(x)

{

#Example usage:

price_fraction(c(0, .01, 0.06, 0.25, 1)) # 0.10 0.10 0.18 0.38 1.00

 

You can extract the contents of the table as follows:

 

dfr <- read.table(tc <- textConnection(

">= 0.00 < 0.06 := 0.10

breaks <- dfr$V4

values <- dfr$V6

 

=={{header|Racket}}==

 

#lang racket

 

;; returns #f for negatives or values >= 1.01

(define (convert x) (for/or ([c table]) (and (< x (car c)) (cadr c))))

 

=={{header|Raku}}==

 

{{works with|rakudo|2016.07}}

when $n < 0.06 { 0.10 }

when $n < 0.11 { 0.18 }

while prompt("value: ") -> $value {

say price-fraction(+$value);

 

If we expect to rescale many prices, a better approach would be to build a look-up array of 101 entries.

Memory is cheap, and array indexing is blazing fast.

 

( 0 ..^ 6 X=> 0.10),

( 6 ..^ 11 X=> 0.18),

while prompt("value: ") -> $value {

say @price[$value * 100] // "Out of range";

 

We can also build this same look-up array by parsing the table as formatted in the task description:

 

{{works with|rakudo|2016.07}}

>= 0.00 < 0.06 := 0.10

>= 0.06 < 0.11 := 0.18

while prompt("value: ") -> $value {

say @price[$value * 100] // "Out of range";

 

=={{header|Raven}}==

{{trans|JavaScript}}

[ 0.1 0.18 0.26 0.32 0.38 0.44 0.50 0.54 0.58 0.62 0.66 0.70 0.74 0.78 0.82 0.86 0.90 0.94 0.98 1.0 ] as $vals

$v 100 * 1 - 5 / 20 min 0 max 1 prefer dup $v "val: %g indx: %d\n" print $vals swap get

 

0 100 9 range each

{{out}}

<pre>0 -> 0.1

=={{header|REXX}}==

===version 1===

pad= ' ' /*for inserting spaces into a message. */

do j=0 to 1 by .01 /*process the prices from 0¢ to ≤ $1 */

otherwise nop

end /*select*/

{{out|output|text=:}}

<pre style="height:66ex">

 

===version 2===

* Inspired by some other solutions tested with version 1 (above)

* 20.04.2013 Walter Pachl

adjprice2: Procedure Expose r.

i=((100*arg(1)-1)%5+1)

 

=={{header|Ring}}==

see pricefraction(0.5)

return 1

 

=={{header|Ruby}}==

A simple function with hardcoded values.

raise ArgumentError, "value=#{value}, must have: 0 <= value < 1.01" if value < 0 || value >= 1.01

if value < 0.06 then 0.10

elsif value < 1.01 then 1.00

end

 

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

For Ruby 1.8.6, use <code>String#each_line</code>

 

ConversionTable = <<-END_OF_TABLE

>= 0.00 < 0.06 := 0.10

end

attr_reader :standard_value

 

And a test suite

 

class PriceFractionTests < Test::Unit::TestCase

end

end

 

{{out}}

 

=={{header|Run BASIC}}==

data .56,.66,.61,.70,.66,.74,.71,.78,.76,.82,.81,.86,.86,.90,.91,.94,.96,.98

 

print numb;" -->";nd(decm)

 

<pre>Gimme a number?12.676

12.676 -->0.78

 

=={{header|Rust}}==

match num {

0.96...1.00 => 1.00,

input_price += 0.01;

}

 

{{out}}

 

=={{header|Scala}}==

case n if n>=0 && n<0.06 => 0.10

case n if n<0.11 => 0.18

 

def testPriceFraction()=

{{out}}

<pre>

 

=={{header|Seed7}}==

include "float.s7i";

 

writeln(flt(i) / 100.0 digits 2 <& " " <& computePrice(flt(i) / 100.0) digits 2);

end for;

 

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

[] (0.06, 0.10), [] (0.11, 0.18), [] (0.16, 0.26), [] (0.21, 0.32), [] (0.26, 0.38),

[] (0.31, 0.44), [] (0.36, 0.50), [] (0.41, 0.54), [] (0.46, 0.58), [] (0.51, 0.62),

raise RANGE_ERROR;

end if;

 

=={{header|Sidef}}==

>= 0.00 < 0.06 := 0.10

>= 0.06 < 0.11 := 0.18

for n in %n(0.3793 0.4425 0.0746 0.6918 0.2993 0.5486 0.7848 0.9383 0.2292) {

say price(n);

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

Object subclass: PriceRescale [

|table|

 

"get a price"

 

=={{header|Swift}}==

 

(0.00..<0.06, 0.10),

(0.06..<0.11, 0.18),

 

print("\(strFmt(val)) -> \(strFmt(adjustDouble(val, accordingTo: ranges) ?? val))")

 

{{out}}

=={{header|Tcl}}==

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

proc parseTable table {

set map {}

# Failed to map; return the input

return $value

How it is used:

set inputTable {

>= 0.00 < 0.06 := 0.10

foreach example {.7388727 .8593103 .826687 .3444635 .0491907} {

puts "$example -> [priceFraction $map $example]"

{{out}}

<pre>

{{trans|Forth}}

{{works with|R3}}

Print Using "+?.##"; i, Using "+?.##"; FUNC(_Normalize (FUNC(_Classify (i))))

Next

Return (Min(b@, 100)) ' clip top of price in accumulator

' calculate class

Output:

<pre>

0 OK, 0:115</pre>

=={{header|Ursala}}==

 

le = <0.06,.11,.16,.21,.26,.31,.36,.41,.46,.51,.56,.61,.66,.71,.76,.81,.86,.91,.96,1.01>

out = <0.10,.18,.26,.32,.38,.44,.50,.54,.58,.62,.66,.70,.74,.78,.82,.86,.90,.94,.98,1.>

 

main points:

* <code>~&p(le,out)</code> zips the pair of lists <code>le</code> and <code>out</code> into a list of pairs

 

test program:

 

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

{{out}}

<pre><

 

=={{header|VBA}}==

Option Explicit

 

If n < Vin(i) Then Price_Fraction = Vout(i): Exit For

Next i

{{Out}}

<pre>0.34 := 0.5

 

=={{header|VBScript}}==

Function pf(p)

If p < 0.06 Then

WScript.Echo pf(0.826687)

WScript.Echo pf(0.3444635)

 

{{Out}}

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var rescale = Fn.new { |v|

for (test in tests) {

Fmt.print("$4.2f -> $4.2f", test, rescale.call(test))

 

{{out}}

 

=={{header|XPL0}}==

 

func real Price(V); \Convert to standard value

RlOut(0, Price(0.10)); CrLf(0);

RlOut(0, Price(1.0)); CrLf(0);

 

{{out}}

 

=={{header|zkl}}==

// < -->, increments of 0.05 but tables are easier to update

var vert=T( T(0.06, 0.10), T(0.11, 0.18), T(0.16, 0.26),

T(0.96, 0.98), T(1.01, 1.00), );

vert.filter1('wrap([(a,_)]){ price<a })[1]

var vert=T(0.10, 0.18, 0.26, 0.32, 0.38, 0.44, 0.50, 0.54, 0.58, 0.62,

0.66, 0.70, 0.74, 0.78, 0.82, 0.86, 0.90, 0.94, 0.98, 1.00);

vert[(price*100-1)/005];

{{out}}

<pre>