forked from hummel/PR1-Spreadsheet
422 lines
13 KiB
Java
422 lines
13 KiB
Java
package de.hs_mannheim.informatik.spreadsheet;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.lang.reflect.Array;
|
|
import java.util.ArrayList;
|
|
import java.util.Scanner;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
|
|
|
|
|
|
/**
|
|
* A simplified spreadsheet class for the PR1 programming lab at Hochschule Mannheim.
|
|
* One aspect worth mentioning is that it only supports long numbers, not doubles.
|
|
*
|
|
* @author Oliver Hummel
|
|
*/
|
|
public class Spreadsheet {
|
|
Cell[][] cells;
|
|
|
|
/**
|
|
* Constructor that creates a Spreadsheet of size rows * cols.
|
|
* @param rows number of rows
|
|
* @param cols number of columns
|
|
*/
|
|
public Spreadsheet(int rows, int cols) throws IllegalArgumentException {
|
|
|
|
if(rows < 1 || rows > 99 || cols < 1 || cols > 26){
|
|
throw new IllegalArgumentException("Range in rows 1-99; Range in cols 1-26");
|
|
}else {
|
|
cells = new Cell[rows][cols];
|
|
|
|
for (int r = 0; r < rows; r++)
|
|
for (int c = 0; c < cols; c++)
|
|
cells[r][c] = new Cell();
|
|
}
|
|
}
|
|
|
|
// -----
|
|
// retrieve or change values of cells
|
|
|
|
private String get(int row, int col) {
|
|
return cells[row][col].getValue();
|
|
}
|
|
|
|
public String get(String cellName) {
|
|
cellName = cellName.toUpperCase();
|
|
return get(getRow(cellName), getCol(cellName));
|
|
}
|
|
|
|
private void put(int row, int col, String value) {
|
|
if (!value.startsWith("="))
|
|
cells[row][col].setValue(value);
|
|
else {
|
|
cells[row][col].setFormula(value);
|
|
evaluateCell(row, col);
|
|
}
|
|
}
|
|
|
|
public void put(String cellName, String value) {
|
|
cellName = cellName.toUpperCase();
|
|
put(getRow(cellName), getCol(cellName), value);
|
|
}
|
|
|
|
private int getCol(String cellName) {
|
|
return cellName.charAt(0) - 'A';
|
|
}
|
|
|
|
private int getRow(String cellName) {
|
|
if(cellName.length()==3){
|
|
return Integer.parseInt(cellName.substring(1))-1;}
|
|
return cellName.charAt(1) - '1';
|
|
}
|
|
|
|
// -----
|
|
// business logic
|
|
|
|
/**
|
|
* A method for reading in data from a CSV file.
|
|
* @param path The file to read.
|
|
* @param separator The char used to split up the input, e.g. a comma or a semicolon.
|
|
* @exception IOException If path does not exist.
|
|
*/
|
|
public void readCsv(String path, String separator) throws FileNotFoundException {
|
|
|
|
ArrayList<String> lines = new ArrayList<>();
|
|
Scanner scan = new Scanner(new File(path));
|
|
|
|
while (scan.hasNextLine()) {
|
|
lines.add(scan.nextLine());
|
|
}
|
|
|
|
String[] linesArray = lines.toArray(new String[lines.size()]);
|
|
ArrayList<int[]> values = new ArrayList<>();
|
|
for(int i = 0; i < linesArray.length; i++) {
|
|
//System.out.println(linesArray[i]);
|
|
String[] zwischenSchritt = linesArray[i].split(separator);
|
|
for (int j = 0; j < zwischenSchritt.length; j++) {
|
|
System.out.println(zwischenSchritt[j]);
|
|
if(zwischenSchritt[j].startsWith("=")){
|
|
values.add(new int[]{i, j});
|
|
}else{
|
|
this.put(i, j, zwischenSchritt[j]);
|
|
}
|
|
|
|
}
|
|
for(int[] cell : values){
|
|
String[] value = linesArray[cell[0]].split(",");
|
|
String formula = value[cell[1]];
|
|
this.put(cell[0], cell[1], formula);
|
|
}
|
|
scan.close();
|
|
}
|
|
|
|
|
|
}
|
|
/**
|
|
* A method for saving data to a CSV file.
|
|
* @param path The file to write.
|
|
* @exception IOException If path does not exist.
|
|
*/
|
|
public void saveCsv(String path) throws FileNotFoundException {
|
|
PrintWriter out = new PrintWriter(path);
|
|
|
|
for (Cell[] row : cells) {
|
|
for (Cell cell : row) {
|
|
if (!cell.getFormula().isEmpty())
|
|
out.print("=" + cell.getFormula());
|
|
else
|
|
out.print(cell.getValue());
|
|
|
|
if (cell != row[cells[0].length-1])
|
|
out.print(",");
|
|
}
|
|
out.println();
|
|
}
|
|
|
|
out.close();
|
|
}
|
|
|
|
/**
|
|
* This method does the actual evaluation/calcluation of a specific cell
|
|
* @param row the row of the cell to be evaluated
|
|
* @param col the col of the cell to be evaluated
|
|
*/
|
|
private void evaluateCell(int row, int col) {
|
|
String formula = cells[row][col].getFormula();
|
|
String result = "";
|
|
int colon = formula.indexOf(':');
|
|
String endSubstring = formula.substring((colon + 1), (formula.length()-1));
|
|
|
|
if (formula.startsWith("SUMME(")) // e.g. SUMME(A3:A8)
|
|
result = "" + sum(formula.substring(6, colon), endSubstring);
|
|
else if (formula.startsWith("PRODUKT(")) // e.g. PRODUKT(A3:B9)
|
|
result = "" + prod(formula.substring(8, colon), endSubstring);
|
|
else if (formula.startsWith("MITTELWERT(")) // e.g. MITTELWERT(A3:A5)
|
|
result = "" + mit(formula.substring(11, colon), endSubstring);
|
|
else if (formula.startsWith("STABW(")) // e.g. STABW(C6:D8) -> Standardabweichung
|
|
result = "" + stabw(formula.substring(6, colon), endSubstring);
|
|
else if (formula.startsWith("MIN(")) // e.g. MIN(C13:H13) -> kleinster Wert
|
|
result = "" + min(formula.substring(4, colon), endSubstring);
|
|
else if (formula.startsWith("MAX(")) // e.g. MAX(A1:A10) -> größter Wert
|
|
result = "" + max(formula.substring(4, colon), endSubstring);
|
|
else if (!formula.isEmpty()) {
|
|
try {
|
|
result = "" + calculate(formula);
|
|
} catch(ArithmeticException ae) {
|
|
result = "exc.";
|
|
}
|
|
}
|
|
|
|
cells[row][col].setValue("" + result);
|
|
}
|
|
|
|
/**
|
|
* Method for calculating the amount of cells with values inside a rectangular block of cells, such as from A1 to B3.
|
|
* @param startCellName The name of the cell in the upper left corner of the rectangle.
|
|
* @param endCellName The name of the cell in the lower right corner of the rectangle.
|
|
* @return The counted cells with values calculated.
|
|
*/
|
|
private long counterOfCellsWithValue(String startCellName, String endCellName){
|
|
long counter = 0;
|
|
for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){
|
|
|
|
for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {
|
|
String value = get((row - 1), (col - 'A'));
|
|
|
|
if(!value.isEmpty()){
|
|
counter++;
|
|
}
|
|
}
|
|
}
|
|
return counter;
|
|
}
|
|
|
|
/**
|
|
* Method for calculating the sum of a rectangular block of cells, such as from A1 to B3.
|
|
* @param startCellName The name of the cell in the upper left corner of the rectangle.
|
|
* @param endCellName The name of the cell in the lower right corner of the rectangle.
|
|
* @return The sum calculated.
|
|
*/
|
|
private long sum(String startCellName, String endCellName) {
|
|
long result = 0;
|
|
|
|
for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){
|
|
|
|
for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {
|
|
|
|
String value = get((row - 1), (col - 'A')); //"-1" because we start with 1 instead of 0. "-A" because A in ascii is 65, but we start with 0
|
|
|
|
if(!value.isEmpty()){
|
|
result += Long.parseLong(value);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Method for calculating the product of a rectangular block of cells, such as from A1 to B3.
|
|
* @param startCellName The name of the cell in the upper left corner of the rectangle.
|
|
* @param endCellName The name of the cell in the lower right corner of the rectangle.
|
|
* @return The product calculated.
|
|
*/
|
|
private long prod(String startCellName, String endCellName) {
|
|
long result = 0;
|
|
|
|
for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){
|
|
|
|
for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {
|
|
|
|
String value = get((row - 1), (col - 'A'));
|
|
System.out.println(value);
|
|
|
|
if(result == 0){
|
|
result = Long.parseLong(value);
|
|
|
|
}
|
|
else if(!value.isEmpty() && !(value.equals("0"))){
|
|
result *= Long.parseLong(value);
|
|
}
|
|
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Method for calculating the arithmetic average of a rectangular block of cells, such as from A1 to B3.
|
|
* @param startCellName The name of the cell in the upper left corner of the rectangle.
|
|
* @param endCellName The name of the cell in the lower right corner of the rectangle.
|
|
* @return The arithmetic average calculated.
|
|
*/
|
|
private long mit(String startCellName, String endCellName) {
|
|
|
|
return sum(startCellName, endCellName)/ counterOfCellsWithValue(startCellName, endCellName);
|
|
}
|
|
|
|
/**
|
|
* Method for calculating the standard deviation of a rectangular block of cells, such as from A1 to B3.
|
|
* @param startCellName The name of the cell in the upper left corner of the rectangle.
|
|
* @param endCellName The name of the cell in the lower right corner of the rectangle.
|
|
* @return The standard deviation calculated.
|
|
*/
|
|
private long stabw(String startCellName, String endCellName) {
|
|
long mean = mit(startCellName, endCellName);
|
|
long counter = counterOfCellsWithValue(startCellName, endCellName);
|
|
long result = 0;
|
|
|
|
for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++) {
|
|
|
|
for (int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {
|
|
|
|
String value = get((row - 1), (col - 'A'));
|
|
|
|
if(!value.isEmpty()){
|
|
result += (long) Math.pow(Long.parseLong(value) - mean, 2);
|
|
}
|
|
}
|
|
}
|
|
return (long) Math.sqrt(result / counter);
|
|
}
|
|
|
|
/**
|
|
* Method for finding the maximum value of a rectangular block of cells, such as from A1 to B3.
|
|
* @param startCellName The name of the cell in the upper left corner of the rectangle.
|
|
* @param endCellName The name of the cell in the lower right corner of the rectangle.
|
|
* @return The minimum value of the block.
|
|
*/
|
|
private long min(String startCellName, String endCellName) {
|
|
long result = 0;
|
|
|
|
for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){
|
|
|
|
for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {
|
|
|
|
String value = get((row - 1), (col - 'A')); //"-1" because we start with 1 instead of 0. "-A" because A in ascii is 65, but we start with 0
|
|
|
|
if((col == startCellName.charAt(0)) && (row == Integer.parseInt(startCellName.substring(1)))) {
|
|
result = Long.parseLong(value);
|
|
}
|
|
else if(!value.isEmpty() && (Long.parseLong(value) < result)){
|
|
result = Long.parseLong(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Method for finding the maximum value of a rectangular block of cells, such as from A1 to B3.
|
|
* @param startCellName The name of the cell in the upper left corner of the rectangle.
|
|
* @param endCellName The name of the cell in the lower right corner of the rectangle.
|
|
* @return The maximum value of the block.
|
|
*/
|
|
private long max(String startCellName, String endCellName) {
|
|
long result = 0;
|
|
|
|
for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){
|
|
|
|
for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {
|
|
|
|
String value = get((row - 1), (col - 'A')); //"-1" because we start with 1 instead of 0. "-A" because A in ascii is 65, but we start with 0
|
|
|
|
if((col == startCellName.charAt(0)) && (row == Integer.parseInt(startCellName.substring(1)))) {
|
|
result = Long.parseLong(value);
|
|
}
|
|
else if(!value.isEmpty() && (Long.parseLong(value) > result)){
|
|
result = Long.parseLong(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* This method calculates the result of a "normal" algebraic expression. It only needs to support
|
|
* expressions like =B4 or =2+A3-B2, i.e. only with int numbers and other cells and with plus,
|
|
* minus, times, split only. An expression always starts with either a number or a cell name. If it
|
|
* continues, it is guaranteed that this is followed by an operator and either a number or a
|
|
* cell name again. It is NOT required to implement dot before dash or parentheses in formulas.
|
|
* @param formula The expression to be evaluated.
|
|
* @return The result calculated.
|
|
*/
|
|
private long calculate(String formula) throws ArithmeticException {
|
|
Matcher m = Pattern.compile("([A-Z][0-9]*)|[-\\+\\*/]|[0-9]*").matcher(formula);
|
|
|
|
long res = 0;
|
|
char operator = '+';
|
|
|
|
while (m.find()) {
|
|
String s = m.group();
|
|
long value;
|
|
|
|
if(s.isEmpty()){
|
|
continue;
|
|
}
|
|
|
|
if (!(s.matches("[-\\+\\*/]"))) {
|
|
if(s.matches("[A-Z][0-9]*")) {
|
|
int col = this.getCol(s);
|
|
int row = this.getRow(s);
|
|
|
|
value = Long.parseLong(cells[row][col].getValue());
|
|
|
|
}else{
|
|
value = Long.parseLong(s);
|
|
}
|
|
|
|
switch(operator) {
|
|
case '+':
|
|
res += value;
|
|
break;
|
|
case '-':
|
|
res -= value;
|
|
break;
|
|
case '*':
|
|
res *= value;
|
|
break;
|
|
case '/':
|
|
if (res != 0) {
|
|
res /= value;
|
|
break;
|
|
}
|
|
}
|
|
}else{
|
|
operator = s.charAt(0);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// -----
|
|
|
|
public String toString() {
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.append(" ");
|
|
for (int i = 0; i < cells[0].length; i++) {
|
|
sb.append(" " + (char)('A'+ i) + " | ");
|
|
}
|
|
|
|
int rc = 1;
|
|
for (Cell[] r : cells) {
|
|
sb.append(System.lineSeparator());
|
|
sb.append(String.format("%2s", rc++) + ": ");
|
|
|
|
for (Cell c : r) {
|
|
sb.append(c + " | ");
|
|
}
|
|
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
} |