Currency: Difference between revisions
added RPL
(added RPL) |
|||
(40 intermediate revisions by 21 users not shown) | |||
Line 36:
Dollar signs and thousands separators are optional.
<br><br>
=={{header|11l}}==
{{trans|Nim}}
<syntaxhighlight lang="11l">F currency(units, subunits)
R BigInt(units) * 100 + subunits
F currency_from_str(s)
V (units, subunits) = s.split(‘.’)
R BigInt(units) * 100 + Int(subunits)
F percentage(a, num, denom)
R (a * num * 10 I/ denom + 5) I/ 10
F to_str(c)
R String(c I/ 100)‘’‘.#02’.format(c % 100)
V hamburgers = currency(5, 50) * 4'000'000'000'000'000
V milkshakes = currency_from_str(‘2.86’) * 2
V beforeTax = hamburgers + milkshakes
V tax = percentage(beforeTax, 765, 10'000)
V total = beforeTax + tax
V maxlen = max(to_str(beforeTax).len, to_str(tax).len, to_str(total).len)
print(‘Total price before tax: ’to_str(beforeTax).rjust(maxlen))
print(‘Tax: ’to_str(tax).rjust(maxlen))
print(‘Total with tax: ’to_str(total).rjust(maxlen))</syntaxhighlight>
{{out}}
<pre>
Total price before tax: 22000000000000005.72
Tax: 1683000000000000.44
Total with tax: 23683000000000006.16
</pre>
=={{header|Ada}}==
Numeric constants in Ada do not have to be given an explicit type. When used in constant expressions together, they have
arbitrary precision. This enables simple calculation of the values. Ada also has builtin fixed-point
types, which can define a minimum interval between decimal values (in this case, 1 cent or $0.01).
When using the Dollar_IO package to print each value, the constant is converted into a Dollar, then printed. All of
the arbitrary-precision arithmetic operations are done at compile-time, incurring no runtime cost.
<syntaxhighlight lang="ada">with Ada.Text_IO;
procedure Currency is
type Dollar is delta 0.01 range 0.0 .. 24_000_000_000_000_000.0;
package Dollar_IO is new Ada.Text_IO.Fixed_IO(Dollar);
hamburger_cost : constant := 5.50;
milkshake_cost : constant := 2.86;
tax_rate : constant := 0.0765;
total_cost : constant := hamburger_cost * 4_000_000_000_000_000.0 + milkshake_cost * 2;
total_tax : constant := total_cost * tax_rate;
total_with_tax : constant := total_cost + total_tax;
begin
Ada.Text_IO.Put("Price before tax:");
Dollar_IO.Put(total_cost);
Ada.Text_IO.New_Line;
Ada.Text_IO.Put("Tax: ");
Dollar_IO.Put(total_tax);
Ada.Text_IO.New_Line;
Ada.Text_IO.Put("Total: ");
Dollar_IO.Put(total_with_tax);
Ada.Text_IO.New_Line;
end Currency;</syntaxhighlight>
{{out}}
<pre>
Price before tax: 22000000000000005.72
Tax: 1683000000000000.44
Total: 23683000000000006.16
</pre>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
<
# currency calculations #
# simple fixed point type, LONG INT is 64-bit in Algol 68G #
Line 103 ⟶ 178:
print( ( "tax: ", TOSTRING tax, newline ) );
print( ( "total: ", TOSTRING total, newline ) )
END</
{{out}}
<pre>
Line 115 ⟶ 190:
The AppleScript core language doesn't recognise currency values specifically and its numbers don't have the precision required for this task, but through ASObjC, it's able to use Foundation classes which do.
<
use framework "Foundation"
Line 167 ⟶ 242:
{quantity:2, unitPrice:currencySymbol & 2.86}}
set taxRate to 7.65
return billTotal(quantitiesAndPrices, taxRate, currencySymbol)</
{{output}}
<
Tax: $1,683,000,000,000,000.44
Total: $23,683,000,000,000,006.16"</
=={{header|AWK}}==
===version 1===
<syntaxhighlight lang="awk">
# syntax: GAWK -M -f CURRENCY.AWK
# using GNU Awk 4.1.1, API: 1.1 (GNU MPFR 3.1.2, GNU MP 5.1.2)
Line 197 ⟶ 272:
exit(0)
}
</syntaxhighlight>
<p>Output:</p>
<pre>
Line 209 ⟶ 284:
</pre>
===version 2===
<syntaxhighlight lang="awk">
# syntax: GAWK -M -f CURRENCY2.AWK
# using GNU Awk 4.1.1, API: 1.1 (GNU MPFR 3.1.2, GNU MP 5.1.2)
Line 233 ⟶ 308:
exit(0)
}
</syntaxhighlight>
<p>Output:</p>
<pre>
Line 244 ⟶ 319:
total 23683000000000006.16
</pre>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> REM No need for BigNum library.
REM This language uses 80bit (10 bytes!) for real values internally.
Price = 4E15 * 5.50 + 2.0 * 2.86
Tax = Price * .0765
Total = Price + Tax
REM Number printing will use 2 decimal places and 21 positions zone
@%=&020215
PRINT "Price = $" Price
PRINT "Tax = $" Tax
PRINT "Total = $" Total</syntaxhighlight>
{{out}}
<pre>Price = $ 22000000000000005.72
Tax = $ 1683000000000000.44
Total = $ 23683000000000006.16</pre>
=={{header|Bracmat}}==
The amounts <code>before-tax</code>, <code>tax</code>, <code>after-tax</code> are computed as rounded amounts in dollar cents.
<syntaxhighlight lang="bracmat"> div$((4000000000000000*550+2*286)+1/2,1):?before-tax
& div$(!before-tax*765/10000+1/2,1):?tax
& !before-tax+!tax:?after-tax
& ( fix
= cents dollars
. mod$(!arg.100):?cents
& ( !cents:<10&0 !cents:?cents
|
)
& div$(!arg.100):?dollars
& str$(!dollars "." !cents)
)
& str
$ ( "before-tax "
fix$!before-tax
"\ntax "
fix$!tax
\n
"after-tax "
fix$!after-tax
\n
)</syntaxhighlight>
''Output''
<pre>before-tax 22000000000000005.72
tax 1683000000000000.44
after-tax 23683000000000006.16</pre>
=={{header|C}}==
Line 253 ⟶ 374:
</pre>
One remark about the code, notice that for setting all other variables the '''mpf_set_d''' function is used:
<syntaxhighlight lang="c">
mpf_set_d(burgerUnitPrice,5.50);
mpf_set_d(milkshakePrice,2 * 2.86);
mpf_set_d(burgerNum,4000000000000000);
mpf_set_d(milkshakeNum,2);
</syntaxhighlight>
But when it comes to the tax rate, it's '''mpf_set_str''':
<syntaxhighlight lang="c">
mpf_set_str(tax,"0.0765",10);
</syntaxhighlight>
The reason is a weird rounding off error which happens if the mpf_set_d function is used. Documentation and example usages of GMP are very rare on the net possibly because it is used almost exclusively by academia and high tech industries. The implementation below is the result of a lot of fiddling, gotchas and lessons learnt, just how good programming should always be :)
{{libheader|GMP}}
<syntaxhighlight lang="c">
#include<stdio.h>
Line 296 ⟶ 417:
return 0;
}
</syntaxhighlight>
Output:
<pre>
Line 304 ⟶ 425:
</pre>
=={{header|C sharp|C#}}==
The built in C# type decimal has a max value of 79228162514264337593543950335.
<
using System.Collections.Generic;
Line 360 ⟶ 481:
}
}
}</
{{out}}
<pre>Total before tax: $22,000,000,000,000,005.72
Line 369 ⟶ 490:
{{libheader|clojurewerkz/money}}
<
(require '[clojurewerkz.money.currencies :as mc])
(require '[clojurewerkz.money.format :as mf])
Line 379 ⟶ 500:
(println "Total before tax: " (mf/format pre-tax))
(println " Tax: " (mf/format tax))
(println " Total with tax: " (mf/format (ma/plus pre-tax tax))))</
{{out}}
<pre>
Total before tax: $22,000,000,000,000,005.72
Tax: $1,683,000,000,000,000.44
Total with tax: $23,683,000,000,000,006.16</pre>
{{libheader|io.randomseed/bankster}}
<syntaxhighlight lang="clojure">(require '[io.randomseed.bankster.money :as m])
(let [burgers (m/mul #money[USD 5.50] 4000000000000000)
milkshakes (m/mul #money[USD 2.86] 2)
pre-tax (m/add burgers milkshakes)
tax (m/with-rounding UP (m/mul pre-tax 0.0765))]
(println "Total before tax: " (m/format pre-tax))
(println " Tax: " (m/format tax))
(println " Total with tax: " (m/format (m/add pre-tax tax))))</syntaxhighlight>
{{out}}
Line 394 ⟶ 533:
{{works with|GNU Cobol|2.1}}
<
IDENTIFICATION DIVISION.
PROGRAM-ID. currency-example.
Line 421 ⟶ 560:
DISPLAY " Total with tax: " total-edited
.
END PROGRAM currency-example.</
{{out}}
Line 431 ⟶ 570:
</pre>
=={{header|
Let us just use the built-in and convenient rationals (which use two bignums for numerator and denominator).
<syntaxhighlight lang="lisp">(defun print-$ (rat &key (prefix "") (stream t))
(multiple-value-bind (dollars cents) (truncate rat)
(format stream "~A~D.~D~%" prefix dollars (round (* 100 cents)))))
(defun compute-check (order-alist tax-rate)
(let* ((total-before-tax
(loop :for (amount . price) in order-alist
:sum (* (rationalize price) amount)))
(tax (* (rationalize tax-rate) total-before-tax)))
(print-$ total-before-tax :prefix "Total before tax: ")
(print-$ tax :prefix "Tax: ")
(print-$ (+ total-before-tax tax) :prefix "Total with tax: ")))
(compute-check '((4000000000000000 . 5.5) (2 . 2.86)) 0.0765)</syntaxhighlight>
{{out}}
<pre>Total before tax: 22000000000000005.72
Tax: 1683000000000000.44
Total with tax: 23683000000000006.16</pre>
A reader macro can be used as extra nice icing on the cake:
<syntaxhighlight lang="lisp">(defun read-$ (stream char)
(declare (ignore char))
(let* ((str (with-output-to-string (out)
;; TODO: read integer, if dot, read dot and another integer
(loop :for next = (peek-char nil stream t nil t)
:while (or (digit-char-p next) (char= next #\.))
:do (write-char (read-char stream t nil t) out))))
(dot-pos (position #\. str))
(dollars (parse-integer str :end dot-pos))
(cents (if dot-pos
(/ (parse-integer str :start (+ dot-pos 1))
(expt 10 (- (length str) (+ dot-pos 1))))
0)))
(+ dollars cents)))
(set-macro-character #\$ #'read-$ t)
(defun print-$ (rat &key (prefix "") (stream t))
(multiple-value-bind (dollars cents) (truncate rat)
(format stream "~A~D.~D~%" prefix dollars (round (* 100 cents)))))
(defun compute-check (order-alist tax-rate)
(let* ((total-before-tax
(loop :for (amount . price) in order-alist
:sum (* price amount)))
(tax (* (rationalize tax-rate) total-before-tax)))
(print-$ total-before-tax :prefix "Total before tax: ")
(print-$ tax :prefix "Tax: ")
(print-$ (+ total-before-tax tax) :prefix "Total with tax: ")))
(compute-check '((4000000000000000 . $5.5) (2 . $2.86)) 0.0765)</syntaxhighlight>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| Velthuis.BigRationals}}
{{libheader| Velthuis.BigDecimals}}
{{libheader| Velthuis.BigIntegers}}
{{Trans|Go}}
<syntaxhighlight lang="delphi">
program Currency;
{$APPTYPE CONSOLE}
uses
System.SysUtils,
Velthuis.BigRationals,
Velthuis.BigDecimals,
Velthuis.BigIntegers;
var
one: BigInteger;
hundred: BigInteger;
half: BigRational;
type
TDc = record
value: BigInteger;
function ToString: string;
function Extend(n: BigInteger): TDc;
class operator Add(a, b: TDc): TDc;
end;
TTR = record
value: BigRational;
function SetString(const s: string; var TR: TTR): boolean;
function Tax(dc: TDc): TDc;
end;
{ TDc }
// Extend returns extended price of a unit price.
class operator TDc.Add(a, b: TDc): TDc;
begin
Result.value := a.value + b.value;
end;
function TDc.Extend(n: BigInteger): TDc;
begin
Result.value := n * value;
end;
function TDc.ToString: string;
var
d: BigInteger;
begin
d := value.Divide(value, 100);
if value < 0 then
value := -value;
Result := Format('%s.%2s', [d.ToString, (value mod 100).ToString]);
end;
// ParseDC parses dollars and cents as a string into a DC.
function ParseDC(s: string; var Dc: TDc): Boolean;
var
r: BigRational;
d: BigDecimal;
begin
Result := d.TryParse(s, d);
if not Result then
begin
Dc.value := 0;
exit(false);
end;
r := r.Create(d);
r := r.Multiply(r, 100);
if BigInteger.Compare(r.Denominator, 1) <> 0 then
begin
Dc.value := 0;
exit(false);
end;
Result := true;
Dc.value := r.Numerator;
end;
{ TTR }
function TTR.SetString(const s: string; var TR: TTR): boolean;
var
d: BigDecimal;
begin
Result := d.TryParse(s, d);
if Result then
TR.value := BigRational.Create(d);
end;
function TTR.Tax(dc: TDc): TDc;
var
r: BigRational;
i: BigInteger;
begin
r := BigRational.Create(dc.value, 1);
r := r.Multiply(r, self.value);
r := r.add(r, half);
i := i.Divide(r.Numerator, r.Denominator);
Result.value := i;
end;
var
hamburgerPrice, milkshakePrice, totalBeforeTax, tax, total: TDc;
taxRate: TTR;
begin
one := 1;
hundred := 100;
half := BigRational.Create(1, 2);
if not ParseDC('5.50', hamburgerPrice) then
begin
Writeln('Invalid hamburger price');
halt(1);
end;
if not ParseDC('2.86', milkshakePrice) then
begin
Writeln('Invalid milkshake price');
halt(2);
end;
if not taxRate.SetString('0.0765', taxRate) then
begin
Writeln('Invalid tax rat');
halt(3);
end;
totalBeforeTax := hamburgerPrice.Extend(4000000000000000) + milkshakePrice.Extend(2);
tax := taxRate.Tax(totalBeforeTax);
total := totalBeforeTax + tax;
Writeln('Total before tax: ', totalBeforeTax.ToString: 22);
Writeln(' Tax: ', tax.ToString: 22);
Writeln(' Total: ', total.ToString: 22);
readln;
end.</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">open System
let hamburgers = 4000000000000000M
Line 446 ⟶ 783:
printfn "Total before tax:\t$%M" <| Math.Round (total, 2)
printfn " Tax:\t$%M" <| Math.Round (tax, 2)
printfn " Total:\t$%M" <| Math.Round (totalWithTax, 2)</
{{out}}
Line 458 ⟶ 795:
=={{header|Factor}}==
Factor's <tt>ratio</tt> type can handle arbitrary-precision calculations with rational numbers. The <tt>money</tt> vocabulary implements convenience words for treating rationals as money. The <tt>DECIMAL:</tt> parsing word is used to convert the tax rate <tt>0.0765</tt> to a ratio <tt>153/2000</tt>. The <tt>money.</tt> word is used to print the subtotal <tt>22000000000000005+18/25</tt>, tax <tt>1683000000000000+21879/50000</tt>, and total <tt>23683000000000006+7879/50000</tt> formatted as you would expect.
<
10 15 ^ 4 * 5+50/100 * ! hamburger subtotal
Line 468 ⟶ 805:
"Total before tax: " write [ money. ] 2dip
"Tax: " write [ money. ] dip
"Total with tax: " write money.</
{{out}}
<pre>
Line 479 ⟶ 816:
=={{header|FreeBASIC}}==
Pero el subtotal y el tax los muestra redondeados. Y no encuentro el porqué.
<
Dim As Longint hamburger_q = 4000000000000000
Dim As Longint hamburger_v = hamburger_p * hamburger_q
Line 494 ⟶ 831:
Print Using " tax #####################.##";tax/100
Print Using " total #####################.##";subtotal/10+tax/100
Sleep</
Line 500 ⟶ 837:
Frink tracks units of measure through all calculations, so you can specify quantities as "dollar", "cent", etc.
<
st = 4000000000000000 * 5.50 dollars + 2 * 2.86 dollars
tax = round[st * 7.65 percent, cent]
Line 507 ⟶ 844:
println["Tax: " + format[tax, "dollars", 2]]
println["Total: " + format[total, "dollars", 2]]
</syntaxhighlight>
{{out}}
<pre>
Line 513 ⟶ 850:
Tax: 1683000000000000.44 dollars
Total: 23683000000000006.16 dollars
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn Lunch_Invoice( burger_price as CFStringRef, burger_amount as CFStringRef, shake_price as CFStringRef, shake_amount as CFStringRef, tax as CFStringRef )
'~'1
DecimalNumberRef burgerPriceDecimal = fn DecimalNumberWithString( burger_price )
DecimalNumberRef burgerAmountDecimal = fn DecimalNumberWithString( burger_amount )
DecimalNumberRef burgersDecimal = fn DecimalNumberByMultiplyingBy( burgerPriceDecimal, burgerAmountDecimal )
DecimalNumberRef shakePriceDecimal = fn DecimalNumberWithString( shake_price )
DecimalNumberRef shakeAmountDecimal = fn DecimalNumberWithString( shake_amount )
DecimalNumberRef shakesDecimal = fn DecimalNumberByMultiplyingBy( shakePriceDecimal, shakeAmountDecimal )
DecimalNumberRef taxDecimal = fn DecimalNumberWithString( tax )
DecimalNumberRef subtotalDecimal = fn DecimalNumberByAdding( burgersDecimal, shakesDecimal )
DecimalNumberRef taxTotalDecimal = fn DecimalNumberByMultiplyingBy( subtotalDecimal, taxDecimal )
DecimalNumberRef adjTaxTotalDecimal = fn DecimalNumberByAdding( taxTotalDecimal, fn DecimalNumberWithString( @"0.01" ) )
DecimalNumberRef billTotalDecimal = fn DecimalNumberByAdding( subtotalDecimal, adjTaxTotalDecimal )
CFStringRef burgersString = fn DecimalNumberString( burgersDecimal )
CFStringRef shakesString = fn DecimalNumberString( shakesDecimal )
CFStringRef taxTotalString = fn DecimalNumberString( adjTaxTotalDecimal )
CFStringRef billTotalString = fn DecimalNumberString( billTotalDecimal )
printf @"%@", fn StringByPaddingToLength( @"", 55, @"-", 0 )
printf @"Item Price Quantity Cost"
printf @"Hamburgers %6s %18s %18s", fn StringUTF8String( burger_price ), fn StringUTF8String( burger_amount ), fn StringUTF8String( burgersString )
printf @"Milkshakes %6s %18s %18s", fn StringUTF8String( shake_price ), fn StringUTF8String( shake_amount ), fn StringUTF8String( shakesString )
printf @"%@", fn StringByPaddingToLength( @"", 55, @"-", 0 )
printf @"%34s %@", fn StringUTF8String( @"Subtotal:" ), fn DecimalNumberString( subtotalDecimal )
printf @"%35s %@", fn StringUTF8String( @" Tax: " ), fn StringSubstringToIndex( taxTotalString, len(taxTotalString) - 3 )
printf @"%34s %@", fn StringUTF8String( @" Total:" ), fn StringSubstringToIndex( billTotalString, len(billTotalString) - 3 )
end fn
NSLog( @"%@", fn WindowPrintViewString( 1 ) )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
-------------------------------------------------------
Item Price Quantity Cost
Hamburgers 5.50 4000000000000000 22000000000000000
Milkshakes 2.86 2 5.72
-------------------------------------------------------
Subtotal: 22000000000000005.72
Tax: 1683000000000000.44
Total: 23683000000000006.16
</pre>
=={{header|Go}}==
<
import (
Line 603 ⟶ 988:
fmt.Printf(" Tax: %22s\n", tax)
fmt.Printf(" Total: %22s\n", total)
}</
{{out}}
<pre>
Line 612 ⟶ 997:
=={{header|Haskell}}==
<
import Text.Printf
Line 631 ⟶ 1,016:
printAmount "Subtotal" subtotal
printAmount "Tax" tx
printAmount "Total" total</
{{out}}
Line 645 ⟶ 1,030:
We use a naive implementation with arbitrary precision (rational) numbers:
<
Items=: ;: 'Hamburger Milkshake'
Quantities=: 4000000000000000 2
Tax_rate=: x: 0.0765
'items prices quantities'=. y
values=. prices * quantities
subtotal=. +/ values
tax=. Tax_rate * subtotal
total=. subtotal + tax
'%9s %8s %20s %22s' printf ;:'Item Price Quantity Value'
'%9s %8.2f %20d %22.2f' printf"1 items ,. <"0 prices ,. quantities ,. values
'%62s' printf <'-------------------------------'
'%40s %21.2f' printf"1 (;:'Subtotal: Tax: Total:') ,. subtotal;tax;total
)
makeBill Items;Prices;Quantities</syntaxhighlight>
{{out}}
<pre>
Hamburger 5.50 4000000000000000 22000000000000000.00
Milkshake 2.86 2 5.72
Line 681 ⟶ 1,063:
=={{header|Java}}==
<
import java.util.*;
Line 719 ⟶ 1,101:
System.out.printf(" Total: %20.2f%n", subtotal.add(tax));
}
}</
<pre>Subtotal: 22000000000000005.72
Line 726 ⟶ 1,108:
=={{header|JavaScript}}==
<
let hamburgers = 4000000000000000
Line 750 ⟶ 1,132:
console.log('Tax:', taxTotal)
console.log('Total:', total)
</syntaxhighlight>
=={{header|jq}}==
For simplicity, we will use the gojq implementation of jq
as it supports unbounded-precision integer arithmetic.
If the standard implementation of jq were used,
then it would probably be simplest to use the BigInt.jq library,
which uses strings for precision.
The strategy here is to use cents except when presenting
results as dollars and cents, and when calculating the taxes.
<syntaxhighlight lang="jq">def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
# print as dollars and cents
def dollars:
(. % 100) as $c
| "$\((. - $c) /100).\($c)";
def dollars($width):
dollars | lpad($width);
def innerproduct($y):
. as $x
| reduce range(0;$x|length) as $i (0; . + ($x[$i]*$y[$i]));
def plus($y):
. as $x
| reduce range(0;$x|length) as $i ([]; .[$i] = ($x[$i]+$y[$i]));
# Round up or down
def integer_division($y):
(. % $y) as $remainder
| (. - $remainder) / $y
| if $remainder * 2 > $y then . + 1 else . end;
# For computing taxes
def precision: 10000;
def cents: integer_division(precision);
### The task:
def p: [550, 286];
def q: [4000000000000000, 2];
def taxrate: 765; # relative to `precision`
(p | innerproduct(q)) as $before_tax # cents
| ($before_tax * taxrate) as $taxes # relative to precision
| ((($before_tax * precision) + $taxes) | cents) as $after_tax # cents
| ($after_tax|tostring|length + 2) as $width
|
" Total before tax: \($before_tax | dollars($width))",
" - tax: \($taxes | cents | dollars($width))",
" Total after tax: \($after_tax | dollars($width))"</syntaxhighlight>
{{out}}
<pre>
Total before tax: $22000000000000005.72
- tax: $1683000000000000.44
Total after tax: $23683000000000006.16
</pre>
=={{header|Julia}}==
{{works with|Julia|1.2}}
<
p = [big"5.50", big"2.86"]
Line 767 ⟶ 1,211:
@printf " - tot. before tax: %20.2f \$\n" beftax
@printf " - tax: %20.2f \$\n" tax
@printf " - tot. after tax: %20.2f \$\n" afttax</
{{out}}
Line 775 ⟶ 1,219:
=={{header|Kotlin}}==
<
import java.math.BigDecimal
Line 793 ⟶ 1,237:
println("Tax thereon @ 7.65% : ${fmt.format(tax)}")
println("Total price after tax : ${fmt.format(price + tax)}")
}</
{{out}}
Line 801 ⟶ 1,245:
Total price after tax : 23683000000000006.16
</pre>
=={{header|Lua}}==
Using the lbc library for arbitrary precision support.
<syntaxhighlight lang="lua">C = setmetatable(require("bc"), {__call=function(t,...) return t.new(...) end})
C.digits(6) -- enough for .nn * .nnnn ==> .nnnnnn, follow with trunc(2) to trim trailing zeroes
subtot = (C"4000000000000000" * C"5.50" + C"2" * C"2.86"):trunc(2) -- cosmetic trunc
tax = (subtot * C"0.0765" + C"0.005"):trunc(2) -- rounding trunc
total = (subtot + tax):trunc(2) -- cosmetic trunc
print(("Before tax: %20s"):format(subtot:tostring()))
print(("Tax : %20s"):format(tax:tostring()))
print(("With tax : %20s"):format(total:tostring()))</syntaxhighlight>
{{out}}
<pre>Before tax: 22000000000000005.72
Tax : 1683000000000000.44
With tax : 23683000000000006.16</pre>
=={{header|M2000 Interpreter}}==
This task written in M2000 Environment running on Wine 3.6, in a Linux Ubuntu Studio. M2000 environment is an ActiveX object, written with VB6, which use many types from [https://en.wikipedia.org/wiki/Variant_type COM Variant Type].
<syntaxhighlight lang="m2000 interpreter">
Module Currency_Task {
Locale 1033
Line 870 ⟶ 1,331:
}
Currency_Task
</syntaxhighlight>
Optional with $ and thousands separator (a smaller version from above)
<syntaxhighlight lang="m2000 interpreter">
Module Currency_Task {
Locale 1033
Line 915 ⟶ 1,376:
}
Currency_Task
</syntaxhighlight>
{{out}}
<pre style="height:30ex;overflow:scroll">
Line 935 ⟶ 1,396:
=={{header|Maple}}==
<syntaxhighlight lang="maple">
Digits := 50;
Line 956 ⟶ 1,417:
totalprice := totaltax + total;
printf("%.2f\n",totalprice);
</syntaxhighlight>
{{out}}
<pre>
Line 963 ⟶ 1,424:
23683000000000006.16
</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">total = 4000000000000000 Rationalize[5.50] + 2 Rationalize[2.86];
AccountingForm[N[total, 20], {\[Infinity], 2}]
tax = total Rationalize[0.0765];
AccountingForm[N[tax, 20], {\[Infinity], 2}]
AccountingForm[N[total + tax, 20], {\[Infinity], 2}]</syntaxhighlight>
{{out}}
<pre>22000000000000005.72
1683000000000000.44
23683000000000006.16</pre>
=={{header|Nim}}==
Line 969 ⟶ 1,441:
Nim doesn’t provide a standard module to deal with decimal values. There exist some third party modules but we have chosen to use the “bignum” library which provides big integers and big rationals.
<
import bignum
Line 1,062 ⟶ 1,534:
echo "Total price before tax: ", beforeTaxStr.align(length)
echo "Tax: ", taxStr.align(length)
echo "Total with tax: ", totalStr.align(length)</
{{out}}
Line 1,071 ⟶ 1,543:
=={{header|OCaml}}==
Using the [https://
<syntaxhighlight lang
let () =
let open Decimal in (* bring all functions and operators into scope locally *)
let s = of_string in
let i = of_int in
let
let
let tax_rate = s "7.65e-2" in
let subtotal = hamburgers + milkshakes in
let tax = subtotal * tax_rate in
let total = subtotal + tax in
Printf.printf
"Subtotal: %20s
Tax: %20s
Total: %20s\n"
(to_string (round ~n:2 subtotal))
(to_string (round ~n:2 tax))
(to_string (round ~n:2 total))
</syntaxhighlight>
{{out}}
<pre>
Subtotal: 22000000000000005.72
Tax: 1683000000000000.44
Total: 23683000000000006.16
</pre>
=={{header|Perl}}==
<
@check = (
Line 1,134 ⟶ 1,605:
($q, $r) = dec_rndiv_and_rem("FLR", @_[0], 1);
$q . substr((sprintf "%.2f", $r), 1, 3);
}</
{{out}}
<pre>Item Price Quantity Extension
Line 1,146 ⟶ 1,617:
=={{header|Phix}}==
{{libheader|Phix/mpfr}}
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.4"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (mpfr_get_fixed() busted in 1.0.2|3)</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #7060A8;">mpfr_set_default_precision</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">20</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- ensure accuracy to at least 20 d.p.</span>
<span style="color: #004080;">mpfr</span> <span style="color: #000000;">total_price</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_init</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"4000000000000000"</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">tmp</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_init</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"5.5"</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">tax</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_init</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"0.0765"</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">total</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_init</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">mpfr_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">total_price</span><span style="color: #0000FF;">,</span><span style="color: #000000;">total_price</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_set_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"2.86"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">total_price</span><span style="color: #0000FF;">,</span><span style="color: #000000;">total_price</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tmp</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tax</span><span style="color: #0000FF;">,</span><span style="color: #000000;">total_price</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tax</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">total</span><span style="color: #0000FF;">,</span><span style="color: #000000;">total_price</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tax</span><span style="color: #0000FF;">)</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;">"Total before tax:%26s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">total_price</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">comma_fill</span><span style="color: #0000FF;">:=</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)})</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;">" Tax:%26s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tax</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">comma_fill</span><span style="color: #0000FF;">:=</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)})</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;">" Total:%26s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">total</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">comma_fill</span><span style="color: #0000FF;">:=</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Total before tax: 22,000,000,000,000,005.72
Tax: 1,683,000,000,000,000.44
Total: 23,683,000,000,000,006.16
</pre>
=== 64 bit ===
As it happens, 64-bit Phix uses 80-bit floats for atoms, which actually have just enough accuracy for this task:
<!--<syntaxhighlight lang="phix">-->
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #000000;">64</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">total_price</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">4000000000000000</span><span style="color: #0000FF;">*</span><span style="color: #000000;">5.5</span><span style="color: #0000FF;">+</span><span style="color: #000000;">2.86</span><span style="color: #0000FF;">*</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">tax</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">total_price</span><span style="color: #0000FF;">*</span><span style="color: #000000;">0.0765</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">total</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">total_price</span><span style="color: #0000FF;">+</span><span style="color: #000000;">tax</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;">"Total before tax:%,26.2f\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">total_price</span><span style="color: #0000FF;">})</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;">" Tax:%,26.2f\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">tax</span><span style="color: #0000FF;">})</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;">" Total:%,26.2f\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">total</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
with the same output, however (after deleting the first line) under 32-bit (and under p2js) they would incorrectly end in 4.00/0.25/4.00.
=={{header|PicoLisp}}==
<syntaxhighlight lang="text">(scl 2)
(let
(Before
Line 1,181 ⟶ 1,667:
(tab Fmt "Total before tax:" (format Before *Scl "." ","))
(tab Fmt "Tax:" (format Tax *Scl "." ","))
(tab Fmt "Total:" (format Total *Scl "." ",")) )</
{{out}}
<pre>
Line 1,193 ⟶ 1,679:
(and some copying of names from the Raku example).
<
from collections import namedtuple
Line 1,218 ⟶ 1,704:
total = total_before_tax + tax
print(fmt % ('', '', '', '--------------------'))
print(fmt % ('', '', 'Total', total))</
{{out}}
Line 1,229 ⟶ 1,715:
--------------------
Total 23683000000000006.16</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="Quackery"> [ $ "bigrat.qky" loadfile ] now!
[ 100 * n->v ] is dollars ( n --> n/d )
[ n->v v+ ] is cents ( n/d n --> n/d )
[ rot n->v v* ] is cost ( n n/d --> n/d )
[ $->v drop v* 100 n->v v/ ] is tax ( n/d $ --> n/d )
[ 100 n->v v/
2 point$
$ " $" swap join
' [ 2 split nip ] ]do[
dup -3 peek
char . = if done
dup -2 peek
char . = iff
[ char 0 join ]
done
$ ".00" join ] is currency$ ( n/d --> $ )
[ currency$ echo$ ] is echocurrency ( n/d --> )
4000000000000000 5 dollars 50 cents cost
2 2 dollars 86 cents cost v+
say "Total price before tax: " 2dup echocurrency cr
2dup $ "7.65" tax
say "Tax: " 2dup echocurrency cr
v+
say "Total price with tax: " echocurrency cr
</syntaxhighlight>
{{out}}
<pre>Total price before tax: $22000000000000005.72
Tax: $1683000000000000.44
Total price with tax: $23683000000000006.16</pre>
=={{header|Racket}}==
Line 1,237 ⟶ 1,769:
The main problem is rounding correctly and this part is handled in cents-*, that implements a multiplication that rounds to the cents.
The rest of the program is only formatting.
<
(define (cents-* x y)
(/ (round (* 100 x y)) 100))
Line 1,281 ⟶ 1,813:
(for-each show-item all)
(newline)
(show-total all (/ #e7.65 100))</
{{out}}
<pre>hamburger 4000000000000000 $5.50 -> $22000000000000000.00
Line 1,296 ⟶ 1,828:
(In order to achieve imprecision, you have to explicitly use scientific notation,
or use the <tt>Num</tt> type, or calculate a result that requires a denominator in excess of <tt>2 ** 64</tt>. (There's no limit on the numerator.))
<syntaxhighlight lang="raku"
Hamburger 5.50 4000000000000000
Milkshake 2.86 2
Line 1,323 ⟶ 1,855:
# make up for lack of a Rat fixed-point printf format
sub fix2($x) { ($x + 0.001).subst(/ <?after \.\d\d> .* $ /, '') }</
{{out}}
<pre>Item Price Quantity Extension
Line 1,340 ⟶ 1,872:
Programming note: the tax rate can be expressed with or without a percent ('''%''') suffix.
===without commas===
<
numeric digits 200 /*support for gihugic numbers.*/
taxRate= 7.65 /*number is: nn or nn% */
Line 1,368 ⟶ 1,900:
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
show$: return right( '$'arg(1), 27) /*right─justify and format a number. */</
{{out|output|text= (attempting to mimic a check-out register to some degree):}}
<pre>
Line 1,384 ⟶ 1,916:
===with commas===
<
numeric digits 200 /*support for gihugic numbers.*/
taxRate= 7.65 /*number is: nn or nn% */
Line 1,416 ⟶ 1,948:
do j=e to b by -3; _= insert(',', _, j); end /*j*/; return _
/*──────────────────────────────────────────────────────────────────────────────────────*/
show$: return right( commas( '$'arg(1) ), 27) /*right─justify and format a number. */</
{{out|output|text= with commas in the larger numbers:}}
<pre>
Line 1,432 ⟶ 1,964:
=={{header|Ring}}==
<
# Project : Currency
Line 1,445 ⟶ 1,977:
see "tax thereon @ 7.65 : " + tax + nl
see "total price after tax : " + (price + tax) + nl
</syntaxhighlight>
Output:
<pre>
Line 1,452 ⟶ 1,984:
total price after tax : 23683000006.16
</pre>
=={{header|RPL}}==
Need for big integers.
{{works with|RPL|HP-49C}}
« →STR
'''IF''' LASTARG 9 ≤ '''THEN''' "0" SWAP + '''END'''
1 OVER SIZE 2 - SUB
LASTARG NIP 1 + DUP 1 + SUB
"$" ROT SIZE LASTARG "0" IFTE +
"." + SWAP +
» '<span style="color:blue">→CURR</span>' STO
« 100 * R→I *
DUP <span style="color:blue">→CURR</span> CLLCD 1 DISP .5 WAIT
» '<span style="color:blue">→PRICE</span>' STO
« DUPDUP FLOOR - EVAL →NUM
0.5 ≥ SWAP CEIL LASTARG FLOOR IFTE
» '<span style="color:blue">→RND</span>' STO
« 100 * R→I
OVER <span style="color:blue">→CURR</span> "TPBT" →TAG
UNROT OVER * 100000 / <span style="color:blue">→RND</span> DUP <span style="color:blue">→CURR</span> "Tax" →TAG
UNROT + <span style="color:blue">→CURR</span> "TPWT" →TAG
» '<span style="color:blue">TAX→</span>' STO
4000000000000000 5.50 <span style="color:blue">→PRICE</span>
2 2.86 <span style="color:blue">→PRICE</span> +
7.65 <span style="color:blue">TAX→</span>
{{out}}
<pre>
3: TPBT:"$22000000000000005.72"
2: Tax:"$1683000000000000.44"
1: TPWT:"$23683000000000006.16"
</pre>
=={{header|Ruby}}==
<
before_tax = 4000000000000000 * 5.50.to_d + 2 * 2.86.to_d
Line 1,462 ⟶ 2,029:
Tax: $#{tax.to_s('F')}
Total: $#{total.to_s('F')}"
</syntaxhighlight>
{{out}}
<pre>Before tax: $22000000000000005.72
Line 1,471 ⟶ 2,038:
=={{header|Rust}}==
<
extern crate num_rational; // 0.3.0
Line 1,522 ⟶ 2,089:
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let cents = (&self.amount * BigInt::from(100)).to_integer();
write!(f, "${}.{:0>2}", ¢s / 100, ¢s % 100)
}
}
Line 1,530 ⟶ 2,097:
fn new(num: f64) -> Self {
Self {
amount: BigRational::new(((num * 100.0).round() as i64).into(), 100.into())
}
}
Line 1,541 ⟶ 2,108:
}
}
}</
{{out}}
<pre>
Line 1,552 ⟶ 2,119:
{{libheader|Scala}}Locale is manipulated to demonstrate the behavior with other currencies.
<
import java.util.Locale
Line 1,581 ⟶ 2,148:
println(f"${" " * 16 + '\t' + " " * 16 + '\t' + f"${tax * 100}%5.2f%% tax" + '\t'}$taxation%,25.2f")
println(f"${" " * 16 + '\t' + " " * 16 + '\t' + "Amount due" + '\t'}${beforeTax + taxation}%,25.2f")
}</
{{out}}
4000000000000000 Hamburger XL руб. 5,50 22 000 000 000 000 000,00
Line 1,593 ⟶ 2,160:
=={{header|Sidef}}==
{{trans|Raku}}
<
name, price, quant
}
Line 1,620 ⟶ 2,187:
var total = subtotal+tax
printf(fmt, '', '', 'Total ', total)</
{{out}}
<pre>
Line 1,631 ⟶ 2,198:
Total 23683000000000006.16
</pre>
=={{header|Smalltalk}}==
Using ScaledDecimal numbers ('sX'-suffix).
{{works with|Smalltalk/X}}
<syntaxhighlight lang="smalltalk">check := #(
" amount name price "
(4000000000000000 'hamburger' 5.50s2 )
(2 'milkshakes' 2.86s2 )
).
tax := 7.65s2.
fmt := '%-10s %10P %22P %26P\n'.
totalSum := 0.
totalTax := 0.
Transcript clear.
Transcript printf:fmt withAll:#('Item' 'Price' 'Qty' 'Extension').
Transcript printCR:('-' ,* 72).
check do:[:entry|
|amount name price itemTotal itemTax|
amount := entry[1].
name := entry[2].
price := entry[3].
itemTotal := (price*amount).
itemTax := ((price*amount)*tax/100) roundedToScale.
totalSum := totalSum + itemTotal.
totalTax := totalTax + itemTax.
Transcript printf:fmt
withAll:{name . price . amount . itemTotal}.
].
Transcript printCR:('-' ,* 72).
Transcript printf:fmt withAll:{'' . '' . 'Subtotal' . totalSum}.
Transcript printf:fmt withAll:{'' . '' . 'Tax' . totalTax}.
Transcript printf:fmt withAll:{'' . '' . 'Total' . (totalSum+totalTax)}.
Transcript cr; printCR:('Enjoy your Meal & Thank You for Dining at Milliways')</syntaxhighlight>
{{out}}
<pre>Item Price Qty Extension
------------------------------------------------------------------------
hamburger 5.50 4000000000000000 22000000000000000.00
milkshakes 2.86 2 5.72
------------------------------------------------------------------------
Subtotal 22000000000000005.72
Tax 1683000000000000.44
Total 23683000000000006.16
Enjoy your Meal & Thank You for Dining at Milliways</pre>
=={{header|Swift}}==
<
extension Decimal {
Line 1,652 ⟶ 2,269:
print("Price before tax: $\(totalBeforeTax)")
print("Total tax to be collected: $\(taxesToBeCollected)")
print("Total with taxes: $\(totalBeforeTax + taxesToBeCollected)")</
{{out}}
Line 1,661 ⟶ 2,278:
=={{header|Tcl}}==
{{tcllib|math::decimal}}<
namespace import math::decimal::*
Line 1,674 ⟶ 2,291:
set total [+ $net $tax]
puts "net=[tostr $net], tax=[tostr $tax], total=[tostr $total]"</
{{out}}
net=22000000000000005.72, tax=1683000000000000.44, total=23683000000000006.16
=={{header|Unicon}}==
Solution takes advantage of Unicon's FxPt class as well as Unicon's operator overloading extension.
<syntaxhighlight lang="unicon">import math
procedure main()
n_burgers := 4000000000000000
n_shakes := 2
price := FxPt(5.50) * n_burgers + FxPt(2.86) * n_shakes
tax := (price * FxPt(7.65/100)).round(2)
total := price + tax
write(left("Price", 10), "$", right(price.toString(),21))
write(left("Tax", 10), "$", right(tax.toString(),21))
write(left("Total", 10), "$", right(total.toString(),21))
end</syntaxhighlight>{{out}}
<pre>Price $ 22000000000000005.72
Tax $ 1683000000000000.44
Total $ 23683000000000006.16</pre>
=={{header|VBA}}==
Used in locality Euroland. Formatting as currency shows € in stead of $, and thousand separators are "." in stead of "," and the decimail 'point' is "," in stead of "." When run in the USA it will be with dollar sign and so on.
<
'4000000000000000 hamburgers at $5.50 each
Dim number_of_hamburgers As Variant
Line 1,705 ⟶ 2,342:
'the total with tax
Debug.Print "Total with tax "; Format(total_price_before_tax + tax, "Currency")
End Sub</
<pre>Total price before tax € 22.000.000.000.000.005,72
Tax € 1.683.000.000.000.000,44
Line 1,712 ⟶ 2,349:
=={{header|Wren}}==
{{libheader|Wren-big}}
<
var hamburgers = BigRat.new("4000000000000000")
Line 1,725 ⟶ 2,362:
System.print("Total price before tax : %((totalPreTax).toDecimal(2))")
System.print("Tax : %((totalTax).toDecimal(2))")
System.print("Total price after tax : %((totalAfterTax).toDecimal(2))")</
{{out}}
Line 1,738 ⟶ 2,375:
So, just multiply bucks by 100 and be careful when doing tax calculations.
{{trans|Python}}
<
var taxRate=765; // percent*M
const M=0d10_000;
Line 1,763 ⟶ 2,400:
fmt.fmt("","","","--------------------").println();
fmt.fmt("","","Total",toBucks(totalBeforeTax + tax)).println();
}</
<
{{out}}
<pre>
|