Fifth

src/solver/ComplexNumber.java

@@ -0,0 +1,61 @@
+import java.util.Scanner;
+
+
+class ComplexNumber {
+	double re;
+	double im;
+
+	public ComplexNumber(double re, double im) {
+		this.re = re;
+		this.im = im;
+	}
+
+	public double getRe() {
+		return this.re;
+	}
+
+	public double getIm() {
+		return this.im;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) {return true;}
+		if (obj == null) {return false;}
+		if (obj instanceof ComplexNumber) {
+			ComplexNumber num = (ComplexNumber) obj;
+			return this.getRe() == num.getRe() && this.getIm() == num.getIm();
+		}
+		return false;
+	} 
+	@Override
+	public int hashCode() {
+		return this.toString().hashCode();
+	}
+	public String toString() {
+		return "" + this.re + " + i*" + this.im;
+	}
+
+	ComplexNumber add(ComplexNumber num) {
+		ComplexNumber result = new ComplexNumber(0, 0);
+		result.re = num.re + this.re;
+		result.im = num.im + this.im;
+		return result;
+	}
+
+	ComplexNumber mul(ComplexNumber num) {
+		ComplexNumber result = new ComplexNumber(0, 0);
+		result.re = num.re * this.re - num.im * this.im;
+		result.im = num.re * this.im + num.im * this.re;
+		return result;
+	}
+
+	ComplexNumber inverse() {
+		ComplexNumber result = new ComplexNumber(0, 0);
+		double module = 0;
+		module = this.re * this.re + this.im * this.im;
+		result.re = this.re / module;
+		result.im = -this.im / module;
+		return result;
+	}
+}

src/solver/Main.java

@@ -1,7 +1,40 @@
-package solver;
+import java.util.Scanner;
+import java.util.Arrays;
+import java.util.*;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
 
 public class Main {
-    public static void main(String[] args) {
-        System.out.print("Hello world!");
-    }
-}
+	public static void main(String[] args) {
+
+	makeGood maker = new makeGood();
+
+	File file = new File("in.txt");
+	try(Scanner scanner = new Scanner(file)) {
+		int n = scanner.nextInt();
+		int m = scanner.nextInt();
+		// n - число неизвестных (без ответа), m - число уравнений
+		ComplexNumber[] line = new ComplexNumber[n + 1];
+		Row[] row = new Row[m];
+		String s = "";
+		for (int j = 0; j < m; j++) 
+		{	
+			for (int i = 0; i <= n; i++){
+				s = scanner.next();
+				line[i] = maker.stringToComplex(s);
+			}
+			row[j] = new Row(n, line);
+		}
+		Matrix matrix = new Matrix(row, n, m);
+
+		matrix.steppedViewDown();
+	} catch (FileNotFoundException e) {
+		System.out.println("I hope that never happen");
+	}
+
+
+	}
+}
+

src/solver/Matrix.java

@@ -0,0 +1,153 @@
+import java.util.Scanner;
+import java.util.Arrays;
+import java.util.*;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+class Matrix {
+	int N;
+	int M;
+	Row[] rows = new Row[1];
+	public Matrix(Row[] row, int n, int m) {
+		this.rows = row;
+		this.N = n;
+		this.M = m;
+	}
+// true - ненулевое
+	boolean checkValue(int i, int j) { 
+		ComplexNumber zero = new ComplexNumber(0, 0); 
+		return (this.rows[j].getValue(i).equals(zero) ? false: true);
+	}
+
+
+	String resetAllDown(int i, int j) {
+		String s = "";
+		ComplexNumber minOne = new ComplexNumber(-1, 0);
+		ComplexNumber zero = new ComplexNumber(0, 0);
+		ComplexNumber coef = this.rows[j].getValue(i);		
+		this.rows[j].mul(coef.inverse());
+		s = (coef.inverse().toString()) +  "*R" + (j + 1) + " -> R" + (j + 1) + "\n";
+		for (int k = j + 1; k < this.M; k++) {
+			coef = this.rows[k].getValue(i);
+			if (!coef.equals(zero)) {
+				this.rows[k].mul( coef.inverse().mul(minOne));
+				this.rows[k].add(this.rows[j]);
+				s = s + coef.inverse().mul(minOne).toString() + "*R" + (k + 1) + " + R" + (j + 1) + " -> R" + (k + 1) + "\n";
+			}
+		}
+		return s;
+	}
+
+	String resetAllUp(int i, int j) {
+		String s = "";
+		ComplexNumber zero = new ComplexNumber(0, 0);
+		ComplexNumber minOne = new ComplexNumber(-1, 0);
+		ComplexNumber coef = this.rows[j].getValue(i);
+		this.rows[j].mul(coef.inverse());
+		s = coef.inverse().toString() +  "*R" + (j + 1) + " -> R" + (j + 1) + "\n";
+		for (int k = j - 1; k >= 0; k--) {
+			coef = this.rows[k].getValue(i);
+			if (!coef.equals(zero)) {
+				this.rows[k].mul(coef.inverse().mul(minOne));
+				this.rows[k].add(this.rows[j]); 
+				s = s + coef.inverse().mul(minOne).toString() + "*R" + (k + 1) + " + R" + (j + 1) + " -> R" + (k + 1) + "\n";
+			}
+		}
+		return s;
+	}
+
+	void steppedViewDown () {
+		int j = 0;
+		int i = 0;
+		String s = "";
+		s += "start solving the equation\n";
+		s += "Rows manipulation\n";
+		for (; i <= this.N && j < this.M; i++) {
+			if (this.checkValue(i, j)) {
+				s += this.resetAllDown(i, j);
+				j += 1;
+			}
+			else { //пробегаю вниз. Если есть ненулевой - свапаю, если нет - перехожу к след i и j;
+				for (int k = j + 1; k < this.M; k++) {
+					if (this.checkValue(i, k)) {
+						this.swap(i, k);
+						s = s + "Swap R" + (i + 1) + " with R" + (k + 1) + "\n";
+					}
+				}
+				if (!this.checkValue(i, j)) {
+					i += 1;
+				}
+				i -= 1;
+			}
+		}
+
+		if (j == 0) {
+			s += "infinity solutions\n";
+		}
+
+		else {
+			if (!this.checkNonzero(0, j - 1)) {
+				s += "no solutions\n";
+			}
+			else {
+				if (j != this.N) {
+					s += "infinity solutions\n";
+				}
+				else {
+					s += this.steppedViewUp();
+				}
+			}
+		}
+		File file = new File("out.txt");
+		try (FileWriter writer = new FileWriter(file)) {
+			writer.write(s);
+		} catch (IOException e) {
+			System.out.printf("Exception");
+		}
+	}
+
+	String steppedViewUp () {
+		String s = "";
+		for (int j = this.N - 1; j > 0; j--) {
+			s += this.resetAllUp(j, j);
+		}
+		s += this.solve();
+		return s;
+	}
+// true - есть ненулевой элемент помимо ответа
+	boolean checkNonzero(int i, int j) {
+		if (i < this.N - 1) {
+			return (this.checkNonzero(i + 1, j) || this.checkValue(i, j));
+		}
+		else {
+			return this.checkValue(i, j);
+		}
+	}
+
+	void swap(int i, int j) { 
+		Row row = this.rows[i];
+		this.rows[i] = this.rows[j];
+		this.rows[j] = row;
+	}
+	String getString() {
+		String s = "";
+		for (int i = 0; i < this.M; i++) {
+			s += this.rows[i].getString();
+			s += "\n";
+		}
+		return s;
+	}
+	String solve () {
+		String s = "";
+		s += "The solution is: (";
+		for (int i = 0; i < this.N - 1; i++) {
+			ComplexNumber now = this.rows[i].getValue(i);
+			now = now.inverse();
+			s = s + this.rows[i].getValue(this.N).mul(now).toString() + ", ";
+		}
+		s = s + this.rows[this.N - 1].getValue(this.N).toString() + ")\n";
+		return s;
+	}
+
+}

