Final Realization

in.txt

@@ -0,0 +1,4 @@
+3 4
+1+2i -1.5-1.1i 2.12 91+5i
+-1+3i 1.2+3.5i -3.3 1+15i
+12.31 1.3-5i 12.3i -78.3i

.idea/project.iml → linear-equations-solver.iml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
   <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
     </content>

out.txt

@@ -0,0 +1 @@
+6.733353-22.997542i -1.797607+2.084049i 15.699386+7.396011i

src/solver/Answer.java

@@ -0,0 +1,77 @@
+package solver;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import java.util.stream.Collectors;
+
+/**
+ * Created by DIMA, on 04.12.2018
+ */
+public class Answer {
+    private String fileNameToWrite;
+    private List<Complex> answer;
+
+    private List<Complex> createAnswer(Complex[][] gaussJordanMatrix){
+        answer = new ArrayList<>();
+        for(int i = 0; i < gaussJordanMatrix.length; i++){
+            double xReal = gaussJordanMatrix[i][gaussJordanMatrix[i].length-1].getRealPart();
+            double xImaginary = gaussJordanMatrix[i][gaussJordanMatrix[i].length-1].getImaginaryPart();
+            xReal = new BigDecimal(xReal).setScale(6, BigDecimal.ROUND_HALF_UP).doubleValue();
+            xImaginary = new BigDecimal(xImaginary).setScale(6, BigDecimal.ROUND_HALF_UP).doubleValue();
+            answer.add(new Complex(xReal, xImaginary));
+        }
+        return answer;
+    }
+
+    Answer(String fileNameToWrite){
+        this.fileNameToWrite = fileNameToWrite;
+    }
+
+    void writeAnswer(Complex[][] gaussJordanMatrix){
+        List<Complex> answer = createAnswer(gaussJordanMatrix);
+        try (FileWriter fileWriter = new FileWriter(fileNameToWrite)){
+            StringBuilder sb = new StringBuilder();
+            for(Complex c : answer){
+                if(c.getRealPart() == 0 && c.getImaginaryPart() == 0){
+                    sb.append(0).append(" ");
+                    continue;
+                }
+                if(c.getRealPart() != 0){
+                    sb.append(c.getRealPart());
+                }
+                if(c.getImaginaryPart() != 0){
+                    if(c.getImaginaryPart() > 0){
+                        sb.append("+");
+                    }
+                    sb.append(c.getImaginaryPart()).append("i");
+                }
+                sb.append(" ");
+            }
+            //String s = answer.stream().map(String::valueOf).collect(Collectors.joining(" "));
+            fileWriter.write(sb.toString().trim());
+            fileWriter.flush();
+        }catch (IOException e){
+            System.out.println("Wrong fileOut, please check");
+            System.out.println(e.getMessage());
+        }
+    }
+
+    void writeAnswer(String s){
+       try (FileWriter fileWriter = new FileWriter(fileNameToWrite)){
+            fileWriter.write(s);
+            fileWriter.flush();
+        }catch (IOException e){
+            System.out.println("Wrong fileOut, please check");
+            System.out.println(e.getMessage());
+        }
+    }
+
+    public List<Complex> getAnswer() {
+        return answer;
+    }
+}

src/solver/Complex.java

