Teil 1: Brüche kürzen | Aufgabe 1 bis 4

fraction.ts

@@ -4,7 +4,11 @@ export class Fraction {
   constructor(
     private numerator: number,
     private denominator: number,
-  ) {}
+  ) {
+    if (denominator === 0) {
+      throw new Error("Denominator cannot be 0");
+    }
+  }
 
   public add(other: Fraction) {
     const newNumerator =

fraction_test.ts

@@ -1,4 +1,4 @@
-import { assertAlmostEquals, assertEquals } from "@std/assert";
+import { assertAlmostEquals, assertEquals, assertThrows } from "@std/assert";
 import { Fraction } from "./fraction.ts";
 
 Deno.test("fraction of 1/1 is 1.0", () => {
@@ -34,3 +34,58 @@ Deno.test("1/3 + 2/6 = 2/3 is roughly 0.67", () => {
   // Assert
   assertAlmostEquals(left.toFloat(0.01), 0.67);
 });
+
+Deno.test("3/3 - 1/3 = 2/3 is roughly 0.67", () => {
+  const left = new Fraction(3, 3);
+  const right = new Fraction(1, 3);
+
+  left.subtract(right);
+
+  assertAlmostEquals(left.toFloat(0.01), 0.67);
+});
+
+Deno.test("4/4 * 1/2 = 2/4 is roughly 0.5", () => {
+  const left = new Fraction(4, 4);
+  const right = new Fraction(1, 2);
+
+  left.multiply(right);
+
+  assertAlmostEquals(left.toFloat(0.01), 0.5);
+});
+
+Deno.test("10/10 / 2/10 = 5/10 is roughly 0.5", () => {
+  const left = new Fraction(10, 10);
+  const right = new Fraction(2, 10)
+
+  left.divide(right);
+
+  assertAlmostEquals(left.toFloat(0.01), 5);
+});
+
+Deno.test("toString()", () => {
+  const fraction = new Fraction(3, 4);
+  const fractionString = fraction.toString();
+
+  assertEquals(fractionString, "3/4")
+});
+
+Deno.test("parse()", () => {
+  const fraction = Fraction.parse("3/4");
+  const fractionString = fraction.toString();
+
+  assertEquals(fractionString, "3/4");
+});
+
+Deno.test("Error when denominator is /0", () => { // https://deno-docs-ja.deno.dev/runtime/manual/basics/testing/assertions#throws
+  assertThrows(
+    () => new Fraction(3, 0),
+    Error,
+    "Denominator cannot be 0"
+  );
+
+  assertThrows(
+    () => Fraction.parse("3/0"),
+    Error,
+    "Denominator cannot be 0"
+  );
+});

gcd.ts

@@ -0,0 +1,33 @@
+export class numbers {
+    constructor(
+        public numerator: number,
+        public denominator: number,
+    ) {
+        if (denominator === 0) {
+            throw new Error("Denominator cannot be 0");
+        }
+        this.cancel()
+    }
+
+    public gcdBruteForce(a: number, b: number) {
+        const min = Math.min(a, b);
+        for (let i = min; i >= 1; i--) {
+            if (a % i === 0 && b % i === 0) {
+                return i;
+            }
+        }
+        return 1;
+    }
+
+    public cancel() {
+        const gcd = this.gcdBruteForce(this.numerator, this.denominator)
+        this.numerator = this.numerator / gcd
+        this.denominator = this.denominator / gcd
+    }
+
+    public gcdEuclid(a: number, b: number): number {
+        if (b === 0) return a;
+        return this.gcdEuclid(b, a % b);
+    }
+
+}

gcd_test.ts

@@ -0,0 +1,52 @@
+import { assertAlmostEquals, assertEquals, assertThrows } from "@std/assert";
+import { numbers } from "./gcd.ts"
+
+Deno.test("Grösster Gemeinsamer Teiler", () => {
+    const number = new numbers(18, 27);
+    const result = number.gcdBruteForce(18, 27);
+
+    assertEquals(result, 9);
+});
+
+Deno.test("Bruch kürzen", () => {
+    const number = new numbers(18, 27);
+    number.cancel()
+
+    assertEquals(number.numerator, 2);
+    assertEquals(number.denominator, 3);
+});
+
+const gcdTests = [
+    { a: 1, b: 1, gcd: 1 },
+    { a: 1, b: 2, gcd: 1 },
+    { a: 2, b: 2, gcd: 2 },
+    { a: 3, b: 4, gcd: 1 },
+    { a: 6, b: 9, gcd: 3 },
+    { a: 81, b: 36, gcd: 9 },
+];
+
+Deno.test("Grösster Gemeinsamer Teiler (Euklid-Algorithmus)", () => {
+    for (const { a, b, gcd } of gcdTests) {
+        const num = new numbers(a, b);
+        const result = num.gcdEuclid(a, b);
+        assertEquals(result, gcd);
+    }
+}); 
+
+Deno.test("Aufgabe 4: Automatische Kürzung", () => {
+    const fraction = new numbers(18, 27);
+    assertEquals(fraction.numerator, 2);
+    assertEquals(fraction.denominator, 3);
+});
+
+Deno.test("Aufgabe 4: Automatische Kürzung - bereits gekürztem Bruch", () => {
+    const fraction = new numbers(2, 3);
+    assertEquals(fraction.numerator, 2);
+    assertEquals(fraction.denominator, 3);
+});
+
+Deno.test("Aufgabe 4: Automatische Kürzung - Bruch mit 1 als Nenner", () => {
+    const fraction = new numbers(5, 1);
+    assertEquals(fraction.numerator, 5);
+    assertEquals(fraction.denominator, 1);
+});

geometry_test.ts

@@ -1,5 +1,5 @@
 import { assertAlmostEquals } from "@std/assert";
-import { Circle, Point2D } from "./geometry.ts";
+import { Circle, Point2D, Rectangle } from "./geometry.ts";
 
 Deno.test("circumference of a circle with radius 5 is roughtly 31.416", () => {
   // Given
@@ -11,3 +11,37 @@ Deno.test("circumference of a circle with radius 5 is roughtly 31.416", () => {
   // Then
   assertAlmostEquals(actual, 31.416, 0.01);
 });
+
+Deno.test("area", () => {
+  // Given
+  const circle = new Circle(new Point2D(1, 1), 5);
+
+  // When
+  const actual = circle.area();
+
+  // Then
+  assertAlmostEquals(actual, 78.54, 0.01);
+});
+
+Deno.test("diameter", () => {
+  // Given
+  const circle = new Circle(new Point2D(1, 1), 5);
+
+  // When
+  const actual = circle.diameter();
+
+  // Then
+  assertAlmostEquals(actual, 10, 0.01);
+});
+
+Deno.test("circumference", () => {
+  // Given
+  const rectangle = new Rectangle(new Point2D(1, 1), new Point2D(4, 5));
+
+  // When
+  const actual = rectangle.circumference();
+
+  // Then
+  assertAlmostEquals(actual, 22, 0.01);
+});
+