Currency: Difference between revisions

{{trans|Nim}}

 

R BigInt(units) * 100 + subunits

 

print(‘Total price before tax: ’to_str(beforeTax).rjust(maxlen))

print(‘Tax: ’to_str(tax).rjust(maxlen))

 

{{out}}

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.

 

procedure Currency is

Dollar_IO.Put(total_with_tax);

Ada.Text_IO.New_Line;

{{out}}

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

print( ( "tax: ", TOSTRING tax, newline ) );

print( ( "total: ", TOSTRING total, newline ) )

{{out}}

<pre>

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"

 

{quantity:2, unitPrice:currencySymbol & 2.86}}

set taxRate to 7.65

 

{{output}}

Tax: $1,683,000,000,000,000.44

 

=={{header|AWK}}==

===version 1===

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

exit(0)

}

<p>Output:</p>

<pre>

</pre>

===version 2===

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

exit(0)

}

<p>Output:</p>

<pre>

=={{header|Bracmat}}==

The amounts <code>before-tax</code>, <code>tax</code>, <code>after-tax</code> are computed as rounded amounts in dollar cents.

& div$(!before-tax*765/10000+1/2,1):?tax

& !before-tax+!tax:?after-tax

fix$!after-tax

\n

''Output''

<pre>before-tax 22000000000000005.72

</pre>

One remark about the code, notice that for setting all other variables the '''mpf_set_d''' function is used:

mpf_set_d(burgerUnitPrice,5.50);

mpf_set_d(milkshakePrice,2 * 2.86);

mpf_set_d(burgerNum,4000000000000000);

mpf_set_d(milkshakeNum,2);

