math.fractions: refactor and add more tests

vlib/math/fractions/fraction.v

@@ -1,105 +1,219 @@
 // Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
 // Use of this source code is governed by an MIT license
 // that can be found in the LICENSE file.
-
 module fractions
 
 import math
 import math.bits
 
 // Fraction Struct
+// A Fraction has a numerator (n) and a denominator (d). If the user uses
+// the helper functions in this module, then the following are guaranteed:
+// 1.
 struct Fraction {
-	n i64
+	n          i64
-	d i64
+	d          i64
+pub:
+	is_reduced bool
 }
 
 // A factory function for creating a Fraction, adds a boundary condition
-pub fn fraction(n i64, d i64) Fraction{
+// to ensure that the denominator is non-zero. It automatically converts
+// the negative denominator to positive and adjusts the numerator.
+// NOTE: Fractions created are not reduced by default.
+pub fn fraction(n, d i64) Fraction {
 	if d != 0 {
-		return Fraction{n, d}
+		// The denominator is always guaranteed to be positive (and non-zero).
-	} 
+		if d < 0 {
-	else {
+			return fraction(-n, -d)
+		} else {
+			return Fraction{
+				n: n
+				d: d
+				is_reduced: math.gcd(n, d) == 1
+			}
+		}
+	} else {
 		panic('Denominator cannot be zero')
 	}
 }
 
 // To String method
-pub fn (f Fraction) str() string { 
+pub fn (f Fraction) str() string {
-	return '$f.n/$f.d' 
+	return '$f.n/$f.d'
+}
+
+//
+// + ---------------------+
+// | Arithmetic functions.|
+// + ---------------------+
+//
+// These are implemented from Knuth, TAOCP Vol 2. Section 4.5
+//
+// Returns a correctly reduced result for both addition and subtraction
+fn general_addition_result(f1, f2 Fraction, addition bool) Fraction {
+	d1 := math.gcd(f1.d, f2.d)
+	// d1 happends to be 1 around 600/(pi)^2 or 61 percent of the time (Theorem 4.5.2D)
+	if d1 == 1 {
+		mut n := i64(0)
+		num1n2d := f1.n * f2.d
+		num1d2n := f1.d * f2.n
+		if addition {
+			n = num1n2d + num1d2n
+		} else {
+			n = num1n2d - num1d2n
+		}
+		return Fraction{
+			n: n
+			d: f1.d * f2.d
+			is_reduced: true
+		}
+	}
+	// Here d1 > 1.
+	// Without the i64(...), t is declared as an int
+	// and it does not have enough precision
+	mut t := i64(0)
+	term1 := f1.n * (f2.d / d1)
+	term2 := f2.n * (f1.d / d1)
+	if addition {
+		t = term1 + term2
+	} else {
+		t = term1 - term2
+	}
+	d2 := math.gcd(t, d1)
+	return Fraction{
+		n: t / d2
+		d: (f1.d / d1) * (f2.d / d2)
+		is_reduced: true
+	}
 }
 
 // Fraction add using operator overloading
-pub fn (f1 Fraction) + (f2 Fraction) Fraction {
+pub fn (f1 Fraction) +(f2 Fraction) Fraction {
-	if f1.d == f2.d {
+	return general_addition_result(f1.reduce(), f2.reduce(), true)
-		return Fraction{f1.n + f2.n, f1.d}
-	}
-	else {
-		return Fraction{(f1.n * f2.d) + (f2.n * f1.d), f1.d * f2.d}
-	}
 }
 
 // Fraction subtract using operator overloading
-pub fn (f1 Fraction) - (f2 Fraction) Fraction {
+pub fn (f1 Fraction) -(f2 Fraction) Fraction {
-	if f1.d == f2.d {
+	return general_addition_result(f1.reduce(), f2.reduce(), false)
-		return Fraction{f1.n - f2.n, f1.d}
+}
+
+// Returns a correctly reduced result for both multiplication and division
+fn general_multiplication_result(f1, f2 Fraction, multiplication bool) Fraction {
+	// Theorem: If f1 and f2 are reduced i.e. gcd(f1.n, f1.d) ==  1 and gcd(f2.n, f2.d) == 1,
+	// then gcd(f1.n * f2.n, f1.d * f2.d) == gcd(f1.n, f2.d) * gcd(f1.d, f2.n)
+	// Knuth poses this an exercise for 4.5.1. - Exercise 2
+	mut d1 := i64(0)
+	mut d2 := i64(0)
+	mut n := i64(0)
+	mut d := i64(0)
+	// The terms are flipped for multiplication and division, so the gcds must be calculated carefully
+	// We do multiple divisions in order to prevent any possible overflows. Also, note that:
+	// if d = gcd(a, b) for example, then d divides both a and b
+	if multiplication {
+		d1 = math.gcd(f1.n, f2.d)
+		d2 = math.gcd(f1.d, f2.n)
+		n = (f1.n / d1) * (f2.n / d2)
+		d = (f2.d / d1) * (f1.d / d2)
+	} else {
+		d1 = math.gcd(f1.n, f2.n)
+		d2 = math.gcd(f1.d, f2.d)
+		n = (f1.n / d1) * (f2.d / d2)
+		d = (f2.n / d1) * (f1.d / d2)
 	}
-	else {
+	return Fraction{
-		return Fraction{(f1.n * f2.d) - (f2.n * f1.d), f1.d * f2.d}
+		n: n
+		d: d
+		is_reduced: true
 	}
 }
 
 // Fraction multiply using operator overloading
-// pub fn (f1 Fraction) * (f2 Fraction) Fraction {
+pub fn (f1 Fraction) *(f2 Fraction) Fraction {
-// 	return Fraction{f1.n * f2.n,f1.d * f2.d}
+	return general_multiplication_result(f1.reduce(), f2.reduce(), true)
-// }
+}
 
 // Fraction divide using operator overloading
-// pub fn (f1 Fraction) / (f2 Fraction) Fraction {
+pub fn (f1 Fraction) /(f2 Fraction) Fraction {
-// 	return Fraction{f1.n * f2.d,f1.d * f2.n}
+	if f2.n == 0 {
-// }
+		panic('Cannot divive by zero')
+	}
+	// If the second fraction is negative, it will
+	// mess up the sign. We need positive denominator
+	if f2.n < 0 {
+		return f1.negate() / f2.negate()
+	}
+	return general_multiplication_result(f1.reduce(), f2.reduce(), false)
+}
 
-// Fraction add method
+// Fraction add method. Deprecated. Use the operator instead.
+[deprecated]
 pub fn (f1 Fraction) add(f2 Fraction) Fraction {
 	return f1 + f2
 }
 
-// Fraction subtract method
+// Fraction subtract method. Deprecated. Use the operator instead.
+[deprecated]
 pub fn (f1 Fraction) subtract(f2 Fraction) Fraction {
 	return f1 - f2
 }
 
-// Fraction multiply method
+// Fraction multiply method. Deprecated. Use the operator instead.
+[deprecated]
 pub fn (f1 Fraction) multiply(f2 Fraction) Fraction {
-	return Fraction{f1.n * f2.n, f1.d * f2.d}
+	return f1 * f2
 }
 
-// Fraction divide method
+// Fraction divide method. Deprecated. Use the operator instead.
+[deprecated]
 pub fn (f1 Fraction) divide(f2 Fraction) Fraction {
-	return Fraction{f1.n * f2.d, f1.d * f2.n}
+	return f1 / f2
+}
+
+// Fraction negate method
+pub fn (f1 Fraction) negate() Fraction {
+	return Fraction{
+		n: -f1.n
+		d: f1.d
+		is_reduced: f1.is_reduced
+	}
 }
 
 // Fraction reciprocal method
 pub fn (f1 Fraction) reciprocal() Fraction {
-	if f1.n == 0 { panic('Denominator cannot be zero') }
+	if f1.n == 0 {
-	return Fraction{f1.d, f1.n}
+		panic('Denominator cannot be zero')
-}
+	}
-
+	return Fraction{
-// Fraction method which gives greatest common divisor of numerator and denominator
+		n: f1.d
-pub fn (f1 Fraction) gcd() i64 {
+		d: f1.n
-	return math.gcd(f1.n, f1.d)
+		is_reduced: f1.is_reduced
+	}
 }
 
 // Fraction method which reduces the fraction
 pub fn (f1 Fraction) reduce() Fraction {
-	cf := f1.gcd()
+	if f1.is_reduced {
-	return Fraction{f1.n / cf, f1.d / cf}
+		return f1
+	}
+	cf := math.gcd(f1.n, f1.d)
+	return Fraction{
+		n: f1.n / cf
+		d: f1.d / cf
+		is_reduced: true
+	}
 }
 
-// Converts Fraction to decimal
+// f64 converts the Fraction to 64-bit floating point
 pub fn (f1 Fraction) f64() f64 {
 	return f64(f1.n) / f64(f1.d)
 }
 
+//
+// + ------------------+
+// | Utility functions.|
+// + ------------------+
+//
 // Returns the absolute value of an i64
 fn abs(num i64) i64 {
 	if num < 0 {
@@ -109,18 +223,65 @@ fn abs(num i64) i64 {
 	}
 }
 
+fn cmp_i64s(a, b i64) int {
+	if a == b {
+		return 0
+	} else if a > b {
+		return 1
+	} else {
+		return -1
+	}
+}
+
+fn cmp_f64s(a, b f64) int {
+	// V uses epsilon comparison internally
+	if a == b {
+		return 0
+	} else if a > b {
+		return 1
+	} else {
+		return -1
+	}
+}
+
 // Two integers are safe to multiply when their bit lengths
 // sum up to less than 64 (conservative estimate).
 fn safe_to_multiply(a, b i64) bool {
 	return (bits.len_64(abs(a)) + bits.len_64(abs(b))) < 64
 }
 
-// Compares two Fractions
+fn cmp(f1, f2 Fraction) int {
-pub fn (f1 Fraction) equals(f2 Fraction) bool {
 	if safe_to_multiply(f1.n, f2.d) && safe_to_multiply(f2.n, f1.d) {
-		return (f1.n * f2.d) == (f2.n * f1.d)
+		return cmp_i64s(f1.n * f2.d, f2.n * f1.d)
+	} else {
+		return cmp_f64s(f1.f64(), f2.f64())
 	}
-	r1 := f1.reduce()
+}
-	r2 := f2.reduce()
+
-	return (r1.n == r2.n) && (r1.d == r2.d)
+// +-----------------------------+
+// | Public comparison functions |
+// +-----------------------------+
+// equals returns true if both the Fractions are equal
+pub fn (f1 Fraction) equals(f2 Fraction) bool {
+	return cmp(f1, f2) == 0
+}
+
+// ge returns true if f1 >= f2
+pub fn (f1 Fraction) ge(f2 Fraction) bool {
+	return cmp(f1, f2) >= 0
+}
+
+// gt returns true if f1 > f2
+pub fn (f1 Fraction) gt(f2 Fraction) bool {
+	return cmp(f1, f2) > 0
+}
+
+// le returns true if f1 <= f2
+pub fn (f1 Fraction) le(f2 Fraction) bool {
+	return cmp(f1, f2) <= 0
+}
+
+// lt returns true if f1 < f2
+pub fn (f1 Fraction) lt(f2 Fraction) bool {
+	return cmp(f1, f2) < 0
 }

vlib/math/fractions/fraction_test.v

@@ -1,153 +1,266 @@
-import math.fractions as fractions
+import math.fractions
 
-// Results are verified using https://www.calculatorsoup.com/calculators/math/fractions.php
+// (Old) results are verified using https://www.calculatorsoup.com/calculators/math/fractions.php
-
+// Newer ones are contrived for corner cases or prepared by hand.
-fn test_fraction_creation() {
+fn test_4_by_8_f64_and_str() {
-	mut f1 := fractions.fraction(4,8)
+	f := fractions.fraction(4, 8)
-	assert f1.f64() == 0.5
+	assert f.f64() == 0.5
-	assert f1.str().eq('4/8')
+	assert f.str() == '4/8'
-	f1 = fractions.fraction(10,5)
-	assert f1.f64() == 2.0
-	assert f1.str().eq('10/5')
-	f1 = fractions.fraction(9,3)
-	assert f1.f64() == 3.0
-	assert f1.str().eq('9/3')
 }
 
-fn test_fraction_add() {
+fn test_10_by_5_f64_and_str() {
-	mut f1 := fractions.fraction(4,8)
+	f := fractions.fraction(10, 5)
-	mut f2 := fractions.fraction(5,10)
+	assert f.f64() == 2.0
-	mut sum := f1 + f2
+	assert f.str() == '10/5'
+}
+
+fn test_9_by_3_f64_and_str() {
+	f := fractions.fraction(9, 3)
+	assert f.f64() == 3.0
+	assert f.str() == '9/3'
+}
+
+fn test_4_by_minus_5_f64_and_str() {
+	f := fractions.fraction(4, -5)
+	assert f.f64() == -0.8
+	assert f.str() == '-4/5'
+}
+
+fn test_minus_7_by_minus_92_str() {
+	f := fractions.fraction(-7, -5)
+	assert f.str() == '7/5'
+}
+
+fn test_4_by_8_plus_5_by_10() {
+	f1 := fractions.fraction(4, 8)
+	f2 := fractions.fraction(5, 10)
+	sum := f1 + f2
 	assert sum.f64() == 1.0
-	assert sum.str().eq('80/80')
+	assert sum.str() == '1/1'
-	f1 = fractions.fraction(5,5)
+	assert sum.equals(fractions.fraction(1, 1))
-	f2 = fractions.fraction(8,8)
+}
-	sum = f1 + f2
+
+fn test_5_by_5_plus_8_by_8() {
+	f1 := fractions.fraction(5, 5)
+	f2 := fractions.fraction(8, 8)
+	sum := f1 + f2
 	assert sum.f64() == 2.0
-	assert sum.str().eq('80/40')
+	assert sum.str() == '2/1'
-	f1 = fractions.fraction(9,3)
+	assert sum.equals(fractions.fraction(2, 1))
-	f2 = fractions.fraction(1,3)
-	sum = f1 + f2
-	$if debug {
-		println(sum.f64())
-	}
-	assert sum.str().eq('10/3')
-	f1 = fractions.fraction(3,7)
-	f2 = fractions.fraction(1,4)
-	sum = f1 + f2
-	$if debug {
-		println(sum.f64())
-	}
-	assert sum.str().eq('19/28')
 }
 
-fn test_fraction_subtract() {
+fn test_9_by_3_plus_1_by_3() {
-	mut f1 := fractions.fraction(4,8)
+	f1 := fractions.fraction(9, 3)
-	mut f2 := fractions.fraction(5,10)
+	f2 := fractions.fraction(1, 3)
-	mut diff := f2 - f1
+	sum := f1 + f2
-	assert diff.f64() == 0
+	assert sum.str() == '10/3'
-	assert diff.str().eq('0/80')
+	assert sum.equals(fractions.fraction(10, 3))
-	f1 = fractions.fraction(5,5)
-	f2 = fractions.fraction(8,8)
-	diff = f2 - f1
-	assert diff.f64() == 0
-	assert diff.str().eq('0/40')
-	f1 = fractions.fraction(9,3)
-	f2 = fractions.fraction(1,3)
-	diff = f1 - f2
-	$if debug {
-		println(diff.f64())
-	}
-	assert diff.str().eq('8/3')
-	f1 = fractions.fraction(3,7)
-	f2 = fractions.fraction(1,4)
-	diff = f1 - f2
-	$if debug {
-		println(diff.f64())
-	}
-	assert diff.str().eq('5/28')
 }
 
-fn test_fraction_multiply() {
+fn test_3_by_7_plus_1_by_4() {
-	mut f1 := fractions.fraction(4,8)
+	f1 := fractions.fraction(3, 7)
-	mut f2 := fractions.fraction(5,10)
+	f2 := fractions.fraction(1, 4)
-	mut product := f1.multiply(f2)
+	sum := f1 + f2
+	assert sum.str() == '19/28'
+	assert sum.equals(fractions.fraction(19, 28))
+}
+
+fn test_36529_by_12409100000_plus_418754901_by_9174901000() {
+	f1 := fractions.fraction(i64(36529), i64(12409100000))
+	f2 := fractions.fraction(i64(418754901), i64(9174901000))
+	sum := f1 + f2
+	assert sum.str() == '5196706591957729/113852263999100000'
+}
+
+fn test_4_by_8_plus_minus_5_by_10() {
+	f1 := fractions.fraction(4, 8)
+	f2 := fractions.fraction(-5, 10)
+	diff := f2 + f1
+	assert diff.f64() == 0
+	assert diff.str() == '0/1'
+}
+
+fn test_4_by_8_minus_5_by_10() {
+	f1 := fractions.fraction(4, 8)
+	f2 := fractions.fraction(5, 10)
+	diff := f2 - f1
+	assert diff.f64() == 0
+	assert diff.str() == '0/1'
+}
+
+fn test_5_by_5_minus_8_by_8() {
+	f1 := fractions.fraction(5, 5)
+	f2 := fractions.fraction(8, 8)
+	diff := f2 - f1
+	assert diff.f64() == 0
+	assert diff.str() == '0/1'
+}
+
+fn test_9_by_3_minus_1_by_3() {
+	f1 := fractions.fraction(9, 3)
+	f2 := fractions.fraction(1, 3)
+	diff := f1 - f2
+	assert diff.str() == '8/3'
+}
+
+fn test_3_by_7_minus_1_by_4() {
+	f1 := fractions.fraction(3, 7)
+	f2 := fractions.fraction(1, 4)
+	diff := f1 - f2
+	assert diff.str() == '5/28'
+}
+
+fn test_36529_by_12409100000_minus_418754901_by_9174901000() {
+	f1 := fractions.fraction(i64(36529), i64(12409100000))
+	f2 := fractions.fraction(i64(418754901), i64(9174901000))
+	sum := f1 - f2
+	assert sum.str() == '-5196036292040471/113852263999100000'
+}
+
+fn test_4_by_8_times_5_by_10() {
+	f1 := fractions.fraction(4, 8)
+	f2 := fractions.fraction(5, 10)
+	product := f1 * f2
 	assert product.f64() == 0.25
-	assert product.str().eq('20/80')
+	assert product.str() == '1/4'
-	f1 = fractions.fraction(5,5)
+}
-	f2 = fractions.fraction(8,8)
+
-	product = f1.multiply(f2)
+fn test_5_by_5_times_8_by_8() {
+	f1 := fractions.fraction(5, 5)
+	f2 := fractions.fraction(8, 8)
+	product := f1 * f2
 	assert product.f64() == 1.0
-	assert product.str().eq('40/40')
+	assert product.str() == '1/1'
-	f1 = fractions.fraction(9,3)
+}
-	f2 = fractions.fraction(1,3)
+
-	product = f1.multiply(f2)
+fn test_9_by_3_times_1_by_3() {
+	f1 := fractions.fraction(9, 3)
+	f2 := fractions.fraction(1, 3)
+	product := f1 * f2
 	assert product.f64() == 1.0
-	assert product.str().eq('9/9')
+	assert product.str() == '1/1'
-	f1 = fractions.fraction(3,7)
-	f2 = fractions.fraction(1,4)
-	product = f1.multiply(f2)
-	$if debug {
-		println(product.f64())
-	}
-	assert product.str().eq('3/28')
 }
 
-fn test_fraction_divide() {
+fn test_3_by_7_times_1_by_4() {
-	mut f1 := fractions.fraction(4,8)
+	f1 := fractions.fraction(3, 7)
-	mut f2 := fractions.fraction(5,10)
+	f2 := fractions.fraction(1, 4)
-	mut re := f1.divide(f2)
+	product := f2 * f1
-	assert re.f64() == 1.0
+	assert product.f64() == (3.0 / 28.0)
-	assert re.str().eq('40/40')
+	assert product.str() == '3/28'
-	f1 = fractions.fraction(5,5)
-	f2 = fractions.fraction(8,8)
-	re = f1.divide(f2)
-	assert re.f64() == 1.0
-	assert re.str().eq('40/40')
-	f1 = fractions.fraction(9,3)
-	f2 = fractions.fraction(1,3)
-	re = f1.divide(f2)
-	assert re.f64() == 9.0
-	assert re.str().eq('27/3')
-	f1 = fractions.fraction(3,7)
-	f2 = fractions.fraction(1,4)
-	re = f1.divide(f2)
-	$if debug {
-		println(re.f64())
-	}
-	assert re.str().eq('12/7')
 }
 
-fn test_fraction_reciprocal() {
+fn test_4_by_8_over_5_by_10() {
-	mut f1 := fractions.fraction(4,8)
+	f1 := fractions.fraction(4, 8)
-	assert f1.reciprocal().str().eq('8/4')
+	f2 := fractions.fraction(5, 10)
-	f1 = fractions.fraction(5,10)
+	q := f1 / f2
-	assert f1.reciprocal().str().eq('10/5')
+	assert q.f64() == 1.0
-	f1 = fractions.fraction(5,5)
+	assert q.str() == '1/1'
-	assert f1.reciprocal().str().eq('5/5')
-	f1 = fractions.fraction(8,8)
-	assert f1.reciprocal().str().eq('8/8')
-	f1 = fractions.fraction(9,3)
-	assert f1.reciprocal().str().eq('3/9')
-	f1 = fractions.fraction(1,3)
-	assert f1.reciprocal().str().eq('3/1')
-	f1 = fractions.fraction(3,7)
-	assert f1.reciprocal().str().eq('7/3')
-	f1 = fractions.fraction(1,4)
-	assert f1.reciprocal().str().eq('4/1')
 }
 
-fn test_fraction_equals() {
+fn test_5_by_5_over_8_by_8() {
-	mut f1 := fractions.fraction(4,8)
+	f1 := fractions.fraction(5, 5)
-	mut f2 := fractions.fraction(5,10)
+	f2 := fractions.fraction(8, 8)
+	q := f1 / f2
+	assert q.f64() == 1.0
+	assert q.str() == '1/1'
+}
+
+fn test_9_by_3_over_1_by_3() {
+	f1 := fractions.fraction(9, 3)
+	f2 := fractions.fraction(1, 3)
+	q := f1 / f2
+	assert q.f64() == 9.0
+	assert q.str() == '9/1'
+}
+
+fn test_3_by_7_over_1_by_4() {
+	f1 := fractions.fraction(3, 7)
+	f2 := fractions.fraction(1, 4)
+	q := f1 / f2
+	assert q.str() == '12/7'
+}
+
+fn test_reciprocal_4_by_8() {
+	f := fractions.fraction(4, 8)
+	assert f.reciprocal().str() == '8/4'
+}
+
+fn test_reciprocal_5_by_10() {
+	f := fractions.fraction(5, 10)
+	assert f.reciprocal().str() == '10/5'
+}
+
+fn test_reciprocal_5_by_5() {
+	f := fractions.fraction(5, 5)
+	assert f.reciprocal().str() == '5/5'
+}
+
+fn test_reciprocal_8_by_8() {
+	f := fractions.fraction(8, 8)
+	assert f.reciprocal().str() == '8/8'
+}
+
+fn test_reciprocal_9_by_3() {
+	f := fractions.fraction(9, 3)
+	assert f.reciprocal().str() == '3/9'
+}
+
+fn test_reciprocal_1_by_3() {
+	f := fractions.fraction(1, 3)
+	assert f.reciprocal().str() == '3/1'
+}
+
+fn test_reciprocal_7_by_3() {
+	f := fractions.fraction(7, 3)
+	assert f.reciprocal().str() == '3/7'
+}
+
+fn test_reciprocal_1_by_4() {
+	f := fractions.fraction(1, 4)
+	assert f.reciprocal().str() == '4/1'
+}
+
+fn test_4_by_8_equals_5_by_10() {
+	f1 := fractions.fraction(4, 8)
+	f2 := fractions.fraction(5, 10)
 	assert f1.equals(f2)
-	f1 = fractions.fraction(1,2)
+}
-	f2 = fractions.fraction(3,4)
+
+fn test_1_by_2_does_not_equal_3_by_4() {
+	f1 := fractions.fraction(1, 2)
+	f2 := fractions.fraction(3, 4)
 	assert !f1.equals(f2)
 }
 
-fn test_gcd_and_reduce(){
+fn test_reduce_3_by_9() {
 	f := fractions.fraction(3, 9)
-	assert f.gcd() == 3
 	assert f.reduce().equals(fractions.fraction(1, 3))
 }
+
+fn test_1_by_3_less_than_2_by_4() {
+	f1 := fractions.fraction(1, 3)
+	f2 := fractions.fraction(2, 4)
+	assert f1.lt(f2)
+	assert f1.le(f2)
+}
+
+fn test_2_by_3_greater_than_2_by_4() {
+	f1 := fractions.fraction(2, 3)
+	f2 := fractions.fraction(2, 4)
+	assert f1.gt(f2)
+	assert f1.ge(f2)
+}
+
+fn test_5_by_7_not_less_than_2_by_4() {
+	f1 := fractions.fraction(5, 7)
+	f2 := fractions.fraction(2, 4)
+	assert !f1.lt(f2)
+	assert !f1.le(f2)
+}
+
+fn test_49_by_75_not_greater_than_2_by_3() {
+	f1 := fractions.fraction(49, 75)
+	f2 := fractions.fraction(2, 3)
+	assert !f1.gt(f2)
+	assert !f1.ge(f2)
+}