From bc614f1a03fe232a7480432b70f72f61573a2ce1 Mon Sep 17 00:00:00 2001 From: manuel Date: Wed, 22 Oct 2025 16:51:27 +0000 Subject: [PATCH] Upload files to "source" --- source/Addition.java | 9 +++++ source/Field.java | 52 +++++++++++++++++++++++++++ source/FieldTest.java | 40 +++++++++++++++++++++ source/Multiplication.java | 23 ++++++++++++ source/Operation.java | 73 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 197 insertions(+) create mode 100644 source/Addition.java create mode 100644 source/Field.java create mode 100644 source/FieldTest.java create mode 100644 source/Multiplication.java create mode 100644 source/Operation.java diff --git a/source/Addition.java b/source/Addition.java new file mode 100644 index 0000000..4d1f13f --- /dev/null +++ b/source/Addition.java @@ -0,0 +1,9 @@ +package serie04; + +public class Addition extends Operation { + + public Addition (int size, int[][] table) { + super(size, table); + } + +} diff --git a/source/Field.java b/source/Field.java new file mode 100644 index 0000000..5e4912d --- /dev/null +++ b/source/Field.java @@ -0,0 +1,52 @@ +package serie04; + +public class Field { + + private int size; + private Addition addition; + private Multiplication multiplication; + + public Field(int size, Addition addition, Multiplication multiplication) { + + if(addition.getSize() != size || multiplication.getSize() + 1 != size) { + throw new ArithmeticException(); + } + + this.size = size; + this.addition = addition; + this.multiplication = multiplication; + } + + public boolean checkDistributivity(int indexA, int indexB, int indexC) { + + int leftSide = multiplication.calculate(indexA, addition.calculate(indexB, indexC)); + int rightSide = addition.calculate(multiplication.calculate(indexA, indexB), multiplication.calculate(indexA, indexC)); + + return leftSide == rightSide; + } + + public boolean checkDistributivity() { + + for(int a = 0; a < this.size; a++) { + for(int b = 0; b < this.size; b++) { + for(int c = 0; c < this.size; c++) { + if (this.checkDistributivity(a, b, c) == false) return false; + } + } + } + + return true; + } + + public boolean verifyField() { + + if (this.multiplication.validateTable() == false) return false; + + if (this.addition.validateTable() == false) return false; + + if (this.checkDistributivity() == false) return false; + + return true; + } + +} diff --git a/source/FieldTest.java b/source/FieldTest.java new file mode 100644 index 0000000..a8652e2 --- /dev/null +++ b/source/FieldTest.java @@ -0,0 +1,40 @@ +package serie04; + +public class FieldTest { + + public static void main(String[] args) { + + int[][] m1Table = { + {0,1,2}, + {1,2,0}, + {2,0,1} + }; + + int[][] a1Table = { //This is the addition table number 1 which we want to + {0,1,2,3}, //show is a field. + {1,0,3,2}, + {2,3,0,1}, + {3,2,1,0} + }; + + int[][] a2Table = { //This is the addition table for which we know it is not + {0,1,2,3}, //a field + {1,0,3,2}, + {2,3,1,0}, + {3,2,0,1} + }; + + Multiplication m1 = new Multiplication(3, m1Table); + Addition a1 = new Addition(4, a1Table); + Addition a2 = new Addition(4, a2Table); + + Field k4_1 = new Field(4, a1, m1); + Field k4_2 = new Field(4, a2, m1); + + System.out.println(k4_1.verifyField() + " this should be true"); + System.out.println(k4_2.verifyField() + " this should be false"); + + + } + +} diff --git a/source/Multiplication.java b/source/Multiplication.java new file mode 100644 index 0000000..1367e70 --- /dev/null +++ b/source/Multiplication.java @@ -0,0 +1,23 @@ +package serie04; + +public class Multiplication extends Operation { + + public Multiplication (int size, int[][] table) { + super(size, table); + } + + @Override + public int calculate(int indexA, int indexB) { + if(indexA == 0 || indexB == 0) { + return 0; + } + else { + indexA--; + indexB--; + return super.calculate(indexA, indexB) + 1; + } + } + + + +} diff --git a/source/Operation.java b/source/Operation.java new file mode 100644 index 0000000..3658e88 --- /dev/null +++ b/source/Operation.java @@ -0,0 +1,73 @@ +package serie04; + +import java.util.ArrayList; + +public class Operation { + private int[][] table; + private int size; + + public Operation(int size, int[][] table) { + if (size < 1) throw new NegativeArraySizeException(); + this.size = size; + this.table = table; + } + + public int calculate(int indexA, int indexB) { + if(indexA >= this.size || indexB >= this.size)throw new IndexOutOfBoundsException(); + return this.table[indexA][indexB]; + } + + public boolean validateTable() { + + //validate rows and check closedness + for(int i = 0; i < this.size; i++) { + ArrayList used = new ArrayList(); + for(int j = 0; j < this.size; j++) { + if(this.table[i][j] >= this.size || this.table[i][j] < 0) return false; + if (isIn(this.table[i][j], used)) return false; + used.add(this.table[i][j]); + } + } + //validate columns + for(int j = 0; j < this.size; j++) { + ArrayList used = new ArrayList(); + for(int i = 0; i < this.size; i++) { + if (isIn(this.table[i][j], used)) return false; + used.add(this.table[i][j]); + } + } + + return this.checkAssociativity(); + } + + public boolean checkAssociativity() { + + for(int a = 0; a < this.size; a++) { + for(int b = 0; b < this.size; b++) { + for(int c = 0; c < this.size; c++) { + if (this.checkAssociativity(a, b, c) == false) return false; + } + } + } + + return true; + } + + public boolean checkAssociativity(int indexA, int indexB, int indexC) { + + return this.calculate(indexA, this.calculate(indexB, indexC)) == this.calculate(this.calculate(indexA, indexB), indexC); + + } + + private static boolean isIn(int a, ArrayList array) { + for(int i = 0; i < array.size(); i++) { + if (a == array.get(i)) return true; + } + return false; + } + + public int getSize() { + return this.size; + } + +}