Vector Geometry, Linear Algebra, and Java Script

Click on the title to return to the table of contents.

[linearprogramming]

While-Loops, Loops and Input, Do-While-Loops, For-Loops, Loops and Char

While-Loops Some code needs to be execute a certain amount of times, possibly one hundred times. Instead of copying and pasting the code block many times, while-loops allow the programmer to just type the code block once, as long as certain conditions are met. It is structured like an if statement.

while(boolean) { code block that loops if boolean is true }

As long as the boolean expression inside the while() is still true, the loop will repeat the code block inside it forever. However, this is called infinite looping, which is generally undesirable. Instead, while-loops need to have an exit condition and a statement inside the while-loop that will help the code progress to this exit condition.

boolean number = true; int result = 0; while(number) { System.out.println(result++); }

In this while-loop, the boolean variable number is already set to true, so the while-loop will run. Inside this while-loop is the method println that prints out the integer variable result which is being postfix-incremented each loop. This is basically counting up by 1 from 0. However, when this program runs, since there is no exit condition in the while(), this while-loop counts to infinity, making it an infinite loop. That is only good if the program desires it.

int number = 0; while(number <= 10) { System.out.println(number++); }

Instead, if we wanted the result to only count up to 10, the exit condition must be changed into a range, where the while-loop exits the code after the exit condition is met. To count up to 10 and have the while-loop exit, the range, or exit condition, should be number ≤ 10. That means the while-loop will run as long as number ≤ 10 is true. It will become false when result is higher than 10. When it is false, the while-loop stops. Another problem with while-loops is that sometimes they do not execute at all. This is not their fault either; the exit condition just doesn't satisfy the variable range, etc.

int i = 0; while(i > 0) { ... }

Here the code inside the while-loop will not execute, because the exit condition will never be true; i is only equal to 0, while the exit condition considers values of i greater than 0. With while-loops, after the last line in the code block executes, the program automatically goes up to the while() and checks if the exit condition remains true. If it is true, the code block will execute again. If it is false, the while-loop will stop, and the program will skip the while-loop onto the next code. This means that you cannot make the while-loop stop or restart in the middle of its code block. The entire code block runs before it is determined whether or not the loop should run again. Loops and Input While-loops can allow input from the user multiple times, such as guessing a certain number. The input scanner will appear as many times as the user guesses wrong until the exit condition is met: where the user enters the correct number. However, in order to use while-loops and user input, the exit condition must be true before the while-loop can begin. So if we wanted a user to guess a number, we would have to have the exit condition already true before the loop begins. This is not efficient, because then the variable that is assigned to the user's input has to be initialized outside of the while-loop. (to either 0 or -1). This is one of the limitations for while-loops. Do-While-Loops A solution to the above problem is to use do-while-loops, where there is one "do" code that executes automatically, no matter the condition, and then goes through the while-loop process afterwards. An example would be

Scanner kb = new Scanner(System.in); int sum = 0; int userNumber; do { userNumber = kb.nextInt(); sum = sum + userNumber; } while(userNumber != 0);

The code block in do executes automatically just once with no conditions needed. For this, the input from the user is saved into the integer variable userNumber and then added to the integer variable sum, which is equal to 0. After this code executes once, it goes through the while-loop process, only executing now if the exit condition remains true. In this case, the exit condition is when the userNumber's value doesn't equal 0, the code inside do will run. This means that the code will stop once the user inputs the number 0. Note that the while() has a semi-colon. Do-while-loops is the only construct that uses a semi-colon at the end of the while() statement. Any other conditional construct will cause in an error. For-Loop For-loop is considered a better loop when a program needs to count up or down numbers or specific objects.

int i; for(i = 0; i <= 100; i++) { System.out.println(i); }

"i = 0" is called the initialization condition, where whatever its value is the value the for-loop begins at. In this case, the for-loop begins at the value 0. "i <= 100" is called the continue condition, where the for-loop will continue looping as long as this boolean is true. In this case, the for-loop stops once i ≤ 100. "i++" is called the increment, whether it is counting up or down, by multiples, or if it's postfix-increment/prefix-increment, this is where it is placed. In this case, the integer variable i is incremented by 1 each loop. If we looked at the for-loop code again, it is saying that the integer variable i starts at 0, and each loop prints out i++, adding 1 to i each loop, eventually reaching the continue condition, which is i ≤ 100. Therefore, the loop stops once i ≤ 100. Note that the value is incremented before the loop checks if the loop should continue. That means, i will equal 101 in the end, but this will not show, because the for-looped stopped before it could print this out. If the code was this instead:

int i; for(i = 0; i ≤ 100; i++) { System.out.println(i); } System.out.println(i);

The output would count to 100 from 0, then exit out of the for-loop. After, the println method will run showing that i is now 101, something the for-loop was forbidden to show due to continue conditions. When it comes to the initialization condition, the variable can be assigned on this statement. That means this

int i; for(i = 0; i ≤ 100; i++)

can be written as this

for(int i = 0; i ≤ 100; i++)

However, declaring variables on top of methods is good programming. When to Use Which Loops Out of the three loops, here is a logarithm to use when you need to decide which loop is best to use for the situation. Always use for-loops if you know exactly how many loops, or iterations, you need to run. So basically whenever you are counting from a specific value to another specific value, or working with a specific number of items. Otherwise, use the do-while-loop or while-loop. If your code needs to run at least once, then use the do-while-loop. Loops and Char A way of using loops is to make characters in strings appear in certain rows or columns. If we had a string String word = "cute"; We can make a for-loop that makes this string have one character in each row, a total of four rows.

int i; char ch; for(i = 0; i < word.length(); i++) { ch = word.charAt(i); System.out.println("\"" + ch + "\""); }

If i is an integer, it can correspond to the positions of the characters in the string cute, which is 0, 1, 2, and 3. In the initialization condition, i starts at 0, so the for-loop begins at charAt(i=0), which is c. In the continue condition, the for-loop will run until i is less than the string variable word's length, which is in total 4 changes to the charAt(i). In the increment, i is incrementing by 1, so the first for-loop does charAt(i=0), then the second is charAt(i=0+1), which is u, then the third is charAt(i=0+1+1), which is t, and finally the fourth is charAt(i=0+1+1+1), which is e. The println method prints these changes of charAt, because charAt is a character variable ch.

[linearprogramming]

JOptionPane, Floating-Point Values, Advanced Scanner Input, Global Constants, String Methods

JOptionPane There is a special library that imports a different type of input/output capability. It is called the JOptionPane. The following import should be on top of the program before using JOptionPane: import javax.swing.*; The asterisk, *, just means that whatever is in javax.swing is to be imported. To show a JOptionPane, the following statement can be placed in any method. JOptionPane.showMessageDialog(null, "Hello!"); Ignore the null for now, but always put it before the message. To have JOptionPane ask for input, a string, from the user, the following statement can be placed in any method. JOptionPane.showInputDialog(null, "Enter data:"); On run time, the JOptionPane will appear with "Enter data:" on the top and an input box below it. The input will always return a string data. In order for JOptionPane to return a numeric data, we use the parse method.