But when it comes to the tax rate, it's '''mpf_set_str''':

mpf_set_str(tax,"0.0765",10);

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

 

#include<stdio.h>

return 0;

}

Output:

<pre>

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

The built in C# type decimal has a max value of 79228162514264337593543950335.

using System.Collections.Generic;

 

}

}

{{out}}

<pre>Total before tax: $22,000,000,000,000,005.72

{{libheader|clojurewerkz/money}}

 

(require '[clojurewerkz.money.currencies :as mc])

(require '[clojurewerkz.money.format :as mf])

(println "Total before tax: " (mf/format pre-tax))

(println " Tax: " (mf/format tax))

 

{{out}}

{{libheader|io.randomseed/bankster}}

 

 

(let [burgers (m/mul #money[USD 5.50] 4000000000000000)

(println "Total before tax: " (m/format pre-tax))

(println " Tax: " (m/format tax))

 

{{out}}

{{works with|GNU Cobol|2.1}}

 

IDENTIFICATION DIVISION.

PROGRAM-ID. currency-example.

DISPLAY " Total with tax: " total-edited

.

 

{{out}}

{{libheader| Velthuis.BigIntegers}}

{{Trans|Go}}

program Currency;

 

Writeln(' Total: ', total.ToString: 22);

readln;

 

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

 

let hamburgers = 4000000000000000M

printfn "Total before tax:\t$%M" <| Math.Round (total, 2)

printfn " Tax:\t$%M" <| Math.Round (tax, 2)

 

{{out}}

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

"Total before tax: " write [ money. ] 2dip

"Tax: " write [ money. ] dip

{{out}}

<pre>

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

Print Using " tax #####################.##";tax/100

Print Using " total #####################.##";subtotal/10+tax/100

 

 

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]

println["Tax: " + format[tax, "dollars", 2]]

println["Total: " + format[total, "dollars", 2]]

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

fmt.Printf(" Tax: %22s\n", tax)

fmt.Printf(" Total: %22s\n", total)

{{out}}

<pre>

 

=={{header|Haskell}}==

import Text.Printf

 

printAmount "Subtotal" subtotal

printAmount "Tax" tx

 

{{out}}

We use a naive implementation with arbitrary precision (rational) numbers:

 

Items=: ;: 'Hamburger Milkshake'

)

 

{{out}}

<pre> Item Price Quantity Value

 

=={{header|Java}}==

import java.util.*;

 

System.out.printf(" Total: %20.2f%n", subtotal.add(tax));

}

 

<pre>Subtotal: 22000000000000005.72

 

=={{header|JavaScript}}==

 

let hamburgers = 4000000000000000

console.log('Tax:', taxTotal)

console.log('Total:', total)

 

=={{header|jq}}==

results as dollars and cents, and when calculating the taxes.

 

 

# print as dollars and cents

" Total before tax: \($before_tax | dollars($width))",

" - tax: \($taxes | cents | dollars($width))",

{{out}}

<pre>

{{works with|Julia|1.2}}

 

 

p = [big"5.50", big"2.86"]

@printf " - tot. before tax: %20.2f \$\n" beftax

@printf " - tax: %20.2f \$\n" tax

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.math.BigDecimal

println("Tax thereon @ 7.65% : ${fmt.format(tax)}")

println("Total price after tax : ${fmt.format(price + tax)}")

 

{{out}}

=={{header|Lua}}==

Using the lbc library for arbitrary precision support.

C.digits(6) -- enough for .nn * .nnnn ==> .nnnnnn, follow with trunc(2) to trim trailing zeroes

 

print(("Before tax: %20s"):format(subtot:tostring()))

print(("Tax : %20s"):format(tax:tostring()))

{{out}}

<pre>Before tax: 22000000000000005.72

=={{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].

Module Currency_Task {

Locale 1033

}

Currency_Task

Optional with $ and thousands separator (a smaller version from above)

Module Currency_Task {

Locale 1033

}

Currency_Task

{{out}}

<pre style="height:30ex;overflow:scroll">

 

=={{header|Maple}}==

 

Digits := 50;

totalprice := totaltax + total;

printf("%.2f\n",totalprice);

{{out}}

<pre>

 

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

AccountingForm[N[total, 20], {\[Infinity], 2}]

tax = total Rationalize[0.0765];

AccountingForm[N[tax, 20], {\[Infinity], 2}]

{{out}}

<pre>22000000000000005.72

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

 

echo "Total price before tax: ", beforeTaxStr.align(length)

echo "Tax: ", taxStr.align(length)

 

{{out}}

Using the [https://github.com/janestreet/bignum Bignum] library.

 

 

let p1 = Bignum.((of_string "4000000000000000") * (of_float_decimal 5.50)) ;;

Printf.printf "tax: %s\n" (my_to_string r2);

Printf.printf "total: %s\n" (my_to_string r3);

{{out}}

<pre>

 

=={{header|Perl}}==

 

@check = (

($q, $r) = dec_rndiv_and_rem("FLR", @_[0], 1);

$q . substr((sprintf "%.2f", $r), 1, 3);

{{out}}

<pre>Item Price Quantity Extension

=={{header|Phix}}==

{{libheader|Phix/mpfr}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.0"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (mpfr_set_default_prec[ision] has been renamed)</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:%21s\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: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" Total:%21s\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>

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let

(Before

(tab Fmt "Total before tax:" (format Before *Scl "." ","))

(tab Fmt "Tax:" (format Tax *Scl "." ","))

{{out}}

<pre>

(and some copying of names from the Raku example).

 

from collections import namedtuple

 

total = total_before_tax + tax

print(fmt % ('', '', '', '--------------------'))

 

{{out}}

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

(for-each show-item all)

(newline)

{{out}}

<pre>hamburger 4000000000000000 $5.50 -> $22000000000000000.00

(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.))

Hamburger 5.50 4000000000000000

Milkshake 2.86 2

 

# make up for lack of a Rat fixed-point printf format

{{out}}

<pre>Item Price Quantity Extension

Programming note: &nbsp; the tax rate can be expressed with or without a percent &nbsp; ('''%''')&nbsp; suffix.

===without commas===

numeric digits 200 /*support for gihugic numbers.*/

taxRate= 7.65 /*number is: nn or nn% */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; (attempting to mimic a check-out register to some degree):}}

<pre>

 

===with commas===

numeric digits 200 /*support for gihugic numbers.*/

taxRate= 7.65 /*number is: nn or nn% */

do j=e to b by -3; _= insert(',', _, j); end /*j*/; return _

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; with commas in the larger numbers:}}

<pre>

 

=={{header|Ring}}==

# Project : Currency

 

see "tax thereon @ 7.65 : " + tax + nl

see "total price after tax : " + (price + tax) + nl

Output:

<pre>

</pre>

=={{header|Ruby}}==

 

before_tax = 4000000000000000 * 5.50.to_d + 2 * 2.86.to_d

Tax: $#{tax.to_s('F')}

Total: $#{total.to_s('F')}"

{{out}}

<pre>Before tax: $22000000000000005.72

 

=={{header|Rust}}==

extern crate num_rational; // 0.3.0

 

}

}

{{out}}

<pre>

 

{{libheader|Scala}}Locale is manipulated to demonstrate the behavior with other currencies.

import java.util.Locale

 

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

=={{header|Sidef}}==

{{trans|Raku}}

name, price, quant

}

 

var total = subtotal+tax

{{out}}

<pre>

Using ScaledDecimal numbers ('sX'-suffix).

{{works with|Smalltalk/X}}

" amount name price "

(4000000000000000 'hamburger' 5.50s2 )

Transcript printf:fmt withAll:{'' . '' . 'Total' . (totalSum+totalTax)}.

 

{{out}}

<pre>Item Price Qty Extension

=={{header|Swift}}==

 

 

extension Decimal {

print("Price before tax: $\(totalBeforeTax)")

print("Total tax to be collected: $\(taxesToBeCollected)")

 

{{out}}

 

=={{header|Tcl}}==

namespace import math::decimal::*

 

set total [+ $net $tax]

 

{{out}}

net=22000000000000005.72, tax=1683000000000000.44, total=23683000000000006.16

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

'the total with tax

Debug.Print "Total with tax "; Format(total_price_before_tax + tax, "Currency")

<pre>Total price before tax € 22.000.000.000.000.005,72

Tax € 1.683.000.000.000.000,44

=={{header|Wren}}==

{{libheader|Wren-big}}

 

var hamburgers = BigRat.new("4000000000000000")

System.print("Total price before tax : %((totalPreTax).toDecimal(2))")

System.print("Tax : %((totalTax).toDecimal(2))")

 

{{out}}

So, just multiply bucks by 100 and be careful when doing tax calculations.

{{trans|Python}}

var taxRate=765; // percent*M

const M=0d10_000;

fmt.fmt("","","","--------------------").println();

fmt.fmt("","","Total",toBucks(totalBeforeTax + tax)).println();

{{out}}

<pre>