diff --git a/.idea/misc.xml b/.idea/misc.xml index a165cb3..556829f 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,6 +1,9 @@ - + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml index a0733a5..d040f98 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -2,7 +2,7 @@ - + \ No newline at end of file diff --git a/in.txt b/in.txt new file mode 100644 index 0000000..dc67031 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/.idea/project.iml b/linear-equations-solver.iml similarity index 94% rename from .idea/project.iml rename to linear-equations-solver.iml index 47baa8c..c90834f 100644 --- a/.idea/project.iml +++ b/linear-equations-solver.iml @@ -1,6 +1,7 @@ + diff --git a/out.txt b/out.txt new file mode 100644 index 0000000..b4d7a2e --- /dev/null +++ b/out.txt @@ -0,0 +1 @@ +6.733353-22.997542i -1.797607+2.084049i 15.699386+7.396011i \ No newline at end of file diff --git a/src/solver/Answer.java b/src/solver/Answer.java new file mode 100644 index 0000000..5f78592 --- /dev/null +++ b/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 answer; + + private List 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 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 getAnswer() { + return answer; + } +} diff --git a/src/solver/Complex.java b/src/solver/Complex.java new file mode 100644 index 0000000..f7eafe3 --- /dev/null +++ b/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)); + } +} diff --git a/src/solver/Main.java b/src/solver/Main.java index 4404714..7ea575f 100644 --- a/src/solver/Main.java +++ b/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()); + } } \ No newline at end of file diff --git a/src/solver/Matrix.java b/src/solver/Matrix.java new file mode 100644 index 0000000..4747e29 --- /dev/null +++ b/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; + } +} diff --git a/src/solver/Solver.java b/src/solver/Solver.java new file mode 100644 index 0000000..470eec1 --- /dev/null +++ b/src/solver/Solver.java @@ -0,0 +1,147 @@ +package solver; + +import solver.specialCases.*; + +/** + * Created by DIMA, on 03.12.2018 + */ +class Solver { + boolean noSolutions = false; + boolean infinitySolutions = false; + Complex[][] matrix; + + public Solver(Matrix m){ + matrix = m.getMatrix(); + } + + + private Complex[][] calcGaussian(Complex[][] matrix){ + Complex[][] gaussMatrix = matrix; + // 1*x1 + int matrixSize = gaussMatrix.length; + for (int row = 0; row < matrixSize; row++){ + if(!Checker.isAllZero(row, gaussMatrix)){ + if(!Checker.hasMainNumber(row, gaussMatrix)){ + int findedRow = Searcher.searchRowDown(row, gaussMatrix); + if(findedRow != -1){ + Swapper.swapRows(row, findedRow, gaussMatrix); + }else { + int findedColumn = Searcher.searchColumnRight(row, gaussMatrix); + if (findedColumn != -1){ + Swapper.swapColumns(row, findedColumn, gaussMatrix); + SwapStore.addSwap(row, findedColumn); + }else { + if(!Checker.isZeroInRightColumn(row, gaussMatrix)){ + noSolutions = true; + return null; + }else { + continue; + } + } + } + } + }else { + gaussMatrix = deleteRow(row, gaussMatrix); + row--; + matrixSize--; + continue; + } + if(row != 0){ + gaussMatrix = nullingRowGauss(row, gaussMatrix); + } + if(!Checker.isAllZero(row, matrix)){ + gaussMatrix = divideRowToOne(row, gaussMatrix[row][row], gaussMatrix); + } + } + if(Checker.checkToNoSolution(gaussMatrix)){ + noSolutions = true; + return null; + } + Swapper.unSwapAllC(SwapStore.swapStack, gaussMatrix); + gaussMatrix = deleteZeroRows(gaussMatrix); + if(Checker.checkToNoSolution(gaussMatrix)){ + noSolutions = true; + return null; + } + return gaussMatrix; + } + + Complex[][] calcGaussJordan(Complex[][] matrix){ + Complex[][] matrixGausJordan = calcGaussian(matrix); + if(noSolutions || matrixGausJordan == null) return null; + //from row last but one + for (int row = matrixGausJordan.length - 2; row >= 0; row--){ + //above main diagonal + // 1 a b c + // 0 1 d f + // 0 0 1 k + for (int column = row + 1; column < matrixGausJordan.length; column++){ + Complex multy = matrixGausJordan[row][column]; + for(int k = 0; k < matrixGausJordan[row].length; k++){ + Complex old = matrixGausJordan[column][k]; + Complex newItem = old.changeSign().multiply(multy).adding(matrixGausJordan[row][k]); + matrixGausJordan[row][k] = newItem; + } + } + } + if(matrixGausJordan.length < matrixGausJordan[0].length - 1){ + infinitySolutions = true; + } + //Helper.print(matrixGausJordan); + return matrixGausJordan; + } + + private Complex[][] divideRowToOne(int row, Complex divider, Complex[][] matrix){ + Complex[][] dividedMatrix = matrix; + //if(row >= matrix[0].lenght) do nothing + if(row < dividedMatrix[0].length){ + for(int column = 0; column < dividedMatrix[row].length; column++){ + Complex item = dividedMatrix[row][column]; + Complex newItem = item.divide(divider); + dividedMatrix[row][column] = newItem; + } + } + return dividedMatrix; + } + + private Complex[][] nullingRowGauss(int row, Complex[][] matrix){ + + for(int column = 0; column < row; column++){ + Complex multy = matrix[row][column]; + for(int k = 0; k < matrix[row].length; k++){ + Complex old = matrix[column][k]; + Complex newItem = old.changeSign().multiply(multy).adding(matrix[row][k]); + matrix[row][k] = newItem; + } + } + return matrix; + } + + private Complex[][] deleteZeroRows(Complex[][] matrix){ + int matrixSize = matrix.length; + for(int row = 0; row < matrixSize; row++){ + if(Checker.isAllZero(row, matrix)){ + //del row + matrix = deleteRow(row, matrix); + row--; + matrixSize--; + } + } + return matrix; + } + + private Complex[][] deleteRow (int row, Complex[][] matrix){ + Complex[][] trimMatrix = new Complex[matrix.length-1][matrix[row].length]; + for(int i = 0; i < row; i++){ + for (int j = 0; j < matrix[i].length; j ++){ + trimMatrix[i][j] = matrix[i][j]; + } + } + for(int i = row+1; i < matrix.length; i++){ + for (int j = 0; j < matrix[i].length; j++){ + trimMatrix[i-1][j] = matrix[i][j]; + } + } + return trimMatrix; + } +} diff --git a/src/solver/specialCases/Checker.java b/src/solver/specialCases/Checker.java new file mode 100644 index 0000000..503eea4 --- /dev/null +++ b/src/solver/specialCases/Checker.java @@ -0,0 +1,44 @@ +package solver.specialCases; + +import solver.Complex; + +/** + * Created by DIMA, on 07.12.2018 + */ +public class Checker { + static final double DELTA_DOUBLE = 0.000001; + + public static boolean hasMainNumber(int row, Complex[][] matrix){ + if (row >= matrix[row].length) return true; + return Math.abs(matrix[row][row].getRealPart()) > DELTA_DOUBLE || Math.abs(matrix[row][row].getImaginaryPart()) > DELTA_DOUBLE; + } + + public static boolean isZeroInRightColumn(int row, Complex[][] matrix){ + return Math.abs(matrix[row][matrix[row].length - 1].getRealPart()) > DELTA_DOUBLE || Math.abs(matrix[row][matrix[row].length - 1].getImaginaryPart()) > DELTA_DOUBLE; + } + + public static boolean isAllZero(int row, Complex[][] matrix){ + for (int column = 0; column < matrix[row].length; column++){ + if(Math.abs(matrix[row][column].getRealPart()) > DELTA_DOUBLE || Math.abs(matrix[row][column].getImaginaryPart()) > DELTA_DOUBLE) return false; + } + return true; + } + + public static boolean checkToNoSolution(Complex[][] matrix){ + for(int row = 0; row < matrix.length; row++){ + boolean zeroInLeftSide = true; + //check left side + for(int column = 0; column < matrix[0].length - 1; column ++){ + if(Math.abs(matrix[row][column].getRealPart()) > DELTA_DOUBLE || Math.abs(matrix[row][column].getImaginaryPart()) > DELTA_DOUBLE){ + zeroInLeftSide = false; + } + } + if(zeroInLeftSide){ + if(Math.abs(matrix[row][matrix[row].length - 1].getRealPart()) > DELTA_DOUBLE || Math.abs(matrix[row][matrix[row].length - 1].getImaginaryPart()) > DELTA_DOUBLE){ + return true; + } + } + } + return false; + } +} diff --git a/src/solver/specialCases/Helper.java b/src/solver/specialCases/Helper.java new file mode 100644 index 0000000..f4f09a3 --- /dev/null +++ b/src/solver/specialCases/Helper.java @@ -0,0 +1,36 @@ +package solver.specialCases; + +import solver.Complex; + +import java.util.Arrays; +import java.util.stream.Collectors; + +/** + * Created by DIMA, on 14.01.2019 + */ +public class Helper { + public static void print(Complex matrix[][]){ + System.out.println("Start print"); + StringBuilder sb = new StringBuilder(); + for(int row = 0; row < matrix.length; row++){ + for(int column = 0; column < matrix[row].length; column++){ + sb.append(matrix[row][column].getRealPart()); + double imaginary = matrix[row][column].getImaginaryPart(); + if(imaginary > 0){ + sb.append("+"); + } + if(imaginary == 0){ + sb.append(" "); + }else { + sb.append(imaginary).append("i"); + sb.append(" "); + } + + } + sb.append("\n"); + } + System.out.println(sb.toString()); + System.out.println("End print"); + } + +} diff --git a/src/solver/specialCases/Searcher.java b/src/solver/specialCases/Searcher.java new file mode 100644 index 0000000..a14365e --- /dev/null +++ b/src/solver/specialCases/Searcher.java @@ -0,0 +1,26 @@ +package solver.specialCases; + +import solver.Complex; + +/** + * Created by DIMA, on 10.12.2018 + */ +public class Searcher { + public static int searchRowDown(int startRow, Complex[][] matrix){ + for(int i = startRow + 1; i < matrix.length; i ++){ + if(Math.abs(matrix[i][startRow].getRealPart()) > Checker.DELTA_DOUBLE || Math.abs(matrix[i][startRow].getImaginaryPart()) > Checker.DELTA_DOUBLE){ + return i; + } + } + return -1; + } + + public static int searchColumnRight(int row, Complex[][] matrix){ + for(int column = row + 1; column < matrix[row].length - 1; column++){ + if(Math.abs(matrix[row][column].getRealPart()) > Checker.DELTA_DOUBLE || Math.abs(matrix[row][column].getImaginaryPart()) > Checker.DELTA_DOUBLE){ + return column; + } + } + return -1; + } +} diff --git a/src/solver/specialCases/Swap.java b/src/solver/specialCases/Swap.java new file mode 100644 index 0000000..0902e46 --- /dev/null +++ b/src/solver/specialCases/Swap.java @@ -0,0 +1,22 @@ +package solver.specialCases; + +/** + * Created by DIMA, on 06.12.2018 + */ +public class Swap { + private int oldColumnsNumber; + private int newColumnsNumber; + + public Swap(int oldColumnsNumber, int newColumnsNumber) { + this.oldColumnsNumber = oldColumnsNumber; + this.newColumnsNumber = newColumnsNumber; + } + + public int getOldColumnsNumber() { + return oldColumnsNumber; + } + + public int getNewColumnsNumber() { + return newColumnsNumber; + } +} diff --git a/src/solver/specialCases/SwapStore.java b/src/solver/specialCases/SwapStore.java new file mode 100644 index 0000000..8e36974 --- /dev/null +++ b/src/solver/specialCases/SwapStore.java @@ -0,0 +1,23 @@ +package solver.specialCases; + +import java.util.ArrayDeque; +import java.util.Arrays; +import java.util.Deque; +import java.util.Stack; +import java.util.stream.Collectors; + +/** + * Created by DIMA, on 06.12.2018 + */ +public class SwapStore { + public static Deque swapStack = new ArrayDeque<>(); + + public static void addSwap(int oldColumn, int newColumn){ + Swap swap = new Swap(oldColumn, newColumn); + swapStack.addLast(swap); + } + + + + +} diff --git a/src/solver/specialCases/Swapper.java b/src/solver/specialCases/Swapper.java new file mode 100644 index 0000000..b13973c --- /dev/null +++ b/src/solver/specialCases/Swapper.java @@ -0,0 +1,41 @@ +package solver.specialCases; + +import solver.Complex; + +import java.util.Deque; + +/** + * Created by DIMA, on 07.12.2018 + */ +public class Swapper { + + public static void swapColumns (int oldColumns, int newColumns, Complex[][] matrix){ + for (int row = 0; row < matrix.length; row++){ + Complex tmp = matrix[row][newColumns]; + matrix[row][newColumns] = matrix[row][oldColumns]; + matrix[row][oldColumns] = tmp; + } + } + + public static void swapRows(int oldRow, int newRow, Complex[][] matrix){ + for(int column = 0; column < matrix[oldRow].length; column++){ + Complex tmp = matrix[newRow][column]; + matrix[newRow][column] = matrix[oldRow][column]; + matrix[oldRow][column] = tmp; + } + } + + private static void unSwapColumns(Swap swap, Complex[][] matrix){ + int oldColumn = swap.getNewColumnsNumber(); + int newColumn = swap.getOldColumnsNumber(); + swapColumns (oldColumn, newColumn, matrix); + } + + public static void unSwapAllC(Deque swapDeque, Complex[][] matrix){ + Swap swap; + while ((swap = swapDeque.pollLast()) != null){ + unSwapColumns(swap, matrix); + } + } + +} diff --git a/src/solver/specialCases/TesterResult.java b/src/solver/specialCases/TesterResult.java new file mode 100644 index 0000000..0f33e0e --- /dev/null +++ b/src/solver/specialCases/TesterResult.java @@ -0,0 +1,26 @@ +package solver.specialCases; + +import solver.Complex; + +import java.math.BigDecimal; +import java.util.List; + +/** + * Created by DIMA, on 17.01.2019 + */ +public class TesterResult { + public static void testingResult(Complex[][] matrix, List answer){ + for(int row = 0; row < matrix.length; row++){ + Complex resultRow = matrix[row][0].multiply(answer.get(0)); + for(int column = 1; column < matrix[0].length-1; column++){ + resultRow = matrix[row][column].multiply(answer.get(column)).adding(resultRow); + } + double xReal = resultRow.getRealPart(); + double xImaginary = resultRow.getImaginaryPart(); + xReal = new BigDecimal(xReal).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue(); + xImaginary = new BigDecimal(xImaginary).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue(); + resultRow = new Complex(xReal, xImaginary); + System.out.println(resultRow + " = " + matrix[row][matrix[0].length-1]); + } + } +} diff --git a/src/solver/tmpTests/CopyArr.java b/src/solver/tmpTests/CopyArr.java new file mode 100644 index 0000000..6933215 --- /dev/null +++ b/src/solver/tmpTests/CopyArr.java @@ -0,0 +1,32 @@ +package solver.tmpTests; + +import solver.specialCases.Helper; +import solver.specialCases.SwapStore; + +import java.util.Arrays; + +/** + * Created by DIMA, on 10.12.2018 + */ +public class CopyArr { + public static void main(String[] args) { + double[][] a1 = {{1,1}, {2,2}, {0, 0}, {4,4}, {5,5}}; + double[][] a2; + double[][] a3; + + a2 = Arrays.copyOf(a1, 2); + //Helper.print(a2); + + a3 = Arrays.copyOfRange(a1, 3, a1.length); + //Helper.print(a3); + + + + + + + + + + } +} diff --git a/src/solver/tmpTests/TestSplit.java b/src/solver/tmpTests/TestSplit.java new file mode 100644 index 0000000..6b7e314 --- /dev/null +++ b/src/solver/tmpTests/TestSplit.java @@ -0,0 +1,78 @@ +package solver.tmpTests; + +import solver.Complex; + +/** + * Created by DIMA, on 16.01.2019 + */ +public class TestSplit { + + private static Complex parseComplexString(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; + + } + return new Complex(real, imaginary); + } + + public static void main(String[] args) { + String[] items = {"1.5-1.1i", "-2.3i", "-1.6-2.6i", "-2.3", "5.6i", "5.6", "1.6+5.6i"}; + for(String item : items){ + System.out.println(parseComplexString(item)); + } + + } +} diff --git a/src/solver/tmpTests/TestVoid.java b/src/solver/tmpTests/TestVoid.java new file mode 100644 index 0000000..702b2a6 --- /dev/null +++ b/src/solver/tmpTests/TestVoid.java @@ -0,0 +1,55 @@ +package solver.tmpTests; + +import java.util.Arrays; +import java.util.stream.Collectors; + +/** + * Created by DIMA, on 17.12.2018 + */ +public class TestVoid { + public String getStringMultyTwo(int [] arr){ + String s = Arrays.stream(arr).boxed().map(String::valueOf).collect(Collectors.joining(" ")); + System.out.println(s); + arr = deleteElem(arr, 3); + s = Arrays.stream(arr).boxed().map(String::valueOf).collect(Collectors.joining(" ")); + System.out.println(s); + devide(arr, 3); + return Arrays.stream(arr).boxed().map(String::valueOf).collect(Collectors.joining(" ")); + + + + } + + private int[] deleteElem(int[] arr, int index){ + int[] ar1 = new int[arr.length -1]; + for(int i = 0; i < index; i++){ + ar1[i] = arr[i]; + } + for(int i = index+1; i < arr.length; i++){ + ar1[i-1] = arr[i]; + } + //System.out.println(Arrays.stream(ar1).boxed().map(String::valueOf).collect(Collectors.joining(" "))); + return ar1; + } + + private void changeInt(int a){ + a = a*2; + } + + private void devide (int[] arr, int a){ + for(int i = 0; i < arr.length; i++){ + arr[i] = arr[i]/a; + } + + + + } + + public static void main(String[] args) { + int[] a = {0,1,2,3,4,5,6,7}; + TestVoid t = new TestVoid(); + System.out.println(t.getStringMultyTwo(a)); + } + + +}