@@ -0,0 +1,147 @@
+package solver;
+
+/**
+ * Created by DIMA, on 16.01.2019
+ */
+public class Complex {
+    private double realPart;
+    private double imaginaryPart;
+
+    public Complex(double realPart, double imaginaryPart) {
+        this.realPart = realPart;
+        this.imaginaryPart = imaginaryPart;
+    }
+
+    public Complex(String item){
+        String[] items = item.split("[-,+]");
+        int len = items.length;
+        double real = 0;
+        double imaginary = 0;
+        switch (len){
+            case 3:
+                String[] items1 = item.split("\\+");
+                if(items1[0].endsWith("i")){
+                    // -real && -imaginary
+                    real = Double.parseDouble(items[1]) * -1;
+                    imaginary = Double.parseDouble(items[2].substring(0, items[2].length()-1)) * -1;
+                }else {
+                    // -real && imaginary
+                    real = Double.parseDouble(items[1]) * -1;
+                    imaginary = Double.parseDouble(items[2].substring(0, items[2].length()-1));
+                }
+                break;
+            case 2:
+                if(items[0].equals("")){
+                    // -real || -imaginary
+                    if(items[1].endsWith("i")){
+                        // -imaginary
+                        imaginary = Double.parseDouble(items[1].substring(0, items[1].length()-1)) * -1;
+                        real = 0;
+                    }else {
+                        // -real
+                        real = Double.parseDouble(items[1]) * -1;
+                        imaginary = 0;
+                    }
+                }else {
+                    // real && imaginary
+                    items1 = item.split("\\+");
+                    if(items1[0].endsWith("i")){
+                        // real && -imaginary
+                        real = Double.parseDouble(items[0]);
+                        imaginary = Double.parseDouble(items[1].substring(0, items[1].length()-1)) * -1;
+                    }else {
+                        // real && imaginary
+                        real = Double.parseDouble(items[0]);
+                        imaginary = Double.parseDouble(items[1].substring(0, items[1].length()-1));
+                    }
+
+                }
+                break;
+            case 1:
+                if(items[0].endsWith("i")){
+                    // imaginary
+                    imaginary = Double.parseDouble(items[0].substring(0, items[0].length()-1));
+                    real = 0;
+                }else {
+                    // real
+                    real = Double.parseDouble(items[0]);
+                    imaginary = 0;
+                }
+                break;
+
+        }
+        this.realPart = real;
+        this.imaginaryPart = imaginary;
+    }
+
+    public double getRealPart() {
+        return realPart;
+    }
+
+    public double getImaginaryPart() {
+        return imaginaryPart;
+    }
+
+    @Override
+    public String toString() {
+        String s = "";
+        if(realPart != 0){
+            s += realPart;
+        }
+        if(imaginaryPart > 0 && realPart != 0){
+            return s + "+" + imaginaryPart + "i";
+        }else if(imaginaryPart > 0 && realPart == 0){
+            return imaginaryPart + "i";
+        }else if(imaginaryPart < 0){
+            return s + imaginaryPart + "i";
+        }else if(realPart !=0 ){
+            return s;
+        }else {
+            return "0";
+        }
+    }
+
+    public Complex adding(Complex c){
+        double realC = c.realPart;
+        double imaginaryC = c.imaginaryPart;
+        double realResult = realPart + realC;
+        double imaginaryResult = imaginaryPart + imaginaryC;
+        return new Complex(realResult, imaginaryResult);
+    }
+
+    public Complex subtracting(Complex c){
+        double realC = c.realPart;
+        double imaginaryC = c.imaginaryPart;
+        double realResult = realPart - realC;
+        double imaginaryResult = imaginaryPart - imaginaryC;
+        return new Complex(realResult, imaginaryResult);
+    }
+
+
+
+    public Complex multiply(Complex c){
+        double realC = c.realPart;
+        double imaginaryC = c.imaginaryPart;
+        double realResult = realPart*realC - imaginaryPart*imaginaryC;
+        double imaginaryResult = realPart*imaginaryC + imaginaryPart*realC;
+        return new Complex(realResult, imaginaryResult);
+    }
+
+    private Complex conjugating(Complex c){
+        double realC = c.realPart;
+        double imaginaryC = c.imaginaryPart;
+        double imaginaryCResult = imaginaryC * (-1);
+        return new Complex(realC, imaginaryCResult);
+    }
+
+    Complex divide(Complex divisor){
+        Complex conjugate = conjugating(divisor);
+        Complex newDivident = multiply(conjugate);
+        double newDivisor = divisor.realPart*divisor.realPart + divisor.imaginaryPart*divisor.imaginaryPart;
+        return new Complex(newDivident.realPart/newDivisor, newDivident.imaginaryPart/newDivisor);
+    }
+
+    Complex changeSign(){
+        return multiply(new Complex(-1, 0));
+    }
+}

src/solver/Main.java

@@ -1,7 +1,47 @@
 package solver;
 
+import solver.specialCases.Helper;
+import solver.specialCases.TesterResult;
+
+import java.util.Arrays;
+
 public class Main {
+
+    private String fileNameSource;
+    private String fileNameAnswer;
+    private Matrix matrix;
+    private Solver solver;
+    private Answer answer;
+
     public static void main(String[] args) {
-        System.out.print("Hello world!");
+        //X:\Programming\IdeaProjects\linear-equations-solver\in.txt
+        Main m = new Main();
+        m.fileNameSource = args[0];
+        m.fileNameAnswer = args[1];
+        m.matrix = new Matrix(m.fileNameSource);
+        m.solver = new Solver(m.matrix);
+        m.answer = new Answer(m.fileNameAnswer);
+        Complex[][] origMatrix = new Complex[m.matrix.getMatrix().length][m.matrix.getMatrix()[0].length];
+        for(int row = 0; row < origMatrix.length; row++){
+            for(int column = 0; column < origMatrix[row].length; column++){
+                origMatrix[row][column] = m.matrix.getMatrix()[row][column];
+            }
+        }
+
+        Complex[][] gaussJordanMatrix = m.solver.calcGaussJordan(m.matrix.getMatrix());
+
+        if(m.solver.noSolutions){
+            m.answer.writeAnswer("No Solution");
+        }else if(m.solver.infinitySolutions){
+            m.answer.writeAnswer("Infinity Solutions");
+        }else {
+            m.answer.writeAnswer(gaussJordanMatrix);
+        }
+
+
+
+        //============================TESTS======================//
+        //TesterResult.testingResult(origMatrix, m.answer.getAnswer());
+
     }
 }

src/solver/Matrix.java

@@ -0,0 +1,45 @@
+package solver;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.util.Arrays;
+import java.util.Scanner;
+import java.util.stream.Collectors;
+
+/**
+ * Created by DIMA, on 03.12.2018
+ */
+public class Matrix {
+    private Complex[][] matrix;
+
+    Matrix(String fileName){
+        try (Scanner scanner = new Scanner(new FileInputStream(fileName))){
+            int rows = scanner.nextInt();
+            int columns = scanner.nextInt();
+            matrix = new Complex[rows][columns];
+            for(int i = 0; i < rows; i++){
+                for (int j = 0; j < columns; j++){
+                    String item = scanner.next();
+
+                    matrix[i][j] = new Complex(item);
+                }
+            }
+        }catch (FileNotFoundException e){
+            System.out.println("Please check file of coefficients");
+            System.out.println(e.getMessage());
+        }
+    }
+
+/*    @Override
+    public String toString() {
+        return Arrays.stream(matrix)
+                .map(i -> Arrays.stream(i).boxed()
+                        .map(String::valueOf)
+                        .collect(Collectors.joining(" ")))
+                .collect(Collectors.joining("\n"));
+    }*/
+
+    public Complex[][] getMatrix() {
+        return matrix;
+    }
+}