The first statement asks the user to enter a number. After that, it is held in a String variable called input. But since it is a number, we use the parse method to convert it into an integer that is stored inside an integer variable called num. The integer variable called result then adds three to this converted integer, which is then displayed in the JOptionPane for the user to see that their string data got converted into an integer. Working with Floating-Point Values (Double, Float, etc.) Never use the relational operator == when comparing doubles, floats, etc. This is because 0.1 is a stored double that actually equals 0.99999... instead. It is rounded when being used, not compared, to become 0.1. Instead, testing ranges is the most efficient way of comparing floating-point values. If you want to test if a floating-point value is 3.5, check to see if the number if sufficiently close to 3.5. final double MIN = 3.499999; final double MAX = 3.500001; if(dec < MAX && dec > MIN) { System.out.println("This number is x."); } else { System.out.println("This number is not x."); } This code will show that x is in between 3.499999 and 3.500001, which is very, very close to 3.5. Advanced Scanner Input If we want our scanner to determine what type of data is being put, we use the following statement after declaring the scanner object: keyboard.hasNextLine(); (is it a string?) keyboard.hasNextInt(); (is it a integer?) keyboard.hasNextDouble(); (is it a double?) keyboard.hasNextBoolean(); (is it a boolean?) To check if the input the user put in is a string, integer, double, etc., we use conditional statements. if(keyboard.hasNextInt()) { System.out.println("Your input is an integer."); } else if(keyboard.hasNextDouble()) { System.out.println("Your input is a double."); } else if(keyboard.hasNextBoolean()) { System.out.println("Your input is a boolean."); } else if(keyboard.hasNextLine()) { System.out.println("Your input is a string."); } else { System.out.println("Nothing."); } However, if a user does not put any input into the scanner (presses enter), the input will still appear until input is placed. So the else statement above is unnecessary. Integers should be checked first, because an integer can be a double. Also, boolean and everything else should go before checking if the input is a string, because all of them can be considered a string type. Global Constants If a constant must be seen by all methods, it should be declared as a global constant. Instead, regular constants are only seen inside the method they are declared in. For global constants, they are positioned at the top of the program, under the import statements. ... static final int PANTS_WEATHER = 15; public static void main... For a constant to be global, the keyword static is used in front of it. Variables can be global without being constant, however this is not good programming, because anyone can change the variable's value. String Methods There are many methods designed for numeric data, and there is also a separate many methods designed for string data. Equalizing Strings Instead of using the relational operator == to compare strings, which does not work, because every variable has a different memory location, we use the method .equals(). In fact, == only works for primitive data types, or the lowercase data types like int, double, boolean, etc. It even doesn't work properly for double, float, etc. if(string1.equals(string2)) { System.out.println("They are equal."); } The if statement will test if the string1 is the same as string2. If it's true, then the code will run. Comparing Strings If we want to know if strings come before other strings alphabetically, we use the .compareTo() method. String string1 = "abc"; String string2 = "def"; if(string1.compareTo(string2) < 0) { // string1 comes before string2 } You can read the if statement as string1 < string2. If this is true, which it is in this case, the code will run. Technically, .compareTo() does not compare if strings are in alphabetical order. If we were to compare, String string1 = "abc"; String string2 = "DEF"; logically string1 should go before string2. However, it doesn't. Instead, .compareTo() compares the DEC values in the ASCII table. Therefore, D has a lesser value than a, so, DEF comes before abc. To compare strings that have various case sensitivities, use the method .compareToIgnoreCase(). The reason .compareTo() exists is for comparing strings that are not case sensitive, making the program faster. It only has to look at string data, and not convert it into lowercase or uppercase. String Length The method .length() lets the user know how many characters, including white space, there is in total inside the string. String text = "hello world"; int len = text.length(); System.out.println(len); The output would equal 11, because there are 11 total characters, or ASCII characters inside the string variable text. Strings and Character Position In order to access a specific character in a string, each character has its own particular position inside the string. The .charAt() method tells the user where this character is positioned according to zero-based indexing. Zero-based indexing means the very first character, or element, is at position 0, or in the zeroth index. Therefore, if you were to determine the zeroth position in String str = "HELLO"; char ch = str.charAt(0); System.out.println(ch); will give us H.

[linearprogramming]

Relational Operators, Conditional Statements (Boolean), Conditional (Else-If) Statements, and Constants

Relational Operators The following operators are used to compare all data types except Strings. They all return a boolean type.

With these operators, you can compare numeric data and see if they are true or false. int x = 3; int y = 2; if(x == y) { System.out.println("They are equal."); } However, since x and y are not equal, this code will not run, because the if statement is testing for the two variables to be equal. If we did this instead, if(x > y) { System.out.println(x + " > " + y); } The output will give us a message saying x is greater than y, if and only if the statement "x > y" is true, which it is in this case. You can also make variables have conditions. boolean noJacket = true; boolean noPants = true; boolean cold = noJacket || noPants; boolean veryCold = noJacket && noPants; The boolean variable cold is only true if either noJacket is true, or noPants is true. The boolean variable veryCold is only true if both noJacket and noPants is true. Conditional Statements (Boolean) A boolean data type can either return the value true or the value false. boolean catsMeow = true; boolean dogsMeow = false; This is important for programs that have certain conditions in order for certain code to run. Certain code blocks can run depending if a condition is true or false. The following is a conditional statement, where if catsMeow is true, which was initialized as true above, then the code inside the conditional statement will run. if(catsMeow) { System.out.println("Cute!"); } You can also type if(catsMeow == true) or if(catsMeow == false), but it's more standard to just type if(catsMeow) for true, and if(!catsMeow) for false. It is also useful to test if a cat meows AND a dog meows, or a cat meows OR a dog meows. if(catsMeow && dogsMeow) The two apersands, &&, indicate that the if statement must have both boolean variables to be true before running the code. if(catsMeow || dogsMeow) The two lines, ||, indicate that the if statement must have either the first boolean variable, catsMeow, or the second boolean variable, dogsMeow, to be true before running the code. To negate a boolean variable (true becomes false, false becomes true), have an explanation mark, !, in front of the variable. boolean catsMeow = true; boolean catsWithNoMouth = !catsMeow; The boolean variable, catsWithNoMouth, is set to false, because the negation of catsMeow is false. This makes sense, because a cat without a mouth cannot meow. So catsMeow has to be false instead of true, in this case. Truth Table for && If A = false, B = false, result = false If A = false, B = true, result = false If A = true, B = false, result = false If A = true, B = true, result = true This tells us that using the && for conditional statements can only return true if both variables are true. Truth Table for || If A = false, B = false, result = false If A = false, B = true, result = true If A = true, B = false, result = true If A = true, B = true, result = true Truth Table for == If A = false, B = false, result = true If A = false, B = true, result = false If A = true, B = false, result = false If A = true, B = true, result = true Conditional (If) Statements If statements are useful for programs that require decision making, where the code that is executed is not quite linear or predictable. This type of programming is called conditional programming. Using if statements, or conditional statements, programs can execute only certain lines of code instead of all of it. Java uses the keyword, if, and a boolean value to determine if, and only if, a block of code should be run. If that boolean value is true, then the block of code inside that if-statement will run. Else-If Statements Another way of using if statements is when code that executes when an if statement is false. This is using the else statement. if(canAfford) { System.out.println("You can buy it."); } else { System.out.println("You cannot buy it."); } The if statement will test to see if the boolean variable canAfford is true. If it is true, this if statement will run the code inside. Else, if it is false, the program will only run the code inside the else statement. Another way of writing else-if statements is the following: if(someCondition) { // code runs if true } else if (someOtherCondition) { // code runs if the first is not true, but this is true } else { // code runs if none are true above } Note that else-if statements always begin with an if statement, while it generally ends with an else statement. The last else statement is called the default option, where it runs if all if statements are false. Else-statements are optional, and order matters when comparing boolean variables. The very first condition Java sees to be true will run. The other conditions that are outside of this true condition will be ignored. If order was not considered, it could be a problem if the other conditions are more correct than the conditions before it. Nesting If Statements You can place if statements inside of if statements to organize conditional statements into similar conditional statements. if(smart) { System.out.println("You're smart."); if(verySmart) { System.out.println("You're very smart."); } else { System.out.println("You're not smart."); } } The first if statement will test to see if the boolean variable smart is true. If it is true, it will run the code inside. Additionally, the code inside contains another if statement. If the first if statement is true, then the second if statement inside will run to see if the boolean variable verySmart is also true. If it is true, the entire code block inside will run; if verySmart is false, then only the first if statement will run. If the first if statement is false, nothing inside of this if statement will run. Instead, it will run the else statement. Constants Magic numbers are numbers that were directly placed into code, such as this if(temperature < 15) Magic numbers are considered magic, because if someone were to look at your program, the number 15 would be considered random, as if it magically appeared with no context or meaning behind it. Instead of using numbers directly, it is good to create variable constants that are assigned those numbers, and then use those variable constants instead. Instead of int pantsWeather = 15; it should be final int PANTS_WEATHER = 15; The final keyword tells Java that the value assigned to PANTS_WEATHER is a constant. It will never be changed by the program. Instead of using camelCase to name the constant, it uses all uppercase letters with underscores to separate the words. This is more of a conventional way to determine what is a variable and what is a constant. Now it should be if(temperature < PANTS_WEATHER) Constants are good for all magic numbers except 0 and 1. Those do not need constant assignments. Constants are good for two reasons: 1. It makes it easier to change common values that appear in more than one place in the program. If you had to change the value of the constant, you don't have to go through the entire program and change the magic number. All you do is change the constant value at the top of the method it was created in. 2. It makes the code easier to read. Instead of a person guessing what the magic number means, the constant variable's name lets the person know exact what that number is meant for. This allows efficient programming if anyone can read your code, because it helps determine where it will be used and why it will be used. Constants are generally stored on top inside of the main method or other methods.

[linearprogramming]

Characters, Methods, Scope, and Scanners (Input), Parse Method

Char Data Type The char data type represents a single character. char ch = 'y'; Instead of double quotes, it only uses single quotes in Java language. Double quotes are for strings while single quotes are for characters. Only one character can go inside a single-quote structure. char ch = 'a'; is okay, but char ch = 'ab'; is not okay. However, even though escape sequences have two characters for execution, it is still considered one character. Characters and integers are closely related, so each character has a corresponding numeric value, vice versa. It is displayed on a ASCII table.

To switch characters into integers, type-casting should occur. If the code was int x = 76; System.out.println((char)x); The output would be the character corresponding to the intger 76, which on the ASCII table considers L. An integer variable could be also created and initialized with a char value. However, in order for the output to be the corresponding integer for the letter, type-casting int is necessary. int x = (int)'A'; System.out.println(x); Therefore, the output is the integer corresponding to the character A, which is the integer 65. Note that uppercase letters and lowercase letters have a different ASCII value. In fact, if uppercase A was subtracted from lowercase a, the difference would be 32. The same difference for uppercase B and lowercase b, and so on. int difference = (int)'a' - (int)'A'; System.out.println(difference); Output would be 32. Methods An important part of computer programming is code re-usability. It would be useful to only have to write some code once, then use it multiple times in multiple places in the program. To do this very thing, Java language provides methods. A method is a piece of code which, after written, can be used any number of times. They can take any number of parameters, and also return a value depending on the method type. Examples of some methods that have been used so far is println, math class methods, etc. So far, the only method that has been written in DrJava is the main method. That is because Java runs this method automatically without having to call the method. Method Structure An example of a created method is the following:

