不同国家有不同的货币流通,不同的货币也会有不同的价值。其实也不只货币,任何物品,无论实体的或是虚拟的都一样,只要价值可以被衡量,就可以被等值换算。讲到钱就伤感情,以苹果和橘子来举例好了,假设 2 颗苹果等值于 3 粒橘子,那么 8 颗苹果就会等值于 12 粒橘子。
物品的价值
「2 颗苹果等值于 3 粒橘子」,我们可以说 1 颗苹果的价值为 #{{3 \over 2}}# 粒橘子。所以 #{{n}}# 颗苹果,就会等值于 #{{n \times {3 \over 2}}}# 粒橘子。
货币也是同样的概念,假设 1 元 #{{A}}# 币等值于 1 颗苹果,再假设 1 元 #{{B}}# 币等值于半颗苹果,所以 1 元 #{{A}}# 币等值于 2 元 #{{B}}# 币,若有 #{{n}}# 元 #{{A}}# 币就会等值于 #{{2n}}# 元 #{{B}}# 币。
将以上的假设化为代数可列式如下:
#{{{
\text{若 n 元A币的价值 $=$ m 元B币的价值}
}}}#
#{{{
{{n \times \text{1元A币的价值}} \over {m \times \text{1元B币的价值}}} = 1
}}}#
#{{{
m = n \times {\text{1元A币的价值} \over \text{1元B币的价值}}
}}}#
汇率
汇率是一种货币兑换另一种货币的比率。假设现在还是一样有 #{{A}}#、#{{B}}# 两种货币,#{{A}}# 币对 #{{B}}# 币的汇率就是:
#{{{
汇率 = {\text{1元A币的价值} \over \text{1元B币的价值}}
}}}#
#{{{
\text{若 n 元A币的价值 $=$ m 元B币的价值}
}}}#
#{{{
\begin{alignedat}{2}
m &{}={}&& n \times {\text{1元A币的价值} \over \text{1元B币的价值}} \\
&{}={}&& n \times \text{A币对B币的汇率}
\end{alignedat}
}}}#
物品的最小单位
假设 2 颗苹果等值于 30 粒葡萄,我们可以说 1 颗苹果的价值为 15 粒葡萄,所以 #{{n}}# 颗苹果,就会等值于 #{{15n}}# 粒葡萄。
然而当我们实际在应用苹果和葡萄的等值数量换算时(例如等值交换),我们想要让苹果总是完整的 4 颗一盒,而葡萄总是完整的 30 颗一串。在这样的情况下,就要确保 #{{n}}# 是 4 的倍数,且 #{{15n}}# 是 30 的倍数,所以 #{{n}}# 要是什么数的倍数才能够同时符合这些条件呢?
我们可以先找出最小数量单位(4 颗)的苹果的价值,再找出最小数量单位(30 颗)的葡萄的价值,取它们的最小公倍数(LCM, Least Common Multiple),就是「#{{n}}# 要是什么数的倍数」的那个数,称它为 #{{m}}# 吧!#{{n}}# 若是 #{{m}}# 的倍数,就可以同时符合苹果和葡萄的最小数量单位。#{{m}}# 的计算过程如下:
#{{{
\begin{alignedat}{2}
m &{}={}&& lcm(\text{苹果的最小数量单位} \times \text{1颗苹果的价值}, \\
&{}\text{ }{}&& \text{葡萄的最小单位} \times \text{1颗葡萄的价值}) \\
&{}={}&& lcm({4 \times 1}, {30 \times {1 \over 15}}) \\
&{}={}&& lcm(4, 2) \\
&{}={}&& 4
\end{alignedat}
}}}#
苹果必须要是 #{{m \over \text{1颗苹果的价值}}}# 的倍数;葡萄必须要是 #{{m \over \text{1颗葡萄的价值}}}# 的倍数。
货币也会有最小数量单位的问题,像是最小的美金就是 1 美分,相当于 0.01 元美金;而台币是 1 元。
初步的程序实作
统整一下,要用程序做等值的货币或是物品的数量换算,我们会需要它们各自的价值和最小数量单位。此外,还会需要做最小公倍数的运算,所以如果您不熟悉写程序算最小公倍数的话,可以查看这篇文章:
程序实作如下:
#[derive(Debug, Copy, Clone)]
pub struct Item {
pub value: f64,
pub unit_number: f64,
}
#[derive(Debug)]
pub struct MultipleFactorsOfAB {
pub a_factor: f64,
pub b_factor: f64,
}
pub fn evaluate_a_to_b(a: Item, a_number: f64, b: Item) -> Result<f64, &'static str> {
if !is_divisible(a_number, a.unit_number) {
return Err("The number of A is invalid.");
}
let b_number = a_number * a.value / b.value;
if !is_divisible(b_number, b.unit_number) {
return Err("The number of A is not quite valid.");
}
Ok(b_number)
}
pub fn get_multiple_factors_of_ab(a: Item, b: Item) -> MultipleFactorsOfAB {
let m = lcm(a.unit_number * a.value, b.unit_number * b.value);
MultipleFactorsOfAB {
a_factor: m / a.value,
b_factor: m / b.value,
}
}
fn is_divisible(dividend: f64, divisor: f64) -> bool {
let quotient = dividend / divisor;
quotient == quotient.round()
}
fn lcm(a: f64, b: f64) -> f64 {
a * b / gcd(a, b)
}
fn gcd(mut a: f64, mut b: f64) -> f64 {
if b > a {
core::mem::swap(&mut a, &mut b);
}
let mut m = a % b;
while m != 0.0 {
a = b;
b = m;
m = a % b;
}
b
}
fn main() {
let apples = Item {
value: 1.0,
unit_number: 4.0,
};
let grapes = Item {
value: 1.0 / 15.0,
unit_number: 30.0,
};
println!("{:?}", get_multiple_factors_of_ab(apples, grapes));
println!("{:?}", evaluate_a_to_b(apples, 4.0, grapes));
}
public class ItemExchange {
public static class Item {
public double value;
public double unitNumber;
public Item(final double value, final double unitNumber) {
this.value = value;
this.unitNumber = unitNumber;
}
}
public static class MultipleFactorsOfAB {
public double aFactor;
public double bFactor;
public MultipleFactorsOfAB(final double aFactor, final double bFactor) {
this.aFactor = aFactor;
this.bFactor = bFactor;
}
@Override
public String toString() {
return "aFactor=" + aFactor + ", bFactor=" + bFactor;
}
}
public static double evaluateAtoB(final Item a, final double aNumber, final Item b) {
if (!isDivisible(aNumber, a.unitNumber)) {
throw new IllegalArgumentException("The number of A is invalid.");
}
final double bNumber = aNumber * a.value / b.value;
if (!isDivisible(bNumber, b.unitNumber)) {
throw new IllegalArgumentException("The number of A is not quite valid.");
}
return bNumber;
}
public static MultipleFactorsOfAB getMultipleFactorsOfAB(final Item a, final Item b) {
final double m = lcm(a.unitNumber * a.value, b.unitNumber * b.value);
return new MultipleFactorsOfAB(m / a.value, m / b.value);
}
private static boolean isDivisible(final double dividend, final double divisor) {
final double quotient = dividend / divisor;
return quotient == Math.round(quotient);
}
private static double lcm(double a, double b) {
return a * b / gcd(a, b);
}
private static double gcd(double a, double b) {
if (b > a) {
final double c = b;
b = a;
a = c;
}
double m = a % b;
while (m != 0) {
a = b;
b = m;
m = a % b;
}
return b;
}
public static void main(final String[] args) {
final Item apples = new Item(1.0, 4.0);
final Item grapes = new Item(1.0 / 15.0, 30.0);
System.out.println(getMultipleFactorsOfAB(apples, grapes));
System.out.println(evaluateAtoB(apples, 4.0, grapes));
}
}
function evaluateAtoB(a, aNumber, b) {
if (!isDivisible(aNumber, a.unitNumber)) {
throw new Error("The number of A is invalid.");
}
const bNumber = aNumber * a.value / b.value;
if (!isDivisible(bNumber, b.unitNumber)) {
throw new Error("The number of A is not quite valid.");
}
return bNumber;
}
function getMultipleFactorsOfAB(a, b) {
const m = lcm(a.unitNumber * a.value, b.unitNumber * b.value);
return {
aFactor: m / a.value,
bFactor: m / b.value
};
}
function isDivisible(dividend, divisor) {
const quotient = dividend / divisor;
return quotient == Math.round(quotient);
}
function lcm(a, b) {
return a * b / gcd(a, b);
}
function gcd(a, b) {
if (b > a) {
const c = b;
b = a;
a = c;
}
let m = a % b;
while (m !== 0) {
a = b;
b = m;
m = a % b;
}
return b;
}
const apples = {
value: 1.0,
unitNumber: 4.0,
};
const grapes = {
value: 1.0 / 15.0,
unitNumber: 30.0,
};
console.log(getMultipleFactorsOfAB(apples, grapes));
console.log(evaluateAtoB(apples, 4.0, grapes));
虽然以上程序的运行结果是正确的,但由于是使用浮点数来运算的关系,会有精准度问题,当输入别的参数数值时可能会得到错误的结果。可以参考这篇文章来处理浮点数的误差:
最终的程序实作
#[derive(Debug, Copy, Clone)]
pub struct Item {
pub value: f64,
pub unit_number: f64,
}
#[derive(Debug)]
pub struct MultipleFactorsOfAB {
pub a_factor: f64,
pub b_factor: f64,
}
pub fn evaluate_a_to_b(a: Item, a_number: f64, b: Item) -> Result<f64, &'static str> {
if !is_divisible(a_number, a.unit_number) {
return Err("The number of A is invalid.");
}
let b_number = a_number * a.value / b.value;
if !is_divisible(b_number, b.unit_number) {
return Err("The number of A is not quite valid.");
}
Ok(b_number)
}
pub fn get_multiple_factors_of_ab(a: Item, b: Item) -> MultipleFactorsOfAB {
let m = lcm(a.unit_number * a.value, b.unit_number * b.value);
MultipleFactorsOfAB {
a_factor: m / a.value,
b_factor: m / b.value,
}
}
fn is_divisible(dividend: f64, divisor: f64) -> bool {
if divisor.abs() < f64::MIN_POSITIVE {
dividend.abs() < f64::MIN_POSITIVE
} else {
let quotient = dividend / divisor;
is_equal(quotient, quotient.round())
}
}
fn lcm(a: f64, b: f64) -> f64 {
a * b / gcd(a, b)
}
fn gcd(mut a: f64, mut b: f64) -> f64 {
if b > a {
core::mem::swap(&mut a, &mut b);
}
let mut m = calculate_remainder(a, b);
while m != 0.0 {
a = b;
b = m;
m = calculate_remainder(a, b);
}
b
}
fn calculate_remainder(dividend: f64, divisor: f64) -> f64 {
let quotient = dividend / divisor;
let quotient_ceil = quotient.ceil();
let floor = if is_equal(quotient, quotient_ceil) {
quotient_ceil
} else {
quotient.floor()
};
dividend - (floor * divisor)
}
fn is_equal(a: f64, b: f64) -> bool {
if a == b {
return true;
} else {
let a_abs = a.abs();
let b_abs = b.abs();
let d_abs = (a - b).abs();
d_abs < a_abs.min(b_abs) * f64::EPSILON * 8.0
}
}
fn main() {
let apples = Item {
value: 1.0,
unit_number: 4.0,
};
let grapes = Item {
value: 1.0 / 15.0,
unit_number: 30.0,
};
println!("{:?}", get_multiple_factors_of_ab(apples, grapes));
println!("{:?}", evaluate_a_to_b(apples, 4.0, grapes));
}
public class ItemExchange {
public static class Item {
public double value;
public double unitNumber;
public Item(final double value, final double unitNumber) {
this.value = value;
this.unitNumber = unitNumber;
}
}
public static class MultipleFactorsOfAB {
public double aFactor;
public double bFactor;
public MultipleFactorsOfAB(final double aFactor, final double bFactor) {
this.aFactor = aFactor;
this.bFactor = bFactor;
}
@Override
public String toString() {
return "aFactor=" + aFactor + ", bFactor=" + bFactor;
}
}
public static double evaluateAtoB(final Item a, final double aNumber, final Item b) {
if (!isDivisible(aNumber, a.unitNumber)) {
throw new IllegalArgumentException("The number of A is invalid.");
}
final double bNumber = aNumber * a.value / b.value;
if (!isDivisible(bNumber, b.unitNumber)) {
throw new IllegalArgumentException("The number of A is not quite valid.");
}
return bNumber;
}
public static MultipleFactorsOfAB getMultipleFactorsOfAB(final Item a, final Item b) {
final double m = lcm(a.unitNumber * a.value, b.unitNumber * b.value);
return new MultipleFactorsOfAB(m / a.value, m / b.value);
}
private static boolean isDivisible(final double dividend, final double divisor) {
final double DBL_MIN_POSITIVE = Math.ulp(0.0);
if (Math.abs(divisor) < DBL_MIN_POSITIVE) {
return Math.abs(dividend) < DBL_MIN_POSITIVE;
} else {
final double quotient = dividend / divisor;
return isEqual(quotient, Math.round(quotient));
}
}
private static double lcm(double a, double b) {
return a * b / gcd(a, b);
}
private static double gcd(double a, double b) {
if (b > a) {
final double c = b;
b = a;
a = c;
}
double m = calculateRemainder(a, b);
while (m != 0) {
a = b;
b = m;
m = calculateRemainder(a, b);
}
return b;
}
private static double calculateRemainder(final double dividend, final double divisor) {
final double quotient = dividend / divisor;
final double quotientCeil = Math.ceil(quotient);
final double floor;
if (isEqual(quotient, quotientCeil)) {
floor = quotientCeil;
} else {
floor = Math.floor(quotient);
}
return Math.abs(dividend) - Math.abs(floor * divisor);
}
private static boolean isEqual(final double a, final double b) {
if (a == b) {
return true;
} else {
final double aAbs = Math.abs(a);
final double bAbs = Math.abs(b);
final double dAbs = Math.abs(a - b);
return dAbs < Math.min(aAbs, bAbs) * Math.ulp(1.0) * 8.0;
}
}
public static void main(final String[] args) {
final Item apples = new Item(1.0, 4.0);
final Item grapes = new Item(1.0 / 15.0, 30.0);
System.out.println(getMultipleFactorsOfAB(apples, grapes));
System.out.println(evaluateAtoB(apples, 4.0, grapes));
}
}
function evaluateAtoB(a, aNumber, b) {
if (!isDivisible(aNumber, a.unitNumber)) {
throw new Error("The number of A is invalid.");
}
const bNumber = aNumber * a.value / b.value;
if (!isDivisible(bNumber, b.unitNumber)) {
throw new Error("The number of A is not quite valid.");
}
return bNumber;
}
function getMultipleFactorsOfAB(a, b) {
const m = lcm(a.unitNumber * a.value, b.unitNumber * b.value);
return {
aFactor: m / a.value,
bFactor: m / b.value
};
}
function isDivisible(dividend, divisor) {
const DBL_MIN_POSITIVE = 4.9406564584124654e-324;
if (Math.abs(divisor) < DBL_MIN_POSITIVE) {
return Math.abs(dividend) < DBL_MIN_POSITIVE;
} else {
const quotient = dividend / divisor;
return isEqual(quotient, Math.round(quotient));
}
}
function lcm(a, b) {
return a * b / gcd(a, b);
}
function gcd(a, b) {
if (b > a) {
const c = b;
b = a;
a = c;
}
let m = calculateRemainder(a, b);
while (m !== 0) {
a = b;
b = m;
m = calculateRemainder(a, b);
}
return b;
}
function calculateRemainder(dividend, divisor) {
const quotient = dividend / divisor;
const quotientCeil = Math.ceil(quotient);
let floor;
if (isEqual(quotient, quotientCeil)) {
floor = quotientCeil;
} else {
floor = Math.floor(quotient);
}
return Math.abs(dividend) - Math.abs(floor * divisor);
}
function isEqual(a, b) {
if (a === b) {
return true;
} else {
const aAbs = Math.abs(a);
const bAbs = Math.abs(b);
const dAbs = Math.abs(a - b);
return dAbs < Math.min(aAbs, bAbs) * Number.EPSILON * 8.0;
}
}
const apples = {
value: 1.0,
unitNumber: 4.0,
};
const grapes = {
value: 1.0 / 15.0,
unitNumber: 30.0,
};
console.log(getMultipleFactorsOfAB(apples, grapes));
console.log(evaluateAtoB(apples, 4.0, grapes));