src/solver/Row.java

@@ -0,0 +1,42 @@
+/**
+Я решительно не понимаю 1 важную вещь. Сейчас в конструкторе у меня цикл и вроде как лишние приравнения, сделано это потому,
+что иначе при задании массива строк у нас присваивание будет (как я понимаю) по ссылке и в такой ситуации:
+Row[] row = new Row[5]; 
+row[0] = first_row; ... row[4] = fifth_row; в row[0] будет храниться  fifth_row и я не совсем понимаю почему. Точнее, я не понимаю
+почему при таком задании конструктора как тут, все работает правильно.
+*/
+class Row { // N на 1 больше, чем вход, т.к. тут я учитываю и ответ (то, что справа от равно)
+	int N;
+	ComplexNumber[] line = new ComplexNumber[1];
+	public Row(int N, ComplexNumber[] row) {
+		this.line = new ComplexNumber[N + 1];
+		for (int i = 0; i <= N; i++) {
+			this.line[i] = row[i];
+		}
+		this.N = N;
+	}
+
+	ComplexNumber getValue(int i) {
+		return this.line[i];
+	}
+
+	void add(Row other) { //поидее можно сделать private?
+		for (int i = 0; i <= this.N; i++) {
+			this.line[i] = this.line[i].add(other.line[i]);
+		}
+	}
+	void mul(ComplexNumber num) { //умножение строки на константу
+		for (int i = 0; i <= this.N; i++) {
+			this.line[i] = this.line[i].mul(num);
+		}
+	}
+
+	String getString() {
+		String s = "[";
+		for (int i = 0; i <= this.N - 1; i++) {
+			s = s + this.getValue(i).toString() + ", ";
+		}
+		s = s + this.getValue(this.N).toString() + "]";
+		return s;
+	}
+}

src/solver/makeGood.java

@@ -0,0 +1,45 @@
+class makeGood {
+	ComplexNumber stringToComplex(String s) {
+		ComplexNumber num = new ComplexNumber(0, 0);
+		String[] parts = new String[2];
+		if (s.contains("+")) {
+			parts = s.split("\\+");
+			String re = parts[0];
+			String im = parts[1].substring(0, parts[1].length() -1);
+			double Re = Double.parseDouble(re);
+			double Im = Double.parseDouble(im);
+			num = new ComplexNumber(Re, Im);
+		}
+
+		else if (s.indexOf("-") > 0 || s.substring(1, s.length()).indexOf("-") >= 0)
+		{
+//			System.out.println("Yep, I can parse it too");
+			if (s.indexOf("-") == 0) {
+				parts = s.substring(1, s.length()).split("-");
+				double Re = -Double.parseDouble(parts[0]);
+				double Im = -Double.parseDouble(parts[1].substring(0, parts[1].length() - 1));
+				num = new ComplexNumber(Re, Im);
+			}
+			else {
+				parts = s.substring(0, s.length()).split("-");
+				double Re = Double.parseDouble(parts[0]);
+				double Im = -Double.parseDouble(parts[1].substring(0, parts[1].length() - 1));
+				num = new ComplexNumber(Re, Im);
+			}
+		}
+
+		else {
+			if (s.contains("i")) {
+				double Re = 0;
+				double Im = Double.parseDouble(s.substring(0, s.length() - 1));
+				num = new ComplexNumber(Re, Im);
+			}
+			else {
+				double Re = Double.parseDouble(s);
+				double Im = 0;
+				num = new ComplexNumber(Re, Im);
+			}
+		}
+		return num;
+	}
+}