id stringlengths 36 36 | text stringlengths 1 1.25M |
|---|---|
1259f8d8-488b-40b6-8108-b3fabc62a3ec | protected ArrayList<Node> getNeighbours(int x, int y) {
for(int i = 0; i < nodes.length; i++){
if((nodes[i].location.x == x)&&(nodes[i].location.y == y)){
return nodes[i].getNeighbours();
}
}
return null;
} |
5ffd9fe1-6c95-4c78-956e-5e695eef82ff | private void initNodes() {
Point p = new Point(0, 0);
for (int i = 0; i < 18; i++) {
placedPieces.add(p);
}
int x = 8;
int y = 6;
nodes[0] = new Node("O_0", x, y);
x = 218;
y = 6;
nodes[1] = new Node("O_1", x, y);
x = 442;
y = 6;
nodes[2] = new Node("O_2", x, y);
x = 70;
y = 70;
nodes[3] = new Node("M_0", x, y);
x = 218;
y = 70;
nodes[4] = new Node("M_1", x, y);
x = 370;
y = 70;
nodes[5] = new Node("M_2", x, y);
x = 140;
y = 140;
nodes[6] = new Node("I_0", x, y);
x = 218;
y = 140;
nodes[7] = new Node("I_1", x, y);
x = 310;
y = 140;
nodes[8] = new Node("I_2", x, y);
x = 8;
y = 230;
nodes[9] = new Node("O_3", x, y);
x = 70;
y = 230;
nodes[10] = new Node("M_3", x, y);
x = 140;
y = 230;
nodes[11] = new Node("I_3", x, y);
x = 310;
y = 230;
nodes[12] = new Node("I_4", x, y);
x = 370;
y = 230;
nodes[13] = new Node("M_4", x, y);
x = 442;
y = 230;
nodes[14] = new Node("O_4", x, y);
x = 140;
y = 310;
nodes[15] = new Node("I_5", x, y);
x = 218;
y = 310;
nodes[16] = new Node("I_6", x, y);
x = 310;
y = 310;
nodes[17] = new Node("I_7", x, y);
x = 70;
y = 370;
nodes[18] = new Node("M_5", x, y);
x = 218;
y = 370;
nodes[19] = new Node("M_6", x, y);
x = 370;
y = 370;
nodes[20] = new Node("M_7", x, y);
x = 8;
y = 442;
nodes[21] = new Node("O_5", x, y);
x = 218;
y = 442;
nodes[22] = new Node("O_6", x, y);
x = 442;
y = 442;
nodes[23] = new Node("O_7", x, y);
for (int i = 0; i < nodes.length; i++) {
nodes[i].setIsBusy(0);
}
setNeighbours();
} |
06bcf6a5-41ca-4136-bd50-9f8cdeecaaaa | private void setNeighbours() {
nodes[0].addNeighbour(nodes[1]); // outer top left
nodes[0].addNeighbour(nodes[9]);
nodes[1].addNeighbour(nodes[0]); // outer top center
nodes[1].addNeighbour(nodes[2]);
nodes[1].addNeighbour(nodes[4]);
nodes[2].addNeighbour(nodes[1]); // outer top right
nodes[2].addNeighbour(nodes[14]);
nodes[3].addNeighbour(nodes[4]); // middle top right
nodes[3].addNeighbour(nodes[10]);
nodes[4].addNeighbour(nodes[1]); // middle top center
nodes[4].addNeighbour(nodes[3]);
nodes[4].addNeighbour(nodes[5]);
nodes[4].addNeighbour(nodes[7]);
nodes[5].addNeighbour(nodes[4]); // middle top right
nodes[5].addNeighbour(nodes[13]);
nodes[6].addNeighbour(nodes[7]); // inner top left
nodes[6].addNeighbour(nodes[11]);
nodes[7].addNeighbour(nodes[4]); // inner top center
nodes[7].addNeighbour(nodes[6]);
nodes[7].addNeighbour(nodes[8]);
nodes[8].addNeighbour(nodes[7]); // inner top right
nodes[8].addNeighbour(nodes[12]);
nodes[9].addNeighbour(nodes[0]); // outer middle left
nodes[9].addNeighbour(nodes[10]);
nodes[9].addNeighbour(nodes[21]);
nodes[10].addNeighbour(nodes[3]); // middle middle left
nodes[10].addNeighbour(nodes[9]);
nodes[10].addNeighbour(nodes[11]);
nodes[10].addNeighbour(nodes[18]);
nodes[11].addNeighbour(nodes[6]); // inner middle left
nodes[11].addNeighbour(nodes[10]);
nodes[11].addNeighbour(nodes[15]);
nodes[12].addNeighbour(nodes[8]); // inner middle right
nodes[12].addNeighbour(nodes[13]);
nodes[12].addNeighbour(nodes[17]);
nodes[13].addNeighbour(nodes[5]); // middle middle right
nodes[13].addNeighbour(nodes[12]);
nodes[13].addNeighbour(nodes[14]);
nodes[13].addNeighbour(nodes[20]);
nodes[14].addNeighbour(nodes[2]); // outer middle right
nodes[14].addNeighbour(nodes[13]);
nodes[14].addNeighbour(nodes[23]);
nodes[15].addNeighbour(nodes[11]); // inner bottom left
nodes[15].addNeighbour(nodes[16]);
nodes[16].addNeighbour(nodes[15]); // inner bottom center
nodes[16].addNeighbour(nodes[17]);
nodes[16].addNeighbour(nodes[19]);
nodes[17].addNeighbour(nodes[12]); // inner bottom right
nodes[17].addNeighbour(nodes[16]);
nodes[18].addNeighbour(nodes[10]); // middle bottom left
nodes[18].addNeighbour(nodes[19]);
nodes[19].addNeighbour(nodes[16]); // middle bottom center
nodes[19].addNeighbour(nodes[18]);
nodes[19].addNeighbour(nodes[20]);
nodes[19].addNeighbour(nodes[22]);
nodes[20].addNeighbour(nodes[13]); // middle bottom right
nodes[20].addNeighbour(nodes[19]);
nodes[21].addNeighbour(nodes[9]); // outer bottom left
nodes[21].addNeighbour(nodes[22]);
nodes[22].addNeighbour(nodes[19]); // outer bottom center
nodes[22].addNeighbour(nodes[21]);
nodes[22].addNeighbour(nodes[23]);
nodes[23].addNeighbour(nodes[14]); // outer bottom right
nodes[23].addNeighbour(nodes[22]);
} |
ec1f7bf4-5b8f-4203-bfbf-3cb1270c4a4a | private void setupEventFields(int counter) {
initNodes();
for (int i = 0; i < counter; i++) {
final JLabel interactionFields = new JLabel();
interactionFields.setHorizontalAlignment(SwingConstants.CENTER);
interactionFields.setBounds(nodes[i].location.x,
nodes[i].location.y, 50, 50);
interactionFields.setCursor(Cursor
.getPredefinedCursor(Cursor.HAND_CURSOR));
interactionFields.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent arg0) {
boolean automateAI = true;
int limitMoves = 0;
while(automateAI && placedCounter < 18){
if(!deleteFlag){
if(setting.getPlayer1().contains("Computer")){
brain.setStone(nodes, 1);
}
else{
setStones(interactionFields.getLocation());
automateAI = false;
}
}
if(!deleteFlag && setting.getPlayer2().contains("Computer")){
brain.setStone(nodes, 2);
}
}
while(automateAI && placedCounter >= 18 && limitMoves < 1){
limitMoves++;
if(!deleteFlag){
if(setting.getPlayer1().contains("Computer")){
if(countPieces(true) <= 3){
System.out.println(countPieces(true));
brain.jumpStone(nodes, 1);
}else{
System.out.println(countPieces(true));
brain.moveStone(nodes, 1);
}
}
else{
setStones(interactionFields.getLocation());
automateAI = false;
}
}
if(!deleteFlag && setting.getPlayer2().contains("Computer")){
if(countPieces(false) <= 3){
System.out.println(countPieces(false));
brain.jumpStone(nodes, 2);
}else{
System.out.println(countPieces(false));
brain.moveStone(nodes, 2);
}
}
}
}
});
centerPanel.add(interactionFields, 1);
}
} |
43e5b5c7-6722-4511-9768-6ed0e6a5e62e | @Override
public void mouseClicked(MouseEvent arg0) {
boolean automateAI = true;
int limitMoves = 0;
while(automateAI && placedCounter < 18){
if(!deleteFlag){
if(setting.getPlayer1().contains("Computer")){
brain.setStone(nodes, 1);
}
else{
setStones(interactionFields.getLocation());
automateAI = false;
}
}
if(!deleteFlag && setting.getPlayer2().contains("Computer")){
brain.setStone(nodes, 2);
}
}
while(automateAI && placedCounter >= 18 && limitMoves < 1){
limitMoves++;
if(!deleteFlag){
if(setting.getPlayer1().contains("Computer")){
if(countPieces(true) <= 3){
System.out.println(countPieces(true));
brain.jumpStone(nodes, 1);
}else{
System.out.println(countPieces(true));
brain.moveStone(nodes, 1);
}
}
else{
setStones(interactionFields.getLocation());
automateAI = false;
}
}
if(!deleteFlag && setting.getPlayer2().contains("Computer")){
if(countPieces(false) <= 3){
System.out.println(countPieces(false));
brain.jumpStone(nodes, 2);
}else{
System.out.println(countPieces(false));
brain.moveStone(nodes, 2);
}
}
}
} |
6b5e461b-89c7-4fd3-997e-1f7dd4eaf5e3 | private int countPieces(boolean whitesTurn) {
int state = 0;
int count = 0;
if(whitesTurn){
state = 1;
}
else{
state = 2;
}
for(Node n : nodes){
if(n.getIsBusy() == state){
count++;
}
}
return count;
} |
c4be9b7c-af07-4b47-8577-46dd766a33b8 | private boolean checkPlace(Point location) {
boolean check = false;
for (Point p : placedPieces) {
if ((p.x == location.x)
&& (p.y == location.y)) {
check = true;
break;
} else {
check = false;
}
}
return check;
} |
2d9a4b8e-494e-45ff-8849-67fd134db421 | public void setStones(Point point) {
// System.out.println("+++SETSTONES+++");
if (placedCounter <= 17) {
if (!checkPlace(point)) {
if (turnOfStarter) {
getNode(point).setIsBusy(1);
whites[whitePointer].setLocation(point);
centerPanel.add(whites[whitePointer], 0);
whitePointer++;
Point p = new Point();
p.x = point.x;
p.y = point.y;
placedPieces.add(p);
placedCounter++;
deletePiece(referee.checkRules(nodes,whitesTurn));
whitesTurn = false;
blacksTurn = true;
}
else {
getNode(point).setIsBusy(2);
blacks[blackPointer].setLocation(point);
centerPanel.add(blacks[blackPointer], 0);
blackPointer++;
Point p = new Point();
p.x = point.x;
p.y = point.y;
placedPieces.add(p);
placedCounter++;
deletePiece(referee.checkRules(nodes,whitesTurn));
whitesTurn = true;
blacksTurn = false;
}
if(whitesTurn){
txtLogArea.append("Whites turn!\n");
}
else{
txtLogArea.append("Blacks turn!\n");
}
turnOfStarter = !turnOfStarter;
}
} else {
if(selectedPiece != null){
Node resetNode = getNode(new Point(selectedPiece.getBounds().x,selectedPiece.getBounds().y));
int x = point.x;
int y = point.y;
Node n = getNode(new Point(x,y));
boolean isNeighbour = false;
ArrayList<Node> tmp = getNeighbours(selectedPiece.getBounds().x,selectedPiece.getBounds().y);
for(Node tmpN : tmp){
//System.out.println(tmpN.getId());
if(tmpN.getId().equals(n.getId())){
isNeighbour = true;
}
}
if(countPieces(whitesTurn) <= 3){
System.out.println("HOPPING ACTION");
if(n.getIsBusy() == 0){
selectedPiece.setBounds(x,y, 50, 50);
n.setIsBusy(resetNode.getIsBusy());
resetNode.setIsBusy(0);
selectedPiece = null;
deletePiece(referee.checkRules(nodes,whitesTurn));
whitesTurn = !whitesTurn;
blacksTurn = !blacksTurn;
if(whitesTurn){
txtLogArea.append("Whites turn!\n");
}
else{
txtLogArea.append("Blacks turn!\n");
}
}
}
else{
System.out.println("RUECK ACTION");
if(n.getIsBusy() == 0 && isNeighbour){
selectedPiece.setBounds(x,y, 50, 50);
n.setIsBusy(resetNode.getIsBusy());
resetNode.setIsBusy(0);
selectedPiece = null;
deletePiece(referee.checkRules(nodes,whitesTurn));
whitesTurn = !whitesTurn;
blacksTurn = !blacksTurn;
if(whitesTurn){
txtLogArea.append("Whites turn!\n");
}
else{
txtLogArea.append("Blacks turn!\n");
}
}
}
}
}
} |
f191e83d-14da-47ac-b030-0745c91151eb | protected void deletePiece(boolean checkRules) {
if(checkRules){
txtLogArea.append("############## Mill! ############### \n");
txtLogArea.append("## Select piece to delete then... ## \n");
txtLogArea.append("################################# \n");
deleteFlag = true;
}
} |
50d6c583-f42d-469d-a74b-56de442d6f3c | protected ImageIcon createImageIcon(String path) {
URL imgURL = getClass().getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
} |
1ba18d9c-868d-4a42-9834-d62d826f3b9c | protected Node getNode(Point location) {
for(int i = 0; i < nodes.length; i++){
if((nodes[i].location.x == location.x)&&(nodes[i].location.y == location.y)){
return nodes[i];
}
}
return null;
} |
09f625e9-5fa8-4cfe-ad3f-49d66461dacf | public int getPlacedCounter() {
return placedCounter;
} |
230bf0f7-accf-481c-8304-e07882856b01 | public void setPlacedCounter(int placedCounter) {
this.placedCounter = placedCounter;
} |
d18bf7db-e359-4071-86a7-9a1d70de08fb | public String getId() {
return id;
} |
d26e8ada-6c34-4e3d-b09b-ef66fca39724 | public Node (String id, int x, int y) {
this.id = id;
location = new Point(x, y);
} |
679977fc-aae1-4fdd-96c0-62f3a27022f3 | public void addNeighbour(Node k){
neighbours.add(k);
} |
a28dbe5c-e08e-48a7-ba9d-d35c5905f28d | public ArrayList<Node> getNeighbours(){
return neighbours;
} |
cd24754e-1fad-46c3-9265-742579c5ed86 | public void setIsBusy(int state){
isBusy = state;
} |
7d356771-d237-456e-b228-0ad6fdba9d01 | public int getIsBusy() {
return isBusy;
} |
4ce10f81-c2d2-4519-beaa-f15488d8e96d | public boolean getUnchangedFlag() {
return unchangedFlag;
} |
87eb79e3-7234-4a0e-982e-13b15f833bc9 | public void setUnchangedFlag(boolean check) {
unchangedFlag = check;
} |
6bc25a54-20d6-4cf7-96b4-beb390aa3d72 | public static void main(String[] args) throws Exception {
BufferedReader CSVFile =
new BufferedReader(new FileReader("/home/mathias/1.csv"));
String dataRow = CSVFile.readLine(); // read fist line.
System.out.println(dataRow);
while(dataRow != null) {
String[] dataArray = dataRow.split(",");
for(String item:dataArray)
System.out.print(item + "\t");
System.out.println();
dataRow = CSVFile.readLine();
}
CSVFile.close();
System.out.println();
} |
0b5685aa-7c13-4eae-951d-d478980c92fa | public Item(String performer, double value, String date) {
this.performer = performer; this.date = date;
this.value = value;
} |
6d518648-13c6-4c47-9bea-0272f191257c | @Override
public String getPerformer() { return performer; } |
5359b184-e662-4ef8-a319-72cd571ccac4 | @Override
public double getTransactionValue() { return value; } |
dd412ece-2959-43ff-bec0-2df212fec345 | @Override
public String getDate() { return date; } |
e496addd-bad9-4741-8784-9626e238712a | @Override
public void setPerformer(String name) { performer = name; } |
d5658251-1449-44ca-92cb-74887ed2636d | @Override
public void setTransactionValue(double value) { this.value = value; } |
9255b80b-3a81-4f8a-82cf-7fafd216ad90 | @Override
public void setDate(String date) { this.date = date; } |
ce4adefa-ae1f-43a3-9369-576e9d7d74df | public String toString() {
return getDate() +
"\t" +
getPerformer()
+ "\t"
+ "$"
+ getTransactionValue()
+ " million";
} |
af192f5f-ff7d-43df-b4c1-c4329ceced7b | public Comparator<Item> getTransactionValueComparator(); |
e3463e00-3764-44f0-bfed-11143aba9199 | public Comparator<Item> getTransactionDateComparator(); |
2d9c3a5e-95a1-471a-8f85-8bb5110b16d6 | public double percentileValue(List<Item> items, int percentile); |
63c1ba71-5971-48f4-9054-8492a3cd999a | public boolean isOutlier(Item item, double thresholdLow, double thresholdHigh); |
d1531b26-fcf4-43e7-9717-d3b33b78ac24 | public double thresholdDistance(Item item, double thresholdLow, double thresholdHigh); |
6d2f863c-85f9-44bd-beb0-93addf50d0ca | public Comparator<Item> getThresholdDistanceComparator(); |
6a3b686b-a13c-4b69-9adb-f1b81c9716e4 | public static void main(String[] args) {
ArrayList<Item> a = new ArrayList<>();
// a.add(new Item("bob", "2012-04-17", 22.5));
// a.add(new Item("albert", "2010-08-13", 16.1));
// a.add(new Item("zack", "2009-10-05", 18.3));
// a.add(new Item("john", "2011-02-21", 4.4));
// a.add(new Item("harry", "2013-01-02", 60.0));
Processing p = new Processing();
Collections.sort(a, p.getTransactionDateComparator());
Collections.sort(a, p.getTransactionValueComparator());
for(int i = a.size(); --i >= 0;) {
System.out.print(a.get(i).getTransactionValue() +"\t");
System.out.println(a.get(i).getDate());
}
} |
165468e4-6aa1-4e4f-9777-a0ab3c4e7f91 | @Override
public Comparator<Item> getTransactionValueComparator() {
valueComp = new Comparator<Item>() {
@Override
public int compare(Item o1, Item o2) {
double delta = o1.getTransactionValue() - o2.getTransactionValue();
if(delta < 0) return -1;
if(delta > 0) return 1;
return 0;
}
};
return valueComp;
} |
2460bfba-74fa-43c7-b946-b1fc7a4a452d | @Override
public int compare(Item o1, Item o2) {
double delta = o1.getTransactionValue() - o2.getTransactionValue();
if(delta < 0) return -1;
if(delta > 0) return 1;
return 0;
} |
801a810e-04c0-4af9-9c2c-dbc330d3f952 | @Override
public Comparator<Item> getTransactionDateComparator() {
dateComp = new Comparator<Item>() {
@Override
public int compare(Item o1, Item o2) {
return o1.getDate().compareTo(o2.getDate());
}
};
return dateComp;
} |
14a3f57e-c293-462e-9a9a-12c0383357ec | @Override
public int compare(Item o1, Item o2) {
return o1.getDate().compareTo(o2.getDate());
} |
0b5482ad-8e08-4221-86d4-752d7ae62f86 | @Override
public double percentileValue(List<Item> items, int percentile) {
if(percentile < 0 || percentile > 100) {
System.err.println("Invalid input, valid percentile range: 0-100");
System.exit(1);
}
// special case
if(percentile == 100)
return items.get(items.size()-1).getTransactionValue();
double n = ((percentile*items.size())/100) + 0.5;
return items.get((int) n).getTransactionValue();
} |
4d269d6b-3e58-49d2-8107-bdc9088ad5db | @Override
public boolean isOutlier(Item item, double thresholdLow,
double thresholdHigh) {
double value = item.getTransactionValue();
//if(value >= thresholdHigh || value <= thresholdLow)
// if(thresholdLow >= value || value >= thresholdHigh)
// return true;
return thresholdLow >= value || value >= thresholdHigh;
} |
6b8794e8-e1ef-490d-9910-6f6aa6e4ffbb | @Override
public double thresholdDistance(Item item, double thresholdLow,
double thresholdHigh) {
// method calls are more expensive than variable assignments?
double value = item.getTransactionValue();
double d1 = Math.abs(thresholdHigh - value);
double d2 = Math.abs(thresholdLow - value);
return d1 < d2 ? d1 : d2;
} |
5b745cf7-df58-42a6-98d7-40e483ba7558 | @Override
public Comparator<Item> getThresholdDistanceComparator() {
thresholdComp = new Comparator<Item>() {
@Override
public int compare(Item o1, Item o2) {
double delta = thresholdDistance(o1, thresholdLow, thresholdHigh)
- thresholdDistance(o2, thresholdLow, thresholdHigh);
if(delta < 0) return -1;
if(delta > 0) return 1;
return 0;
}
};
return thresholdComp;
} |
337f22fd-2190-45b5-83f7-e4a66e2f36bb | @Override
public int compare(Item o1, Item o2) {
double delta = thresholdDistance(o1, thresholdLow, thresholdHigh)
- thresholdDistance(o2, thresholdLow, thresholdHigh);
if(delta < 0) return -1;
if(delta > 0) return 1;
return 0;
} |
09af86d1-8452-4aab-b490-147933806fcb | public String getPerformer(); |
79ea3b0a-ec29-4408-b056-82b3321d2df7 | public double getTransactionValue(); |
4198a017-bb63-452b-99b7-7aae7d01d230 | public String getDate(); |
a276453f-c129-4897-93de-0ae1ddb886bc | public void setPerformer(String name); |
3ed2f15b-328c-45dc-a8a8-2ec9c90cb7f3 | public void setTransactionValue(double value); |
216a466a-338d-49a3-996f-a315344307a0 | public void setDate(String date); |
f2c8fe7b-29de-411b-917e-7bec1e2e7287 | public List<Item> readCSVFile(String filename); |
1a9d48c1-3a7d-4a5a-9278-9c879160f8fa | public double lowThresholdValue(List<Item> items,
Processing processing, int lowPercentile); |
e861971f-c684-4175-962c-8f1ba2c62c2b | public double highThresholdValue(List<Item> items,
Processing processing, int highPercentile); |
42531dfa-51f8-4203-9cfc-0fa02fd0eb24 | public void printTransactionsList(List<Item> items,
Processing processing, double lowThreshold, double highThreshold); |
64f63558-e950-4f17-ae2c-67ebf9c3af97 | public void printItemsOfInterest(final List<Item> items, int m,
Processing processing, double lowThreshold, double highThreshold); |
b31e7972-b7a8-4bc5-91da-bbcbc66b14d5 | @Override
public List<Item> readCSVFile(String filename) {
try {
BufferedReader br =
new BufferedReader(new FileReader(filename));
String line = br.readLine();
while(line != null && line.length() != 0) {
String[] itemArray = line.split(",");
items.add(new Item(
itemArray[0],
Double.valueOf(itemArray[1]),
itemArray[2]));
line = br.readLine();
}
br.close();
} catch (Exception e2) {
e2.printStackTrace();
}
Collections.sort(items, p.getTransactionValueComparator());
return items;
} |
7784cef7-2fe1-4acc-ace1-62b8e6ceae1c | @Override
public double lowThresholdValue(List<Item> items, Processing processing,
int lowPercentile) {
return processing.percentileValue(items, lowPercentile);
} |
210f985b-dcdf-46cb-bf5f-1bcf8594105b | @Override
public double highThresholdValue(List<Item> items, Processing processing,
int highPercentile) {
return processing.percentileValue(items, highPercentile);
} |
49fde2a4-559b-436b-8508-edcd3aa9d7bc | @Override
public void printTransactionsList(List<Item> items,
Processing processing, double lowThreshold, double highThreshold) {
Collections.sort(items, processing.getTransactionDateComparator());
System.out.println("TRANSACTIONS:");
for(int i = 0; i < items.size(); i++) {
if(processing.isOutlier(items.get(i), lowThreshold, highThreshold))
System.out.println(items.get(i).toString() + "\t ( ¯\\_(ツ)_/¯ )");
else
System.out.println(items.get(i).toString());
}
} |
75e7b260-638c-461b-9eba-7c731b5cc0c9 | @Override
public void printItemsOfInterest(List<Item> items, int m,
Processing processing, double lowThreshold, double highThreshold) {
PriorityQueue<Item> pq = new PriorityQueue<>(items.size(),
processing.getThresholdDistanceComparator());
// find all non-outlier items
System.out.println("\nITEMS OF INTEREST:");
for(int i = 0; i < items.size(); i++) {
if(!processing.isOutlier(items.get(i), lowThreshold, highThreshold))
pq.add(items.get(i));
}
m = (pq.size() < m) ? pq.size() : m;
for(int i = 0; i < m; i++) {
System.out.println(pq.remove().toString());
}
} |
e8c1613b-5460-4270-bf67-6a423bc67a3a | private void printHelp() {
System.out.println("Usage: main [OPTION]"
+ "\n-f --file \t\tSet file to load *CSV* (STRING)"
+ "\n-pL --percentileLow \t\tSet low value for percentile"
+ "\n-pH --percentileHigh \t\tSet high value for percentile"
+ "\n-h --help \t\tThis help page");
System.exit(1);
} |
bf6fd89f-a585-47c4-b1ba-6d99f1825b4d | private void parseArgs(String[] args) {
Scanner sc = new Scanner(System.in);
if(args.length < 4) {
System.out.print("Path to file: ");
file = sc.nextLine();
System.out.print("Percentiles: ");
int d1 = sc.nextInt();
int d2 = sc.nextInt();
if(d1 > d2) {
hPercentile = d1; lPercentile = d2;
} else {
hPercentile = d2; lPercentile = d1;
}
System.out.print("Number of items of interest: ");
ioi = sc.nextInt();
}
else {
file = args[0];
if(Integer.valueOf(args[1]) > Integer.valueOf(args[2])) {
hPercentile = Integer.valueOf(args[1]);
lPercentile = Integer.valueOf(args[2]);
} else {
hPercentile = Integer.valueOf(args[2]);
lPercentile = Integer.valueOf(args[1]);
}
ioi = Integer.valueOf(args[3]);
}
} |
62a1afd6-6c81-444d-9751-2ce8aa1c9a1e | Main(String[] args) {
parseArgs(args);
//file = "/home/mathias/1.csv";
long start = System.currentTimeMillis();
readCSVFile(file);
low = lowThresholdValue(items, p, lPercentile);
high = highThresholdValue(items, p, hPercentile);
p.thresholdLow = low;
p.thresholdHigh = high;
//long start = System.currentTimeMillis();
printTransactionsList(items, p, low, high);
printItemsOfInterest(items, ioi, p, low, high);
System.out.println("\n" + (System.currentTimeMillis() - start) + "ms");
} |
b07c573f-d213-4e62-838c-8a714091cbb3 | public static void main(String[] args) { Main m = new Main(args); } |
3d9169cb-8de9-4962-912f-c7f138f04593 | @Override
public void addNode(int nodeItem) {
vertices.add(new Vertex(nodeItem));
} |
f43b6da8-d98d-4479-a284-b762814fb7f0 | public Vertex findNode(int nodeItem) {
Vertex s = null;
for(Vertex v : vertices) {
if(v.nodeItem == nodeItem)
s = v;
}
return s;
} |
de590181-61a0-4801-b70a-dcdb7f5826a0 | public void findNodes(int srcNodeItem, int tgtNodeItem) {
src = tgt = null;
for(Vertex v : vertices) {
if(src != null && tgt != null)
break;
else if(v.nodeItem == srcNodeItem)
src = v;
else if(v.nodeItem == tgtNodeItem)
tgt = v;
}
} |
5ccbb3e0-5c12-4672-a187-fc9411559653 | public void clear(ArrayList<Vertex> g) {
for(Vertex v : g)
v.visited = false;
cnt = 0;
} |
3358fcca-cd72-48ad-ad07-4d15bb2ba85d | @Override
public void addEdge(int srcNodeItem, int tgtNodeItem) {
if(srcNodeItem == tgtNodeItem) {
Vertex s = findNode(srcNodeItem);
s.edges.add(s);
selfloop = true;
}
else {
findNodes(srcNodeItem, tgtNodeItem);
if(tgt == null)
tgt = new Vertex(tgtNodeItem);
src.outdegree++;
tgt.indegree++;
src.edges.add(tgt);
}
} |
fac8cf73-2c9f-454e-957d-e10ecef4ec25 | @Override
public boolean hasNode(int nodeItem) {
for(Vertex v : vertices) {
if(v.nodeItem == nodeItem)
return true;
}
return false;
} |
01b8c20a-903f-47bf-bc13-e13b20407b5c | @Override
public boolean hasEdge(int srcNodeItem, int tgtNodeItem) {
findNodes(srcNodeItem, tgtNodeItem);
return src.edges.contains(tgt);
} |
f751223b-aaca-4af8-bedb-692db9d005d4 | @Override
public void printAllNodes() {
for(Vertex v : vertices)
System.out.println(v.nodeItem);
} |
deda8cf6-70bd-4d80-b2fb-d2ce6f0685b5 | @Override
public void printAllEdges() {
for(Vertex v : vertices) {
System.out.print(v.nodeItem + ": ");
for(Vertex e : v.edges)
System.out.print(e.nodeItem + " ");
System.out.println();
}
} |
a6fd007a-75a4-4c9d-90f5-1fbf24c38a22 | @Override
public List<Integer> visitDFS(int startNodeItem) {
dfs(findNode(startNodeItem));
return dfsList;
} |
f6b09913-cb58-4a51-8bfe-30622d89d122 | public void dfs(Vertex s) {
s.visited = true;
dfsList.add(s.nodeItem);
for(Vertex v : s.edges) {
if(!v.visited)
dfs(v);
else
cycle = true;
}
} |
cd44afb4-a1ad-4ba7-bb24-2fa3f848bfba | @Override
public List<Integer> visitBFS(int startNodeItem) {
clear(vertices);
Vertex u;
Queue<Vertex> q = new LinkedList<Vertex>();
Vertex s = findNode(startNodeItem);
bfsList.add(s.nodeItem);
s.visited = true;
q.add(s);
while(!q.isEmpty()) {
u = q.remove();
for(Vertex v : u.edges) {
if(!v.visited) {
bfsList.add(v.nodeItem);
v.visited = true;
q.add(v);
}
}
}
return bfsList;
} |
4d430680-e9a5-4b94-976d-3ee0968f1837 | @Override
public boolean hasSelfLoops() {
return selfloop;
} |
7dc00e15-2889-46a0-902e-33a3f8996330 | public void connectivity(Vertex s) {
s.visited = true;
cnt++;
System.out.println("Node: " + s.nodeItem + " cnt: " + cnt);
for(Vertex v : s.edges) {
if(!v.visited)
connectivity(v);
}
} |
0c309de8-db77-4570-ab00-7bf610ef1970 | @Override
public boolean isConnected() {
clear(vertices);
connectivity(vertices.get(0));
return cnt == vertices.size();
} |
16396971-15fa-4c26-b584-d35ae61772f3 | @Override
public boolean hasTwoCycles() {
for(Vertex a : vertices) {
for(Vertex b : a.edges) {
if(b.edges.contains(a))
return true;
}
}
return false;
} |
25963cbd-e54c-4285-8b53-5b0c2578f6da | @Override
public boolean hasCycles() {
cycle = false;
clear(vertices);
for(Vertex v : vertices) {
dfs(v);
}
return cycle;
} |
a7597315-6b9f-4169-939a-055c0e30f6d0 | private Vertex getSink(ArrayList<Vertex> g) {
Vertex sink;
for(Vertex v : g) {
if(v.outdegree == 0) {
sink = v;
g.remove(v);
return sink;
}
}
return null;
} |
6d1fc0ea-7011-41a8-bf9f-f4d9f9581d34 | private Vertex getSource(ArrayList<Vertex> g) {
Vertex source;
for(Vertex v : g) {
if(v.indegree == 0) {
source = v;
g.remove(v);
return source;
}
}
return null;
} |
b4f473f2-4a2b-4b51-85c5-c9b22f4e894c | private Vertex magic(ArrayList<Vertex> g) {
Vertex magic = new Vertex();
for(Vertex v : g) {
if((v.outdegree - v.indegree) > (magic.outdegree - magic.indegree))
magic = v;
}
return magic;
} |
1235eb10-2723-498b-842a-92285d5caee1 | @Override
public Map<Integer, List<Integer>> feedbackEdges() {
if(hasSelfLoops() || hasTwoCycles() || !isConnected())
return null;
ArrayList<Vertex> g = vertices;
List<Vertex> s = new ArrayList<Vertex>();
List<Vertex> t = new ArrayList<Vertex>();
List<Vertex> list = new ArrayList<Vertex>();
Vertex source, sink;
while(!g.isEmpty()) {
while((sink = getSink(g)) != null)
t.add(0, sink); // prepend
while((source = getSource(g)) != null)
s.add(source); // append
if(!g.isEmpty())
s.add(magic(g));
}
list.addAll(s);
list.addAll(t);
HashMap<Integer, List<Integer>> map = new HashMap<>();
Vertex current, previous;
for(int i = 0; i < list.size(); i++) {
current = list.get(i);
ArrayList<Integer> intList = new ArrayList<Integer>();
for(int k = 0; k < i; k++) {
previous = list.get(k);
if(current.edges.contains(previous))
intList.add(previous.nodeItem);
}
if(!intList.isEmpty())
map.put(current.nodeItem, intList);
}
return map;
} |
beadc43a-a8a3-4b7b-8665-ca5eacc3768d | public Vertex(int nodeItem) {
this(nodeItem, 0, 0);
} |
5b1d7018-df90-4ff6-b009-a52db971a91a | public Vertex() {
this(0, 0, 0);
} |
fac5fe5a-abcb-42cd-9194-51bd36681a23 | public Vertex(int nodeItem, int indegree, int outdegree) {
this.nodeItem = nodeItem;
this.indegree = indegree;
this.outdegree = outdegree;
edges = new ArrayList<Vertex>();
visited = selfLoop = false;
} |
6ac318e1-4943-451d-86ea-0097a10b754d | public void addNode(int nodeItem); |
1beb8d33-4414-4c36-ae5d-a589da480537 | public void addEdge(int srcNodeItem, int tgtNodeItem); |
82fda398-82e1-4e03-8388-966e768fceaf | public boolean hasNode(int nodeItem); |
d781ae5e-922a-46ba-874f-3f6af1368d9d | public boolean hasEdge(int srcNodeItem, int tgtNodeItem); |
a09621d5-9646-42cb-aa3b-29e304c01bfe | public void printAllNodes(); |
64ac2c93-8ece-497c-9640-d80c1dcad1dc | public void printAllEdges(); |
727f5d39-8dee-4d25-aef6-6e61bcf05769 | public List<Integer> visitDFS(int startNodeItem); |
5ff18790-a40a-4628-87ad-c96875b4b658 | public List<Integer> visitBFS(int startNodeItem); |
6d9c0768-a9fa-416b-ab5c-33897d7b71a8 | public boolean hasSelfLoops(); |
cccd38fb-b6ab-47bb-8ee9-74471374f1d9 | public boolean isConnected(); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.