For now, always place "public static" before the method type and method name. With the method, printMessage(), its return type is "void", because we don't want to return a value. This means there is no parameters inside the parentheses of this method. If it were int, float, double, etc., there would be a return statement and parameter values. The method name is printMessage, which will be used to identify this method when "calling" it in the main method, as seen above. When calling the method in the main method, Java will run whatever code is inside the created method. In this case, Java ran the println message, because that statement was in our printMessage method. In good programming, a method should try to do only one function rather than multiply functions at one run. And its length should be approximately one screen-length. Using One Parameter Instead of having the message inside the method, we can make it where the message is place inside the call of the method. To do this, you set the printMessage's parameters by adding one String parameter with its parameter name. public static void printMessage(String msg) { System.out.println(msg); } This means that, whatever is placed inside the parentheses of the call of the method in the main method, that information is converted into a String variable called msg. And just like using variables to simplify the other statements, println will print out whatever "msg" equals. So if (inside main method) printMessage(); is printMessage(This message was created outside of printMessage's method!); Then the String variable, msg, is assigned these words and printed out in the output. Using Two Parameters If we wanted to have a message print out a name and a number, we would set two parameters in the printMessage method, one that is a String and one that is an int, double, etc. public static void printMessage(String msg, int num) { System.out.println(msg + num); } Now an integer that is placed after a string message inside the parentheses of the called method printMessage (shown below) will be assigned the integer variable num. The printMessage method is then run and prints out a string of the two variables concatenated. So if (inside main method) printMessage(); is printMessage("hello ", 123); Then the String variable, msg, is assigned the words 'hello', and the integer variable, num, is assigned the numbers '123'. They both will be printed out in the output. To designate which input goes into which parameter, a comma is used to separate them. Make sure to always pass the correct parameter values in the parameter. Methods and Return Statements In methods, depending on the return type, it can return that said type after the code inside is executed. If a method were an integer return type, it would return an integer value, etc. public static int Multiply(int x) { int m = x*3; return m; } This method will take the integer value, x, that was inserted in the main method, use that value to create an integer variable, m, into a value, and return this value to the main method. In order for the programming to display this result, the main method would generally have a println method to show this. This returning a value inside a method is called a return statement. It basically tells DrJava to exit from the method and return whatever value is assigned to be returned. If the main method just had Multiply(3); nothing would happen, because no variable was assigned to it, making the returned value lost. Instead int result = Multiply(3); would be suitable, because the returned value from Multiply(3), which would give back 9, is then saved in the integer variable result. However, when using the return type, void, it will not return any value, and therefore does not need a return statement or any variable assigned to it in the main method. Although you can use a simple return statement (return;) in a void method, it is generally useless to do. With return statements, you can only return one value, and it doesn't matter which type of value. (boolean, int, double, etc.) Scope Variables inside one method are completely different, and inaccessible, in other methods, including the main method. These variables have separate scope from each other.

Note that val1 in the main method is completely different than val1 in the Value1 method. If you truly want a variable or value to be accessed in more than one method, the variable or value must pass through a parameter. It is also good practice to never create a variable the same name as a method name, no matter where that variable is stored. Scanners and Getting User Input Instead of just giving output to the user in the console with the println method, it can also be possible to get input from the user in the console. This is called standard input, or console input, stdin. We do this using the scanner object. However, scanner commands are not built-in like the println method, so it must be imported into DrJava first. Above the program, it should have the import statement import java.util.Scanner; Now DrJava knows we want more commands in our program. The java.util.Scanner library is just a library for scanner commands. There are many other libraries for many other functions. Now you can create a scanner object in any of the methods in the program. To create a scanner object with a variable called keyboard, its statement is Scanner keyboard = new Scanner(System.in); or Scanner keyboard; keyboard = new Scanner(System.in); Next, we can create a variable that allows the scanner to be shown in the console. String input = keyboard.nextLine(); or (using a declaring statement before assigning the variable) String input; input = keyboard.nextLine(); For this one, it is stored in a String variable, where nextLine() causes whatever is typed into the scanner to become a string. For numeric data, it's int input = keyboard.nextInt(); for integer data double input = keyboard.nextDouble(); for decimal data For conditional data, it's boolean input = keyboard.nextBoolean(); for true/false data For scanner input, it can be used many times after one call of the scanner object. Scanner keyboard = new Scanner(System.in); int i = keyboard.nextInt(); double d = keyboard.nextDouble(); This will cause two scanners to appear, one for integer input and the other for double input. Numeric data that is typed into the input is stripped out of the scanner by whitespace, while non-numeric data is stripped out of the scanner by line breaks. Parse Method It is very useful to convert string data, such as numbers stored in a string variable, to integer/double/long data by using the parse method. This is because often data files in a program will contain numeric data that must be converted into integers first. String data = "1234"; int num = Integer.parseInt(data); double num1 = Double.parseDouble(data); long num2 = Long.parseLong(data); However, the string data must be numbers, otherwise the parse method will crash.

[linearprogramming]

Scalar Multiplication, Addition, Subtraction, and Multiplication Between Matrices

Properties of Matrices Commutative property does not always apply to product matrix AB. AB ≠ BA Associative property holds true as long as product matrices are defined. AB(C) = A(BC) Identity matrices of other matrices form the product matrix of the other matrix.

Scalar Multiplication If matrix A is the following:

Then matrix 3A is matrix A multiplied by the scalar 3.

Matrix Addition If matrix A and matrix B are both an nxn matrix, then the addition matrix A + B is obtained by adding matrix A's entries to the corresponding entries of matrix B.

Otherwise, the addition matrix is undefined if they are not both an nxn matrix. Matrix Subtraction If matrix A and matrix B are both an nxn matrix, then the subtraction matrix A - B is obtained by subtracting matrix B's entries from the corresponding entries of matrix A.

Otherwise, the subtraction matrix is undefined if they are not both an nxn matrix. Matrix Product If matrix A is an nxr matrix and matrix B is an rxm matrix, then the product matrix AB is obtained by creating an mxn matrix. This does not always apply for product matrix BA.

Otherwise, the product matrix is undefined if matrix A's columns are not the same amount as matrix B's rows. Linear Combination When given a linear system, it can be written in the matrix form Ax = b.

If A = (4x5), B = (4x5), C = (5x2), D = (4x2), and E = (5x4) matrix, then find the following matrices: BA BA = B(4x5)A(4x5) = undefined (4 ≠ 5) E(AC) E(5x4) (A(4x5)C(5x2)) E(5x4) (AC(4x2)) (because A's column amount equals C's row amount, creating 4x2) E(AC)(5x2) (because E's column amount equals AC's row amount, creating 5x2) AC + D A(4x5)C(5x2) + D(4x2) AC(4x2) + D(4x2) (because A's column amount equals C's row amount, creating 4x2) (AC + D)(4x2) (because AC's column and row amount equal D's column and row amount, respectively, creating 4x2)

Find all values of k that satisfy the following matrix equation:

Multiply the first two matrices, because they are defined. (1x3)(3x3) = (1x3)

Now multiply this product matrix with the third matrix, because they are defined. (1x3)(3x1) = (1x1)

Solving for k: k² + 2k + 1 = 0 (k + 1)² = 0 k = -1 Therefore, if k = -1, the the matrix equation will be satisfied.

[linearprogramming]

Output, Syntax, String and Int Variables, Type-Casting, Crementation, and Mathematic Statements (Math Class)

When "source code" or even just "code" is mentioned, it is implying the code in the program that is being created. Compiler is the program that converts the source code into binary, so the computer can understand it and run it. In Java language programming, it uses a program called Java virtual machine (J.V.M.) to also translate the programming code. Java source files must have a .java extension. To demonstrate the syntax, or the grammar, of the Java language, begin with a simple example of a method, System.out.println().

Compiling and Running Make sure to compile the code before running the code. In DrJava, the file is prompted to save before compilation. The above code is an instruction for the computer to print out the message "Hello world!" on the DrJava screen. When pressing Compile, then Run, the following happens in Compiler Output:

Comments Note the green-highlighted text. These are called comments. They are used for documenting code, writing notes, etc. The compiler will ignore any comments made. It will even ignore code made into a comment. There are two types of comment formats in Java language: a block comment and a comment line. The green-highlighted comment at the top is a comment block, which begins and terminates with /* and */, respectively. Block comments are useful when documenting long, multiple-lined comments. The green-highlighted comment after the comment block is a line comment, which begins with //, and everything on the same line after the // is ignored by the compiler. Program Name and File Name The program name must be the same as the file name associated with it, and the name of the program is found in a dark blue. In this code, the program name is HelloWorldExample. The file name would then be HelloWorldExample.java. Main Method After the main method, public static void main(String[] args), all of the code is generally written under it. Curly Braces and Code Blocks Curly braces denote the start and the end of the code, which is called a code block. In this code, there are two code blocks: one is of the main method and the other is for the program, HelloWorldExample. Indenting Code Blocks It is always custom to indent code blocks consistently with the tab key due to making the code blocks much easier to read. Statements A program, and many algorithms, are made of statements. Statements are basically a line of instruction for the computer to read. In this code, a statement of System.out.println() is present, telling the program to print a message to the screen. Syntax Since statements are made for the computer to follow instructions, they must be structured in a certain way for the computer to understand it. All programming languages have syntax rules. A basic structure of a statement is the following: command(parameter); Since the print line statement is a command, or method, it follows this syntax. command(parameter); System.out.println("Hello world!"); In this case, the command is System.out.println(), and the parameter is "Hello world!". Although we can change the parameter, we cannot change the command. System.out.show("Hello world!") would not work, because there is no such command in Java language. Compile-time Error If the syntax was not typed properly, causing syntax errors, Java will give an error describing what is wrong during compile-time, however most of the time it is hard to understand the problem. This is called a compile-time error. Case Sensitivity Java language is case sensitive in which System.out.println(); is not the same as system.out.println(); In fact, S and s are completely different characters meant for completely different things in Java language. Output If the following statement was used: System.out.println("..."); then a new line will start after printing the message "...". Additionally, if the following statement was used: System.out.print("..."); then there will be no new line after printing the message "...". This is because "ln", or line, was not included, therefore these two statements have differences when running. Standard Output System.out.println() and System.out.print() are both examples of methods called standard output or console output. It is also possible to see them being called stdout, a shorthand for standard output. Parameters Putting something in double quotes, "", is the way of providing text to Java language. Therefore, removing these double quotes will leave a compile-time error. String Anything in double quotes is called a string, which is short for string of characters. It is a type of data given to the computer. The domain for characters in Java language is letters, numbers, symbols, or even whitespace produced by the space bar. Strings can be joined together, or concatenated, to form larger strings. This is done by using string concatenation, +. System.out.print("Hi" + "there"); will print Hi there Concatenation is something a programmer can always do with strings. Variables It is useful to store data in programs, such as usernames, passwords, bank account balances, etc. This data can be stored in variables. Consider variables like buckets that hold data. Variables are like the mathematical variables, where a variable is assigned a value or a parameter that equals a value. x = 1 y = 20 z = x + y There are different types of variables that hold specific types of data. In the previous code, an example of a specific type was the string data type. Since strings only display characters instead of calculate characters, there is a specific data type for mathematic calculations. Variable Capabilities There are three ways that a variable could be used. 1. Creating a variable. In mathematics, creating a variable is assigning a value to a character, such as x = 1. 2. Assigning a value to a variable. In mathematics, assigning a variable to a value is the same as creating the variable. x = 1 Not only did it create the variable, x, but it was assigned the value 1. This is why variables are called variables: they can vary in value. If a value was assigned to the variable the first time, then it is called initializing the variable. Another way of assigning is assigning variables to other values, even to themselves. Given the following variable declaration: String name; name = "Joe"; There can be another variable involved, such as lastname... String name; String lastname; name = "Joe"; lastname = "Smith"; However, if someone was named Smith, we could use the string variable, lastname, to input this value. String name; String lastname; lastname = "Smith"; name = lastname; If it were the print the variable, name, then its value should be Smith. System.out.println(name);

img5

Just because we set name to lastname in value, it does not change the initial value of lastname; assigning variables is merely copying the variable. Assigning variables is actually an operator, and a good way to show this is the following statements: int x; System.out.println(3 + (x = 4)); System.out.println(x); Two outputs will happen: 7 and 4. The first output indicates that the integer 3 will be added to the value of x, which is 4. The second output indicates that the integer variable, x, is equal to 4. 3. Retrieving the value of a variable. In mathematics, retrieving the value of a variable means to find the value of the variable to perform the instruction. if x = 4, then 4x = 16 The above statement had to retrieve the variable value, 4, to determine 4x. 4. Declaring variables. Declaring variables in Java language has the following syntax rules: variableType variableName; A string variable called "name" would look like this: String name; It is saying to create a String variable and name it "name". Once the variable is created, it does not need to be created again. If the variableName had a value, the following syntax rules would be used: variableName = data; Therefore, the variableName above, name, can be assigned a value. name = "Joe"; Remember that the variable type is a String, so double quotes are used for the data. These double quotes are called string literal. Because whatever is inside the double quotes is what will be literally stored in the string variable. Therefore, the string "Joe" is stored into the string variable name. Another way to write the following: String name; name = "Joe"; is String name = "Joe"; This is both declaring the variable and initializing the variable all on one line. 5. Accessing variables. Variables can be accessed at any time. If the variable name was assigned the value "Joe", then the variable can be used to access the value during an instruction statement. Since the variable is a string type, then the instruction statement must be a string command. String name; name = "Joe"; System.out.println("Joe"); can be written as String name; name = "Joe"; System.out.println(name); The following demonstrates how to access variables:

When Compile is pressed, and Run is pressed, the following output should result:

Escape Sequences If a double quote, or other special characters, is desired in the string, it cannot be simply placed inside the double quotes without a compile-time error. Instead, there are some escape sequences to allow such characters in string variables. They always begin with a back slash, \. For double quote, ", it's \" For a new line, it's \n For a tab indent, it's \t For a back slash, it's \\ Naming Variables A few rules to naming variables in order for Java language to understand: 1. No spaces. 2. No special characters, except underscores. 3. Numbers can be used but cannot start with a number. 4. Cannot be named as Java language's reserved words.

Numbers and Variables If we used a string variable and its concatenated operator, +, to add numbers, it would literally add the number characters together and not actually create a sum. That means this:

will produce this:

This is why string literals are called string literals. Because they literally string values together. Instead, another type of variable would have to be used; a variable that deals with number characters for arithmetic operations. There are many types of these variables, but the common ones are the following: int Stands for integer. Only deals with whole number values. Has 4 bytes of memory, which is 32 bits in total. Range: +- 2,147,483,647 long 64 bits. Range: +- 9,223,372,036,854,775,807 short 16 bits. Range: +- 32,767 byte 8 bits. Range: +- 127 There are also variable types for decimals. float 32 bits. Range: ~7 significant digits double 64 bits. Used more for better precision. Range: ~15 significant digits When using integer variables, do not use commas to separate place value. Note that the floating-point values are not always accurate, which is considered normal and will not really affect the program. String Variables and Integer Variables Concatenating a string and an int will always make a string output, never an integer output. Combining a string data with numeric data String course = "comp" + 1010; will result in "comp1010". Written differently: int num = 1010; String course = "comp" + num; Type Casting Certain data types, like int and double, are very closely related. With this relation, similar data types can be type-casted into each other. What if the data value of the following statement double someDecimal = 5.7; was to be an integer instead of a decimal? To type-cast this, you create another variable and insert (int) before the variable you want type-casted. double someDecimal = 5.7; double val = (int)someDecimal; This will return the value of 5, meaning the decimal portion, 7, is truncated, or dropped. This does not mean the number was rounded. Rounding Numbers In order to round a floating-point number rather than truncating the number, add 0.5 and then truncate. To round the floating-point number 5.7, the following code is used:

When compiled and ran, the compiler output should give 6.0. Operators Operators are the things we can do to different data types. Operators include concatenating strings and adding numbers. There are either unary operators or binary operators. Unary, or monadic, operators have a single one operand: int val = -5; In this case, the negation of the five is the operand. Binary (dyadic) operators have two operands: int sum = a + b; In this case, a is the first operand, and b is the second operand. Five Standard Arithmetic Operators Addition (+): int val = x + y; Subtraction (-): int val = x - y; Multiplication (*): int val = x * y; Division (/): int val = x / y; Modulus (%): int val = x % y; If a number was to be divided by another number with a remainder, truncation will occur. Therefore, to store the result in a floating-point number, it is important to type-cast the variable type double for each operand. int a = 5; int b = 2; double divide = (double) a / (double) b; The output result should then be 2.5. double divide = a / b; would result in 5/2 truncated: 2.0, which is the wrong answer. Order of Operation The following the order of operation for statement calculation. 1. Casting. 2. Bracket calculations. 3. Multiplication. 4. Division. 5. Addition. 6. Subtraction. 7. Variable assignment happens. Therefore, using parentheses to clean up the mathematical expressions is required. Math Library Java language has another built-in library that allows programmers to do a lot of additional mathematics. This library is called the Math Class. In Math Class, there are many functions for square roots, trigonometry, absolute value, random numbers, minimum and maximum, and more. Maximum and Minimum A way of finding what the maximum or minimum of 2 numbers is to use the method Math.min(a,b); Using 2 numbers: int a = 5; int b = 10; int minimum = Math.min(a,b); The output will return the lowest number of 5 and 10, which is 5. With maximums and minimums, the parameters are two instead of one. Some methods have more than two parameters. If it was desired to determine the maximum or minimum of more than two numbers, the following should be applied: int a = 1; int b = 2; int c = 3; int d = 4; int highest = Math.max( Math.max(a,b), Math.max(cd) ); System.out.println(highest); Notice that, since maximum and minimum methods can only work in two parameters at a time, the first two int values, a and b, are compared in one parameter, and the second two int values, c and d, are compared in the other parameter. After those are compared, the maximum value for the first parameter and the maximum value for the second parameter are then compared. In the end, the maximum value is 4, which would be the compiler output. Increment and Decrement Incrementation and decrementation are used to keep track of the number of a certain value at any given time in the program, such as the number of bullets your gun has in the video game or how much time has passed. If the number of seconds increased by 1 each time, the following statement can apply to this increment: numSec = numSec + 1; This may also be expressed the same way with the following statements: numSec ++; (This statement, called postfix increment, only increases by 1.) numSec += 1; Decrementation, if time were to count down instead of up, would have similar statements: numSec = numSec - 1; numSec --; (This statement only decreases by 1.) numSec -= 1; Postfix Crementation and Prefix Crementation Recall that ++; or --; increases and decreases by 1, respectively. However, this can be placed behind the variable, postfix, or in front of the variable, prefix. They crement in different ways. numSec ++; int numSec = 2; int secondsAdded = numSec++; int seconds = numSec; The output of the variable seconds would result in 3. This postfix incrementation means to use the variable, numSec, then increment by 1, showing the increase in the next statement regarding that cremented variable. ++numsec; This prefix incrementation means to increment numSec by 1, then use numSec. int numSec = 2; int seconds = ++numSec; The output would result in 3. Expressions Any statement that can be evaluated is known as an expression. Such expressions are like this: int a = 5; int b = 10; int c = 15; int x = (a + b) * c; x --; String str = "result = " + x; In this case, the expressions are 5, 10, 15, (a + b) * c, x --, and "result = " + x. Variables, and other things, are always assigned values from expressions. Random Numbers Another method that the Math Class has is a method to generate a random number in the range of [0,1). Math.random(); To make the number not inside this range, we simply place the expression (min + (max - min + 1) with the method. int min = 1; int max = 6; int diceRoll = (int)(min + (max - min + 1) * Math.random()); Remember to cast the value as an int, because Math.random() is a decimal value. Although Math.random() can be zero, the min added on to the value after the multiplication causes the output to be in the minimum, 1, and maximum, 6, range. Floating-Point Syntax There many different values that indicate a floating-point number. The common are the following: double v1 = 5.0; (regular double) float v2 = 5.0F; (F specifies a float) double v3 = 2.1E-3 (scientific notation) double v4 = .1; (omitting 0)

[linearprogramming]

Introduction to Computers and Java

Java is a powerful language that runs on practically every type of computer. Java can also be used to create large applications on small programs, known as applets, that are part of a website. Reasons to Program Computers can do many different jobs because they are programmable. Every profession has tools that make the job easier to do. The computer is a tool used by many professions that it cannot be categorized. The computer can perform many different jobs that it is perhaps the most versatile tool ever made. The computer can do a wide variety of tasks, because it can be programmed. Computers are machines specifically designed to follow instructions. Without programmers, the users of computers would have no software, and without software, computers would not be able to do anything. Programmers must learn special languages, such as Java language, because computers do not understand English or other human languages. Programming languages have strict rules that must be carefully followed. Computer Systems: Hardware and Software All computer systems consist of similar hardware devices and software components. Hardware Hardware refers to the physical components that a computer is made of. A computer is not an individual device, but a system of devices. A typical computers system consists of the following major components: the control processing unit (C.P.U.), main memory, secondary storage devices, input devices, and output devices. The Control Processing Unit (C.P.U.) At the heart of a computer is its central processing unit (C.P.U.). The central processing unit's (C.P.U.) job is to retrieve or fetch instructions, follow the instructions, and produce resulting data. Internally, the central processing unit (C.P.U.) consist of two parts: the control unit and the arithmetic and logic unit (A.L.U.). The control unit coordinates all of the computer's operations. The control unit is responsible for determining where to get the next instruction and regulating the other major components of the computer with control signals. The arithmetic and logic unit (A.L.U.) is designed to perform mathematical operations. Programs A program is a sequence of instructions stored in the computer's memory. When is a computer is running a program, the control processing unit (C.P.U.) is engaged in a process called the fetch-decode-execute cycle. Fetch is when the control processing unit (C.P.U.) fetches, from the main memory, the next instruction in the sequence of program instructions. Decode is when the instruction that was fetched is encoded in the form of a number. The control unit decodes the instruction and generates an electronic signal. Execute is when the electronic signal is routed to the appropriate component of the computer. The electronic signal causes the component to perform an operation. Main Memory Random-access memory (RAM) is the computer's main memory: a device that holds information. Random-access memory (RAM) holds the sequences of instructions in the programs that are running and the data those programs are using. Memory is divided into sections that hold an equal amount of data. Each section is made up of eight switches that may be either on or off. A switch in the on position usually represents the number 1, while a switch in the off position usually represents 0. The computer stores data by setting the switches in a memory location to a pattern that represents a character or a number. Each of these switches is known as a bit, which stands for binary digit. Each section of memory, a collection of eight bits, is known as a byte. Each byte is assigned a unique number called an address. The addresses of bytes are ordered from lowest to highest. Random-access memory (RAM) is used only for temporary storage. When the computer is turned off, the content of the random-access memory (RAM) is erased. Secondary Storage Secondary storage is a type of memory that can hold data for long periods of time, even when there is no power to the computer. Frequently used programs are stored in secondary storage and loaded into main memory as needed. The most common type of secondary storage device is the disk drive. A disk drive stores data by magnetically encoding it onto a circular disk. Hard drives, the most common type of disk drives, are capable of storing very large amounts of data and can access data quickly. Most computers have a hard drive mounted inside their case. External hard drives are also available, which connect to one of the computer's communication ports. External hard drives can be used to create back up copies of important data or to move data to another computer. In addition to external hard drives, many types of devices have been created for copying data, and for moving data to other computers, such as floppy disks and Universal Serial Bus (U.S.B.). A floppy disk drive records data onto a small floppy disk, which then can be removed from the drive. The disadvantage of floppy disks was that they hold only a small amount of information while performing slowly. Universal Serial Bus (U.S.B.) drives are new in favor, because they are small devices that appear to the system as a disk drive when plugged in. Optical devices, such as compact disc (C.D.) and the digital versatile disc (D.V.D.) are also popular data storage. Data is not recorded magnetically on an optical disc; it is instead encoded as a series of pits on the disc surface. Compact disc (C.D.) and digital versatile discs (D.V.D.) drives use a laser to detect the pits, reading the encoded data. Input Devices Input is any data the computer collects from the outside world. Input devices are the devices that collect this data and send it to the computer. Common input devices include the keyboard, the mouse, te scanner, the digital camera, disk drives, optical drives, and Universal Serial Bus (U.S.B.) drives. Output Devices Output is any data the computer sends to the outside world. Output includes lists of names or graphic images. Output devices are the devices that the computer sends data to for it to be formatted and presented. Common output devices include monitors and printers. Software Software refers to the programs that run on a computer. There are two general categories of software: operating systems and application software. An operating system is a set of programs that manage the computer's hardware devices and control their processes. Mostly all operating systems now are multitasking capable, having the ability of running multiple programs at once. Using a technique called time sharing, operating systems divide the arrangement hardware resources and the attention of the control processing unit (C.P.U.). Mac, O.S., and Windows are some examples of multitasking operating systems. Application software refers to programs that make the computer useful to the user. Application software solve problems or perform general operations that satisfy the needs of the user. Word processing and spreadsheets are examples of application software.

[linearprogramming]

First Java Project (Person Project)

The following describes how to declare classes, add variables and methods, use the

class to observe the application's behavior, and use a

method as a test harness, all by using the Eclipse Package Explorer. Creating a Package The first step after creating a New Project in Eclipse is to create a place for the class to live in. Packages are namespace constructs, but they conveniently map directly to the file system's directory as well. It is almost always a bad idea to use the default package in Eclipse, so to create a new package: File > New > Package. For "name", type in

. Declaring a Class There are many ways to create a class. The easiest way: right-click on the created package > New > Class... Doing so will make the New Class dialog box pop up. In the "name" box, type

. Under "which method stubs would you like to create?", select

. The code displayed afterwards is a shell class that includes the package statement, red boxed, and the

method, blue boxed.

Two things happen right away if a programmer adds code: an asterisk, *, appears on the class tab, red boxed, telling the programmer the original code is modified and not saved; and red, wavy lines under words, blue boxed, telling the programmer the compiler could not find a reference to such class, flagging the word as a compile error.

Adding Class Variables When constructing a variable, recall that it has an

, a

, a

, and, optionally, an

. A

can either be a primitive type or a reference to another object, such as

. The following table shows eight common primitive data types:

Built-in Logging The Java platform includes the

package, which is a built-in logging mechanism for gathering program information in a readable form. Loggers are named entities that a programmer creates through a static method call to the

class.

Note that "// ..." means the import statement is located under the package statement, the letter after Logger is lowercase L, and the

statement is for any non-static method, which will always reference the name of the class and pass that to the

. If the programmer is making a

call inside a static method, they reference the class the

call is inside of.

This example shows that the statement is in the

class, which is why it has a reference of a special literal,

, that retrieves the

object and gets its

attribute. Using

as a Test Harness

is a special method that a programmer can include in any class so that the J.R.E. can execute its code. A class is not required to have a

method, some most never will; however, a class can have at most one

method. Have Person.java obtain the following code, which is adding a constructor to

, blue boxed.

Notice how the variables are underlined in yellow, red boxed. This is because they lack getter/setter methods. To have each variable obtain a getter/setter method: right-click

in

> Source > Generate Getters and Setters. Have all variables selected and set the insertion point to "Last member". Press OK, where now the getter/setter methods appear after the

method. Add the following code to the

method, ignoring the importance of

for now. However, make sure

is imported, which is not displayed below.

Executing Code in Eclipse To run a Java application from inside Eclipse, the class must have a

method. Click the Run icon and select the class to run. The console view will open automatically and show

output.

[linearprogramming]

Gaussian Elimination, Gauss-Jordan Elimination, Echelon Form

Gaussian Elimination Gaussian elimination is an algorithm, a well-known defined procedure for computation that eventually completes. It finds all solutions to any m x n system of linear equations. Elementary Row Operations The Gaussian elimination is defined via three certain elementary operations carried out on an augmented matrix that corresponds to the system of linear equations. These three elementary operations change the augmented matrix, hence changing the system of linear equations associated with it, but it does not change the set of solutions.

Interchanging Two Rows Switching two rows in an augmented matrix is the same as writing the two equations in different order. The equations are not changed, nor is the solution set changed. Given the following 3 x (3 + 1) augmented matrix:

If it were to have row 1 interchange with row 3 (R₁ ↔ R₃):

Multiplying a Row By a Nonzero Constant If a linear equation were to be multiplied by a nonzero constant, λ, on both sides of the equation, then the solution set is unchanged as long as λ ≠ 0. Given the following 3 x (3 + 1) augmented matrix:

If it were to have row 2 be multiplied by λ = -3 (R₂ → -3R₂):

Adding or Subtracting a Multiple of One Row to Another If a row, j, where to change another row, i, by being added to or subtracted from row i, then it is said that row i would be replaced by the sum or difference of two rows, i and j. This method is used to eliminate a variable, and if the variable cannot be eliminated by just addition or subtraction of row j, then a constant is multiplied through row j before addition or subtraction. Note that the row used to manipulate the desired changing row will not be changed in the final augmented matrix. Given the following 3 x (3 + 1) augmented matrix:

If R₂,C₁, or -1, were to be eliminated, or equal zero, we can multiply the first row by 1/2 and then add row 1 and row 2 together (R₂ → R₂ + 1/2R₁): Multiplying the row 1 by 1/2: 2 3 -1 | 2 1 3/2 -1/2 | 1 Adding altered row 1 to row 2: 1 3/2 -1/2 | 1 -1 1 1 | 4 0 5/2 1/2 | 5 Final augmented matrix:

Echelon Forms and Gauss-Jordan Elimination The following is an example of an augmented matrix in reduced row echelon form.

In order for an augmented matrix to be in reduced row echelon form, the augmented matrix must have all four properties: 1. If a row does not have all zero entries, then the first nonzero number in that row is 1, called the leading 1. 2. If there are any rows that do have all zero entries, then they are grouped together at the bottom of the augmented matrix. 3. If there are rows on top of each other with nonzero entries, the leading 1 in each descending row should be a column more right than its higher row. 4. Besides the constants and leading 1 for each row, there should be zeros everywhere else. In order for an augmented matrix to be just in row echelon form, the augmented matrix only needs the first three properties. An augmented matrix in row echelon form has zeros below each leading 1, while an augmented matrix in reduced row echelon form has zeros below and above each leading 1. The variables that associate to each leading 1 are called leading variables, while the rest of the variables are called free variables. Free variables are often treated as parameters. After using a sequence of elementary row operations to make an augmented matrix for a system of linear equations put into reduced row echelon form, then the solution set can be obtained by either inspection or by converting certain line equations into parametric equations. Facts About Echelon Forms 1. Every augmented matrix has a unique reduced row echelon form. If Gauss-Jordan elimination or other sequences of elementary row operations were done, the reduced row echelon form will always result the same. 2. Row echelon forms are not unique; the algorithms applied to the augmented matrix can result in different row echelon forms. 3. All row echelon forms of an augmented matrix, A, have the same number of zero rows, and the leading 1s always occur in the same positions in the row echelon form of that given augmented matrix. These positions are called pivot positions of A, and the columns that contain pivot positions are called pivot columns. The following augmented matrix has three pivot columns: 1, 3, and 5.

The algorithm that is used to reduce an augmented matrix into reduced row echelon form is called Gauss-Jordan elimination. In this algorithm, there is a forward phase, where zeros are produced below the leading 1s, and then a backward phase, where zeros are produced above the leading 1s. If only the forward phase was applied to an augmented matrix to make it into row echelon form, then it is not the Gauss-Jordan elimination algorithm, but the Gaussian elimination. Solving Systems of Linear Equations with Gaussian Elimination 1. Write the system of linear equations in an augmented matrix. 2. Make R₁C₁ a leading one by multiplying this row by a constant, λ. 3. Make C₁'s entries zeros (besides R₁,C₁) by adding or subtracting multiple of R₁. 4. Make the next leading row in R₂C₂, or at least in C₂ by multiplying this row by a constant, λ. 5. Continue the same steps to achieve an augmented matrix in reduced row-echelon form. 6. Write the matrix back in linear equations. Solve for the system. Back-Substitution For small, easy to solve, linear systems, Gauss-Jordan is a good algorithm to use. For large, computer-required, linear systems, Gaussian elimination is a good algorithm to use, followed by a technique known as back-substitution to complete the process of solving the system. Using Back-Substitution to Solve For Linear Systems 1. Make sure the augmented matrix is in row echelon form. 2. Convert the augmented matrix into a system of linear equations. 3. Solve for the leading 1 in each equation. 4. Working from the bottom row to the top, substitute the leading 1 in the bottom row into the row above it. 5. Using the substituted and simplified equation, do the same as step 3 for this row. 6. Assign parameters if needed and solve for all variables.

Solve the following linear system:

1. Write the system of linear equations in an augmented matrix.

2. Make R₁C₁ a leading one by multiplying this row by a constant, λ. In this case, the entry of R₁C₁ is already a leading one. 3. Make C₁'s entries zeros (besides R₁,C₁) by adding or subtracting multiple of R₁.

4. Make the next leading row in R₂C₂, or at least in C₂ by multiplying this row by a constant, λ. Multiplying R₂ by -1:

5. Continue the same steps to achieve an augmented matrix in reduced row-echelon form.

6. Write the matrix back in linear equations. Solve for the system.

Therefore, (x₁,x₂,x_3) = (3,1,2).

[linearprogramming]

Methods, Variables, and Naming Classes

Listing 1

Naming Classes When naming a class, the convention is to use CamelCase, where it begins with a capital letter, then each other concatenated word is capitalized as well, leaving the rest of the letters lowercase. Class names should only contain letters and numbers. Classes can have two types of members: variables and methods. Variables In a class, the value of its variables distinguishes each instance of that class and defines its state. These values of the variables are often called instance variables. In a variable, it has an

, a

, a

, and optionally an

. A variable's

's value could be

,

,

, or no specifier called package private, or friendly.

means any object can see the variable, but this specifier is highly recommended to not be used.

means any object in the same package as the given object can see the variable.

means only the class containing the variable can see it. No specifier, or friendly/package private, means only objects whose classes are defined in the same package can see the variable. A variable's

depends on what the variable is. A variable's

could be any name for the variable, following the CamelCase rules. A variable's

give the programmer an option to initialize a variable. Otherwise, the compiler generates a default value. The following is an example of variables being used for a class definition of

:

Since this class definition only defines attributes, and private attributes too, this definition is rather a useless one. It needs behavior from methods. Methods As variables are the attributes of an object, methods are the behavior of an object. Methods can be simple, where it does nothing more than return the current value of an attribute, or methods could be more complex. There are categories of methods: constructors, static methods, instance methods, and then the rest of the methods, which there are many types. A constructor method is only used to create an instance of a class. Refer to Listing 1 that mentions the following elements:

,

,

, and

. The combination of these structural elements in a method definition is called its signature. Constructor Methods (refer to Listing 1, lines 5-6)

Constructors are optional, and if a programmer does not provide one, the compiler will provide it for them, where this constructor is called the default constructor, or no-argument constructor. A constructor's

works the same as the variable's

. ClassName means the constructor's name must be the same as its class. If the constructor is not default, there will be an

, which has an

and an

. In an argument list, the arguments are separated by commas, and no two arguments can have the same

. An

can either be a primitive type, such as int, or a data type, such as String. The following is an example of variables (not highlighted) and constructor methods (highlighted):

Notice how the first statements that are highlighted provide an example of a no-argument method, while the second statements that are highlighted do. When a variable assignment has the keyword,

, it is shorthand for "this object", which must be used if the constructor parameter (the constructor statements) and the class variables are the same name, helping the compiler disambiguate the reference. Other Methods (refer to Listing 1, lines 8-9)

Although a constructor is a particular kind of method with a particular kind of function, there are many other types of methods that perform particular functions as well. Other methods look a lot like constructor methods but with exceptions: other methods can be named whatever desired (generally starting with a lowercase, no numbers unless necessary) and, unlike constructors, other methods have an optional return type. The following is an example of other methods, omitting the constructor methods:

Notice in the highlighted statements,

and

. These are one of the getter/setter combinations. A getter is a method for retrieving the value of an attribute, and a setter is a method for modifying that retrieved value. In the example of other methods above, the getter/setter combination was used for the attribute,

. The reason

's return type is

is because this method does not return a value. Static and Instance Methods The other two important methods other than constructor methods are static methods and instance methods. Getter/setter methods are in the category of instance methods. Instance method's behavior is dependent on the state of the specific object instance. Static methods are sometimes called class methods, because their behavior is not dependent on any object's state. A static method's behavior happens at class level. Static methods are used largely for utility, almost as in having global methods, however keeping the code itself grouped with the class that needs it. An example of a static method is the

class, which is used to output information to the console. To create a

class instance, instead of making a

class, the programmer uses a static method called

. The syntax for using a static method is different from the syntax used for a method on an object instance, so in order to invoke a static method, the programmer does not need an object instance, just the name of the class.

[linearprogramming]

Modular Arithmetic

Modular arithmetic modifies usual arithmetic by only using the numbers 0, 1, 2, ..., n - 1, where n is a fixed natural number called the modulus. Standard properties of addition and multiplication familiar from the integers remain valid in modular arithmetic. Using modular arithmetic, calculating sums, differences, and products is done normally, however, if a negative number or a number greater than n - 1 occurs, this number gets replaced by the remainder after division by n. If n = 7, the sum of 3 + 5 is 1 instead of 8, because 8 is greater than n - 1 (6), and when 8 is divided by 7, the remainder is 1. This expression is said as "3 + 5 is congruent to 1 modulo 7," denoted as: 3 ⊕ 5 ≡ 1 (mod 7) where ≡ means "congruent to" If using division, such as 13/5, it would be written as follows: 13 mod 5 = 3 (because 13/5 = 2 remainder 3)

[linearprogramming]

The Field of Axioms

Instead of restricting ourselves to linear equations with rational or real coefficients, let us go over to the more general case, where coefficients belong to an arbitrary field. Field F is a set F, which possesses operations of addition and multiplication that satisfy the familiar rules of rational arithmetic. Ten Basic Properties in a Field 1. (a + b) + c = a + (b + c), for all a, b, c in F; 2. ab(c) = a(bc) for all a, b, c in F; 3. a + b = b + a for all a, b in F; 4. ab = ba for all a, b in F; 5. An element, 0, exists in F, where 0 + a = a for all a in F; 6. An element, 1, exists in F, where 1a = a for all a in F; 7. To every a in F, there corresponds an additive inverse, -a, in F, satisfying a + (-a) = 0; 8. To every non-zero a in F, there corresponds a multiplicative inverse, a⁻¹, in F, satisfying a(a⁻¹) = 1; 9. a(b + c) = ab + ac for all a, b, c in F; 10. 0 ≠ 1. Sixteen Familiar Rules 1. -(a + b) = (-a) + (-b); 2. (ab)⁻¹ = a⁻¹b⁻¹; 3. -(-a) = a; 4. (a⁻¹)⁻¹ = a; 5. -(a - b) = (b - a); 6. (a/b)⁻¹ = b/a; 7. a/b + c/d = ac/bd; 8. (a/b)(c/d) = ac/bd; 9. ab/ac = b/c; 10. a/(b/c) = ac/b; 11. -(ab) = (-a)b = a(-b); 12. -(a/b) = -a/b = a/-b; 13. 0a = 0; 14. (-a)⁻¹ = -(a⁻¹); 15. a - b = a + (-b); 16. a/b = ab⁻¹, where b ≠ 0.

[linearprogramming]

Java Language: Reserved Words, Object Structure and Their Definitions

Although you can create first-class objects in Java language, not everything is an object. Two things make Java language different from purely object-oriented languages: Java language is a mixture of objects and primitive types, and Java language allows the programmer to write code that exposes the inner workings of one object to any other object that uses it. Reserved Words Like any programming language, Java language designates certain words that the compiler recognizes as special, where the following words cannot be used to name constructs:

,

, and

are literals and are also not to be used as Java construct names. An advantage of programming with I.D.E. is the use of syntax colouring for reserved words. Structure of A Java Object Since an object is a discrete entity that contains attributes and behavior, it has a crisp boundary, a state, and can do things when asked correctly. Every object-oriented program has rules on how to define an object. In Java language, an object can be defined by the following, called Listing 1:

This Listing 1 contains many constructs. The constructs highlighted are literals, which are found in the reserved words, and therefore, in any object definition, must be what they are written like in Listing 1. The other, non-highlighted constructs were named to represent their concepts, where the concepts with the square brackets are not required in code, such as "= initial value" and "argumentList". Square brackets are also not part of the Java syntax. Comments in Code (refer to Listing 1, lines 11-15) As seen in Listing 1, almost every programming language allows the programmer to add comments to help document the code. Java syntax allows single-line and multi-line comments, however the single-line comments must always be on one line, and, although multi-line comments can span any numbers of lines, it must begin and terminate with /* and */, respectively. Packaging Objects (refer to Listing 1, line 1) Even though Java language allows the programmer to choose the names for their objects, there may be times where the programmer ends up using the same name to express two different concepts, causing something called name collision. Java language resolves name collisions with packages, or Java packages. A Java package is a mechanism for providing a namespace, which is an encapsulated area where names are unique, however shown publicly as the same. To define a package in code, the programmer uses the keyword

followed by a legal package name, and then terminated with a semi-colon. A programmer is not forced to specify a package if all of their objects have unique class names and reside in the default package.

Often package names, such as above, are separated by periods.

is the organization type, such as com, org, net, etc.

is the name of the organization's domain, such as sun, ibm, etc.

is the name of the application, abbreviated.

is the name of the component. Import Statements (refer to Listing 1, line 2) An import statement allows the Java compiler to know where your classes are coming from; what location to find them in.

The programmer specifies what to import using the keyword,

, followed by the class including its package, and then terminated with a semi-colon. If the programmer wishes to import all classes within a package, they would put

after the package name.

Class Declaration (refer to Listing 1, lines 3-10) In order for Java to know an object, the programmer must declare a class. A class is like the template, or the default shape, for an object. A class defines an object's basic structure, and at run time, the application creates an instance of the object. A instance is the specific realization of the object, and so while, say, there are types of beverages, its instance would be a specific beverage. A class defines the structure of a certain thing, while the object is an instance of that thing. With

, there are several values that can be put here, but its general value is

. Example of a class declaration:

[linearprogramming]

Principles of Object-Oriented Programming

The benefits of using O.P.P. programming is its defining principles: encapsulation, inheritance, and polymorphism. Encapsulation Objects are self-contained entities, meaning they are not dependent. Hiding is a term often used to describe this self-contained, "keeping-to-oneself" personality. Objects maintain a boundary between its state and behavior, and the outside world. A common boundary is public/private access. Like objects in the real world, objects used in computer programming have various types of relationships with different categories of objects in the applications that use them. On Java platform, access specifiers are used to vary the nature of object relationships from public access to private access, where public access is wide open and publicly available to all subclasses, and private access is private and only available to the parent class. The public and private boundary enforces the object-oriented principle of encapsulation. On Java platform, a programmer can vary the strength of this boundary on an object-to-object basis, depending on a system of trust. Inheritance In standard structuring, it is common to copy a structure, give it a new name, and add or modify the attributes that will make the new entity different from its original source. However, this approach will eventually generate a great deal of duplicated code, which can create maintenance issues. Object-oriented programming introduces the concept of inheritance, where the specialized objects (child)--without additional code--can copy the attributes and behavior of the source objects (parent) it specializes. If some of the attributes or behaviors need to change, the programmer can simply override them, where a programmer only changes what they need to change in order to create a specialized object. Suppose a programmer was writing a human-resources application and wanted to use the

object as the basis for a new object called

. Since

would be the child, its attributes will match its parent,

, with additional attributes to make it specialized: Taxpayer identification number Hire date Salary Inheritance makes it simple to create the

class of the object without having to copy all of the

code manually. Polymorphism Polymorphism is when objects that belong to the same hierarchy are sent the same message (or when told to do the same thing), and have the ability to manifest that behavior differently. To use polymorphism in a business-application context, return to the

object and its ability to format its attributes into a

. However, polymorphism makes it possible for

to represent its attributes in a variety of ways, depending on the type of

it is.

[linearprogramming]

Matrices, Coefficient Matrices, and Augmented Matrices

The information in science, business, and mathematics is often organized into rows and columns to form rectangular arrays called matrices, the plural of matrix. Matrices are not simply a notational tool for solving systems of equations; they can be viewed as mathematical objects in their own right, with their rich and important theory associated with them that has a multitude of practical applications. It is the study of matrices and related topics that forms the subject linear algebra.

This matrix has 3 rows:

This matrix also has 4 columns:

A matrix, like the one above, that has 3 rows and 4 columns is said to be a 3 x 4 matrix. More generally, a matrix with m rows and n columns is called a m x n matrix of A.

The notation of ai,j represents the number in both row i and column j. The rows are usually called R₁, R₂, R₃, ..., Rm

The columns are usually called C₁, C₂, C₃, ..., Cn

Coefficient Matrices m x n rows are similar to systems of linear equations. Suppose a given system of linear equations was used:

Then the coefficient matrix, A, is a m x n matrix of the above system.

Augmented Matrices An augmented matrix is the same as a coefficient matrix, however made bigger, or augmented, by adding one more column for bn. This notation is represented as a m x (n + 1) matrix, where the extra column is usually divided from the other columns. Suppose a given system of linear equations was used:

Then the augmented matrix, A, is a m x (n + 1) matrix of the above system.

The following is an example of a coefficient and augmented matrix for the system of linear equations below. x - y + z = 1 2x + 3y - z = 2 Coefficient matrix:

Augmented matrix:

[linearprogramming]

Object-Oriented Programming Concepts

The Java language is mostly object-oriented. With object-oriented languages, it combines data and program instructions into objects. An object is a self-contained entity that contains attributes and behavior, nothing more. C language, a structured program, follows a very different paradigm than object-oriented programs. The structured programs are highly data-oriented, meaning it will have data structures on one hand, and then program instructions that act on that data on the other hand. In structured programs, the data structures with fields (this is the attributes) passes around this structure to all of the progress logic that acts on it. (this is the behavior) In object-oriented programs, the data structure with fields (attributes) and program logic (behavior) are combined. When attributes and behavior are combined, the combination can occur at different levels of granularity, where some objects are fine-grained, meaning more objects hold less data; or some objects are course-grained, meaning few objects hold a lot of data. Parent and Child Objects A parent object is one that is the structural basis for deriving more complex child objects. A child object looks like its parent object but is more specialized. Object-oriented programming allows the common attributes and behavior of the parent object to be reused and added to its child objects that differ. This is called inheritance. Object Communication and Coordination Objects talk to other objects by sending messages, called method calls in Java Language. In an object-oriented application, program code coordinates activities among objects to preform tasks within the context of the given application's domain. The 

Object Using an individual on a common application development by being represented by a 

object. For this 

object, the two primary elements it needs are attributes and behavior. In regards to attributes, the 

object can have many, but the common ones include:

In regards to behavior, an actual person can do many things. However, object behaviors usually relate to a kind of application context. In a business-application context, usually the programmer would want to ask the 

object, "What is your age?" In response, 

object would tell the value of its 

attribute. More complex logic could be hidden inside of the 

object, but suppose this 

object has the behavior of answering these questions:

State and

State is an important concept in object-oriented programming. An object's state is represented at any moment in time by the value of its attributes. In regards to 

object, its state is defined by its attributes. If desired a list of several attributes from the 

object, it can be done using a 

class. With the concepts of state and string, it allows the programmer to say to the 

object: "Tell me who you are by giving me a list, or

, of your attributes."

[linearprogramming]

Introduction to Linear Equations and Systems of Linear Equations

The Definition of a Linear Equation A linear equation in n variables, x₁, x₂, x₃, ..., xn, is an equation of the form: a₁x₁ + a₂x₂ + a₃x₃ + ... + anxn = b This equation is known as a linear equation of n unknowns, where a₁, ..., an, and b are constants, and a₁, ..., an are the coefficients of the equation. A linear equation does not involve any products, roots of variables, or arguments of trigonometric, logarithmic, or exponential functions. A linear equation with two unknowns represents a two dimensional line in a rectangular xy-coordinate system. A linear equation with three unknowns represents a three dimensional plane in a rectangular xyz-coordinate system. The Definition of a System of Linear Equations A system of m linear equations with n unknowns is a list of m linear equations, with each equation having the same set of n unknowns. x - y + z = 1 2x + 3y - z = 2 This is an example of a system of 2 equations with 3 unknowns. u + v = 1 2u + v = 3 u + 2v = 3 This is an example of a system of 3 equations with 2 unknowns. In general:

This is the general example of a system of m equations with n unknowns. If b = 0, it would be a special case called homogeneous linear equations. A linear system whose equations are all homogeneous must be consistent, that is, have at least one solution. The solution set for homogeneous linear systems is called a trivial solution. Linear systems in two unknowns arise in connection with intersections of lines. In general, a line system is consistent if it has at least one solution and inconsistent if it has no solutions. Therefore, a consistent linear system of two equations in two unknowns has either one solution or infinitely many solutions; there are no other possibilities. Solving a system of linear equations will either result in one consistent solution: only making the system intersect once on a Cartesian plane; an infinite amount of solutions: making the system overlap each other on a Cartesian plane; or zero solutions: making the system inconsistent and parallel to each other on a Cartesian plane. Linear systems in three unknowns arise in connection with intersections of planes. The same rules are applied to all linear systems of n equations in n unknowns: there can either be one solution, no solution, or an infinitely many solutions. In regards to linear system solution sets, a linear system in 2 unknowns has a solution set called ordered pair, a linear system in 3 unknowns has a solution set called ordered triple, and a linear system in n unknowns has a solution set called ordered n-tuple. If we assign an arbitrary value, called a parameter, to one of the variables, this allows us to express the solution by making the equations parametric equations. With parameters, we can obtain specific numerical solutions by substituting numerical values for the parameter. This tells us that a linear system with parametric equations has an infinitely many solutions. If a linear system has infinitely many solutions, then its general solution is a set of parametric equations where all solutions can be obtained by numerical subsitution to the parameters.

EXAMPLE 1.1. Solve the equation: 2x + 3y = 6 To solve an equation, we choose which variable to be solved. In this case, it wouldn't matter which variable we choose. Next, we use elementary operations to balance each side of the equation so that the chosen variable is isolated on one of the sides of the equation. Solving for x, subtracting 3y from both sides: 2x + 3y = 6 2x = 6 - 3y Isolating x, dividing both sides by 2. 2x = 6 - 3y 2x/2 = 6/2 - 3y/2 x = 3 - 3y/2 Although we solved for x, we cannot solve for y; substituting x's value into the original equation will make the equation equal 6 on both sides, meaning y is an arbitrary variable. Therefore, there are an infinite many solutions. EXAMPLE 1.2. Solve the system of linear equations with two unknowns: 2x + 3y = 5 3x + 2y = 7 To find all solutions to a system of linear equations with two unknowns, the standard solution is to choose one variable to eliminate, and manipulate one or more of the equations until that chosen variables' coefficients can eliminate that chosen variable when subtracting the system of equations. Eliminating x, multiplying the first equation by 3, the second equation by 2: 3(2x + 3y = 5) 2(3x + 2y = 7) 6x + 9y = 15 6x + 4y = 14 Subtracting the system of linear equations with two unknowns: 6x + 9y = 15 6x + 4y = 14 0 + 5y = 1 Difference: 5y = 1 Solving for y, dividing both sides by 5: 5y = 1 5y/5 = 1/5 y = 1/5 Now that we have found y's solution, and it is a constant, we can solve for the last variable, x, using one of the original equations in the system. Substituting y = 1/5 in the first equation: 2x + 3y = 5 2x + 3(1/5) = 5 Solving for x, subtracting 3(1/5) from both sides of the equation, dividing both sides by 2: 2x + 3(1/5) = 5 2x + 3/5 = 5 2x = 5 - 3/5 x = 5/2 - 3/10 = 11/5 Therefore, the solution to the system of linear equations with two unknowns is (x,y) = (11/5,1/5). EXAMPLE 1.3. Solve the system of linear equations with three unknowns: x + y + z = 1 x - y + z = 0 To find all solutions to a system of linear equations with three unknowns, the standard solution is to choose two variables to eliminate, and manipulate one or more of the equations until those chosen variables' coefficients can eliminate those chosen variables when subtracting the system of equations. Eliminating x and z, no need for equation manipulation: x + y + z = 1 x - y + z = 0 0 + 2y + 0 = 1 Difference: 2y = 1 Solving for y, dividing both sides by 2: 2y = 1 y = 1/2 Now that we have found y's solution, and it is a constant, we can solve for a next variable, x or z, using one of the original equations in the system. Solving for x, substituting y = 1/2 in the second equation: x - y + z = 0 x - (1/2) + z = 0 Solving for x, subtracting z from both sides of the equation, adding 1/2 to both sides: x - (1/2) + z = 0 x = -z + 1/2 Although we solved for x and y, we cannot solve for z; substituting x's value and y's value into one of the original equations will make the equation equal to its constant on both sides, meaning z is an arbitrary variable. Therefore, there are an infinite many solutions.