TheAlgorithms · yanglbme · Feb 17, 2019 · Jan 15, 2019 · Jan 15, 2019 · Jan 15, 2019
@@ -0,0 +1,203 @@
+package Others;
+
+import java.util.ArrayList;
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * @author dimgrichr
+ */
+public class CRCAlgorithm {
+
+    private int correctMess;
+
+    private int wrongMess;
+
+    private int wrongMessCaught;
+
+    private int wrongMessNotCaught;
+
+    private int messSize;
+
+    private double ber;
+
+    private boolean messageChanged;
+
+    private ArrayList<Integer> message;
+
+    private ArrayList<Integer> dividedMessage;
+
+    private ArrayList<Integer> p;
+
+    private Random randomGenerator;
+
+
+    /**
+     * The algorithm's main constructor.
+     * The most significant variables, used in the algorithm,
+     * are set in their initial values.
+     *
+     * @param str  The binary number P, in a string form, which is used by the CRC algorithm
+     * @param size The size of every transmitted message
+     * @param ber  The Bit Error Rate
+     */
+    public CRCAlgorithm(String str, int size, double ber) {
+        messageChanged = false;
+        message = new ArrayList<>();
+        messSize = size;
+        dividedMessage = new ArrayList<>();
+        p = new ArrayList<>();
+        for (int i = 0; i < str.length(); i++) {
+            p.add(Character.getNumericValue(str.charAt(i)));
+        }
+        randomGenerator = new Random();
+        correctMess = 0;
+        wrongMess = 0;
+        wrongMessCaught = 0;
+        wrongMessNotCaught = 0;
+        this.ber = ber;
+    }
+
+
+    /**
+     * Returns the counter wrongMess
+     *
+     * @return wrongMess, the number of Wrong Messages
+     */
+    public int getWrongMess() {
+        return wrongMess;
+    }
+
+    /**
+     * Returns the counter wrongMessCaught
+     *
+     * @return wrongMessCaught, the number of wrong messages, which are caught by the CRC algoriithm
+     */
+    public int getWrongMessCaught() {
+        return wrongMessCaught;
+    }
+
+    /**
+     * Returns the counter wrongMessNotCaught
+     *
+     * @return wrongMessNotCaught, the number of wrong messages, which are not caught by the CRC algorithm
+     */
+    public int getWrongMessNotCaught() {
+        return wrongMessNotCaught;
+    }
+
+    /**
+     * Returns the counter correctMess
+     *
+     * @return correctMess, the number of the Correct Messages
+     */
+    public int getCorrectMess() {
+        return correctMess;
+    }
+
+    /**
+     * Resets some of the object's values, used on the main function,
+     * so that it can be re-used, in order not to waste too much memory and time,
+     * by creating new objects.
+     */
+    public void refactor() {
+        messageChanged = false;
+        message = new ArrayList<>();
+        dividedMessage = new ArrayList<>();
+    }
+
+    /**
+     * Random messages, consisted of 0's and 1's,
+     * are generated, so that they can later be transmitted
+     */
+    public void generateRandomMess() {
+        for (int i = 0; i < messSize; i++) {
+            int x = ThreadLocalRandom.current().nextInt(0, 2);
+            message.add(x);
+        }
+    }
+
+    /**
+     * The most significant part of the CRC algorithm.
+     * The message is divided by P, so the dividedMessage ArrayList<Integer> is created.
+     * If check == true, the dividedMessaage is examined, in order to see if it contains any 1's.
+     * If it does, the message is considered to be wrong by the receiver,so the variable wrongMessCaught changes.
+     * If it does not, it is accepted, so one of the variables correctMess, wrongMessNotCaught, changes.
+     * If check == false, the diviided Message is added at the end of the ArrayList<integer> message.
+     *
+     * @param check the variable used to determine, if the message is going to be checked from the receiver
+     *              if true, it is checked
+     *              otherwise, it is not
+     */
+    public void divideMessageWithP(boolean check) {
+        ArrayList<Integer> x = new ArrayList<>();
+        ArrayList<Integer> k = (ArrayList<Integer>) message.clone();
+        if (!check) {
+            for (int i = 0; i < p.size() - 1; i++) {
+                k.add(0);
+            }
+        }
+        while (!k.isEmpty()) {
+            while (x.size() < p.size() && !k.isEmpty()) {
+                x.add(k.get(0));
+                k.remove(0);
+            }
+            if (x.size() == p.size()) {
+                for (int i = 0; i < p.size(); i++) {
+                    if (x.get(i) == p.get(i)) {
+                        x.set(i, 0);
+                    } else {
+                        x.set(i, 1);
+                    }
+                }
+                for (int i = 0; i < x.size() && x.get(i) != 1; i++) {
+                    x.remove(0);
+                }
+            }
+        }
+        dividedMessage = (ArrayList<Integer>) x.clone();
+        if (!check) {
+            for (int z : dividedMessage) {
+                message.add(z);
+            }
+        } else {
+            if (dividedMessage.contains(1) && messageChanged) {
+                wrongMessCaught++;
+            } else if (!dividedMessage.contains(1) && messageChanged) {
+                wrongMessNotCaught++;
+            } else if (!messageChanged) {
+                correctMess++;
+            }
+        }
+    }
+
+    /**
+     * Once the message is transmitted, some of it's elements,
+     * is possible to change from 1 to 0, or from 0 to 1,
+     * because of the Bit Error Rate (ber).
+     * For every element of the message, a random double number is created.
+     * If that number is smaller than  ber, then the spesific element changes.
+     * On the other hand, if it's bigger than ber, it does not.
+     * Based on these changes. the boolean variable messageChanged, gets the value:
+     * true, or false.
+     */
+    public void changeMess() {
+        for (int y : message) {
+            double x = randomGenerator.nextDouble();
+            while (x < 0.0000 || x > 1.00000) {
+                x = randomGenerator.nextDouble();
+            }
+            if (x < ber) {
+                messageChanged = true;
+                if (y == 1) {
+                    message.set(message.indexOf(y), 0);
+                } else {
+                    message.set(message.indexOf(y), 1);
+                }
+            }
+        }
+        if (messageChanged) {
+            wrongMess++;
+        }
+    }
+}