public ParseMessage(String msg) {
FMValue = msg.substring(3, 5); // first one is starting index,last one is end+1
ToValue = msg.substring(9, 11); //
NPVal = Character.getNumericValue(msg.charAt(15));
HCVal = Character.getNumericValue(msg.charAt(20));
msgNumber = Integer.parseInt(msg.substring(25, 28));
int i = msg.indexOf("DATA");
int j = msg.indexOf("VL");
if (i != (j + 4)) {
VLNode = msg.substring(j + 3, i);
} else VLNode = "";
DATA_Val = msg.substring(i + 5);
if (NPVal == 2) {
int k = msg.indexOf("registered as");
RegisteredName = "" + msg.charAt(k + 14) + msg.charAt(k + 15);
}
if (NPVal == 6) {
String str = new String(DATA_Val);
arr = new CopyOnWriteArrayList<>();
int m = 0;
do {
int k = str.indexOf(",");
arr.add(new Node(str.substring(m, k)));
str = str.substring(k + 1);
} while (str.indexOf(",") != -1);
arr.add(new Node(str));
}
}
/** function to evaluate tree */
public double evaluate(Node ptr) {
if (ptr.leftChild == null && ptr.rightChild == null) return Character.getNumericValue(ptr.data);
else {
double result = 0.0;
double left = evaluate(ptr.leftChild);
double right = evaluate(ptr.rightChild);
char operator = ptr.data;
switch (operator) {
case '+':
result = left + right;
break;
case '-':
result = left - right;
break;
case '*':
result = left * right;
break;
case '/':
result = left / right;
break;
default:
result = left + right;
break;
}
return result;
}
}
public static void main(String args[]) throws Exception {
try {
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
String n = (input.readLine());
int number[] = new int[n.length()];
for (int i = 0; i < n.length(); i++) {
number[i] = Character.getNumericValue(n.charAt(i));
}
System.out.println(Arrays.toString(plus(number)));
} catch (Exception e) {
}
}
/**
* sets an appropiate response MTI.
*
* <p>i.e. 0100 becomes 0110<br>
* i.e. 0201 becomes 0210<br>
* i.e. 1201 becomes 1210<br>
*
* @exception ISOException on MTI not set or it is not a request
*/
public void setResponseMTI() throws ISOException {
if (!isRequest()) throw new ISOException("not a request - can't set response MTI");
String mti = getMTI();
char c1 = mti.charAt(3);
char c2 = '0';
switch (c1) {
case '0':
case '1':
c2 = '0';
break;
case '2':
case '3':
c2 = '2';
break;
case '4':
case '5':
c2 = '4';
break;
}
set(
new ISOField(
0, mti.substring(0, 2) + (Character.getNumericValue(getMTI().charAt(2)) + 1) + c2));
}
/**
* @return true if message "seems to be" a request
* @exception ISOException on MTI not set
*/
public boolean isRequest() throws ISOException {
return Character.getNumericValue(getMTI().charAt(2)) % 2 == 0;
}
public static void main(String[] args) throws IOException {
Scanner in = new Scanner(System.in);
File file = new File("/users/Sriram/Desktop/2014-15/Neural Nets/weightsDiffAct.txt");
if (!file.exists()) file.createNewFile();
Scanner scan = new Scanner(file);
Scanner scanIn =
new Scanner(new File("/users/Sriram/Desktop/2014-15/Neural Nets/StarterInput.txt"));
System.out.println("Type train or run");
String t = in.next();
double[][] iWeights1 = new double[Hidden][Input];
double[][] hWeights1 = new double[Output][Hidden];
if (t.equals("train")) {
BufferedWriter bout = new BufferedWriter(new FileWriter(file));
ReverseNetDiffAct autobot = new ReverseNetDiffAct(iWeights1, hWeights1);
autobot.initializeWeights();
// taking in the inputs
cases = 4;
double[][] ktrainingInputs1 = new double[cases][Input];
// scans files and takes in the inputs, scans line and then by character.
for (int n = 0; n < cases; n++) {
for (int k = 0; k < Math.sqrt(Input); k++) {
String line = scanIn.nextLine();
for (int b = 0; b < Math.sqrt(Input); b++) {
ktrainingInputs1[n][k * (int) (Math.sqrt(Input)) + b] =
Character.getNumericValue(line.charAt(b));
//
// System.out.println(ktrainingInputs1[n][k*9+b]);
}
}
}
autobot.setInput(ktrainingInputs1);
autobot.initOut(cases);
autobot.initHid(cases);
autobot.setOut();
// setting ideal output and initializing real output
// itargetOutput[0][k]
autobot.changeWeights();
iWeights1 = autobot.getIWeights();
hWeights1 = autobot.getHWeights();
for (int j = 0; j < Hidden; j++) {
for (int k = 0; k < Input; k++) {
bout.write(iWeights1[j][k] + "\n");
}
}
for (int i = 0; i < Output; i++) {
for (int j = 0; j < Hidden; j++) {
bout.write(hWeights1[i][j] + "\n");
}
}
bout.close();
System.out.println("Done");
} else if (t.equals("run")) {
// getting the weights from the optimized weights file
for (int j = 0; j < Hidden; j++) {
for (int k = 0; k < Input; k++) {
iWeights1[j][k] = scan.nextDouble();
}
}
for (int i = 0; i < Output; i++) {
for (int j = 0; j < Hidden; j++) {
hWeights1[i][j] = scan.nextDouble();
}
}
// getting in all the inputs that will be propogated to check output
cases = 4;
ReverseNetDiffAct autobot = new ReverseNetDiffAct(iWeights1, hWeights1);
// need to set cases first, because of constructor
double[][] ktrainingInputs1 = new double[cases][Input];
autobot.initOut(cases);
autobot.initHid(cases);
for (int n = 0; n < cases; n++) {
for (int k = 0; k < Math.sqrt(Input); k++) {
String line = scanIn.nextLine();
for (int b = 0; b < Math.sqrt(Input); b++) {
ktrainingInputs1[n][k * (int) (Math.sqrt(Input)) + b] =
Character.getNumericValue(line.charAt(b));
// System.out.println(ktrainingInputs1[n][k*9+b]);
}
}
}
autobot.setInput(ktrainingInputs1);
// setting ideal output
autobot.propagateNet(cases); // with 5 cases
double[][] irealOutput1 = autobot.getOutput();
for (int n = 0; n < cases; n++) {
for (int i = 0; i < Output; i++) {
System.out.println("Case " + n + " Output " + i + ": " + irealOutput1[n][i]);
}
}
System.out.println("Done");
}
}
// given the file type argument, this method reads the file into a vector
public static int readFileIntoInputVector(String inputRepresentation) {
int target = 0; // target integer
String digitAsString = "";
try {
if (inputRepresentation.equalsIgnoreCase("bmp")) {
String currentLine = "CurrentLine";
if (firstRead) {
fileReader.readLine(); // skip first few lines, as they are not relevant
fileReader.readLine();
currentLine = fileReader.readLine();
firstRead = false; // only skip lines on initial entry into the file
}
if (currentLine == null) return -2; // ensures the file is being read
for (int i = 0; i < 32; i++) { // for each 32 rows
currentLine = fileReader.readLine();
if (currentLine == null) return -2;
currentLine = currentLine.trim(); // removes whitespace
char[] inputSplitter =
currentLine.toCharArray(); // separates each digit into its own array element
for (int j = 0; j < inputSplitter.length; j++) {
inputs.addElement(
new Double(Character.getNumericValue(inputSplitter[j]))); // add the line to inputs
}
}
currentLine = fileReader.readLine();
target = Character.getNumericValue(currentLine.charAt(1)); // get solution into target
} else if (inputRepresentation.equalsIgnoreCase("ndsi")) {
String currentLine = fileReader.readLine();
if (currentLine == null) return -2; // ensures file is being read
currentLine =
currentLine.substring(
2, currentLine.length() - 2); // leaves out parentheses and whitespace
String[] inputSplitter =
currentLine.split(
" "); // fills array with actual values from line (they are delimited by whitespace
// initially)
for (int i = 0; i < inputSplitter.length; i++) {
inputs.addElement(
new Double(Double.parseDouble(inputSplitter[i]))); // add the line to inputs
}
currentLine = fileReader.readLine();
currentLine =
currentLine.substring(
2, currentLine.length() - 2); // leaves out parentheses and whitespace
String[] outputSplitter =
currentLine.split(
" "); //// fills array with actual values from line (they are delimited by
// whitespace initially)
for (int i = 0; i < outputSplitter.length; i++) {
if (outputSplitter[i].equals("1.0"))
target = i; // sets target to solution value for this problem
}
} else if (inputRepresentation.equalsIgnoreCase("dsi")) {
String currentLine = fileReader.readLine();
if (currentLine == null) return -2; // ensures file is being read
String[] inputSplitter =
currentLine.split(
","); // file has values delimited by commas, so fill array with actual values
for (int i = 0; i < inputSplitter.length - 1; i++) {
inputs.addElement(
new Double(
Double.parseDouble(inputSplitter[i])
/ 16)); // effectively converts the file into an ndsi
}
target = Integer.parseInt(inputSplitter[inputSplitter.length - 1]);
}
} catch (IOException e) {
e.printStackTrace();
}
return target;
}
public static void main(String args[]) {
int PC, SP, IR, AC, X, Y;
int[] memory = new int[1000];
SP = IR = AC = X = Y = 0;
PC = -1;
// Gets "MainMemory" class from working directory.
String directory = System.getProperty("user.dir") + "\\bin\\ MainMemory";
Scanner in = new Scanner(System.in);
try {
int x, y, index = 0;
String z = "";
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("java -cp " + directory);
// Process proc = rt.exec("cat Hello.java");
InputStream os = proc.getInputStream();
IR = 0;
// GRABS INSTRUCTION OUT OF STREAM
while ((x = os.read()) != -1) {
try {
if (x > 47 && x < 58) {
y = Character.getNumericValue(x);
z += y;
} else if (x == 10 && z != "") {
x = Integer.parseInt(z);
y = 0;
z = "";
// System.out.println(x);
memory[index] = x;
index++;
} else if (x == 13) {
break;
}
} catch (Exception e) {
System.out.println("ERROR: Error while reading instructions.");
System.exit(1);
}
}
// PERFORMS INSTRUCTIONS
for (int k = 0; k < index; k++) {
// System.out.println(k + " == " + memory[k]);
IR = memory[k];
switch (IR) {
case 1:
// System.out.println("LOAD VALUE"); //READS IN THE VALUE
PC++;
k++;
AC = memory[k];
PC++;
break;
case 2:
// System.out.println("LOAD ADDR"); //READS VALUE FROM AN ADDRESS
PC++;
AC = memory[memory[k + 1]];
k++;
break;
case 3:
// System.out.println("STORE ADDR"); //WRITES THE VALUE OF AC TO THE ADDRESS
PC++;
memory[memory[k + 1]] = AC;
k++;
try {
File file = new File(System.getProperty("user.dir") + "\\src\\program.txt");
FileWriter fw = new FileWriter(file);
BufferedWriter out = new BufferedWriter(fw);
for (int i = 0; i < index; i++) {
out.write("" + memory[i]);
out.newLine();
}
out.flush();
out.close();
} catch (IOException e) {
System.out.println("ERROR: Could not rewrite program");
}
break;
case 4:
// System.out.println("ADD X"); //ADDS X TO AC
PC++;
AC += X;
break;
case 5:
// System.out.println("ADD Y"); //ADDS Y TO AC
PC++;
AC += Y;
break;
case 6:
// System.out.println("SUB X"); //SUBSTRACTS X FROM AC
PC++;
AC -= X;
break;
case 7:
// System.out.println("SUB Y"); //SUBTRACTS Y FROM AC
PC++;
AC -= Y;
break;
case 8:
// System.out.println("GET PORT"); //RECEIVES EITHER INTEGER OR CHARACTER DEPENDING ON
// PORT NUMBER, 1 OR 2
PC++;
k++;
if (memory[k] == 1) {
PC++;
// System.out.println("PORT = READ INT"); //RECEIVES INTEGER FROM USER AND PLACES IT
// INTO AC
AC = in.nextInt();
} else if (memory[k] == 2) // RECEIVES CHARACTER FROM USER AND PLACES IT INTO AC
{
PC++;
// System.out.println("PORT = READ CHAR");
AC = (int) in.next(".{1}").charAt(0);
}
break;
case 9:
// System.out.println("PUT PORT"); //PRINTS EITHER INTEGER OR CHARACTER DEPENDING ON
// PORT NUMBER, 1 OR 2
PC++;
k++;
if (memory[k] == 1) {
// System.out.println("PORT = WRITE INT"); PRINTS OUT INTEGER VALUE FROM AC
PC++;
System.out.print(AC);
} else if (memory[k] == 2) {
// System.out.println("PORT = WRITE CHAR"); //PRINTS OUT CHARACTER VALUE FROM AC
PC++;
System.out.print((char) AC);
}
break;
case 10:
// System.out.println("COPYTO X"); //COPIES VALUE FROM X INTO AC
PC++;
X = AC;
break;
case 11:
// System.out.println("COPYTO Y"); //COPIES VALUE FROM Y INTO AC
PC++;
Y = AC;
break;
case 12:
// System.out.println("COPYFROM X"); //COPIES VALUE FROM X INTO AC
PC++;
AC = X;
break;
case 13:
// System.out.println("COPYFROM Y"); //COPIES VALUE FROM Y INTO AC
PC++;
AC = Y;
break;
case 14:
// System.out.println("JUMP ADDR"); //JUMPS TO AN ADDRESS
PC++;
k = memory[k + 1] - 1;
break;
case 15:
// System.out.println("JUMPIFEQUAL ADDR"); //JUMPS TO AN ADDRESS IF AC IS EQUAL TO ZERO
PC++;
if (AC == 0) {
PC++;
k = memory[k + 1] - 1;
} else {
PC++;
k++;
}
break;
case 16:
// System.out.println("JUMPIFNOTEQUAL ADDR"); //JUMPS TO AN ADDRESS IF AC IS NOT EQUAL
// TO ZERO
PC++;
if (AC != 0) {
PC++;
k = memory[k + 1] - 1;
} else {
PC++;
k++;
}
break;
case 17:
// System.out.println("CALL ADDR"); // PUSH RETURN ADDRESS INTO STACK, AND JUMPS AN
// ADDRESS
PC++;
SP = PC;
k = memory[k + 1] - 1;
PC++;
break;
case 18:
// System.out.println("RETURN"); //POPS RETURN ADDRESS FROM STACK, AND JUMPS TO IT
PC++;
k = SP + 1;
break;
case 19:
// System.out.println("INC X"); //INCREMENTS VALUE IN X BY ONE
PC++;
X++;
break;
case 20:
// System.out.println("DEC X"); //DECREMENTS VALUE IN X BY ONE
PC++;
X--;
break;
case 30:
// System.out.println("END"); //ENDS PROCESS
PC++;
X = 0;
Y = 0;
AC = 0;
k = index;
try {
os.close();
} catch (Exception e) {
}
break;
}
// System.out.println("\nProgram Counter: " + PC);
}
// PROCESS ENDS
proc.waitFor();
in.close();
int exitVal = proc.exitValue();
System.out.println("\nProcess exited: " + exitVal);
} catch (Throwable t) {
t.printStackTrace();
}
System.exit(1);
}
