public class EvenPrinter extends Thread {

	public void run(){
		// what does this thread
		// aimlessly print out even numbers
		for(int i=0; i<Integer.MAX_VALUE; i+=2){
			System.out.println(i);
			try{
				// let it sleep for 1.5 seconds
				Thread.sleep(1500);
			}
			catch(InterruptedException ie){}
		}
	}

}

public class OddPrinter implements Runnable {

	public void run() {
		// what does this thread
		// aimlessly print out odd numbers
		for(int i=1; i<Integer.MAX_VALUE; i+=2){
			System.out.println(i);
			try{
				// let it sleep for 1.5 seconds
				Thread.sleep(1500);
			}
			catch(InterruptedException ie){}
		}
	}

}

public class PrinterTest {

	public static void main(String[] args){
		// create our thread
		EvenPrinter evens = new EvenPrinter();
		// and start it
		evens.start();
		// create our new Runnable
                OddPrinter op = new OddPrinter();
                // use it to create a new Thread
                Thread odds = new Thread(op);
                // start it
                odds.start();
	}

}

Now after running PrinterText you should be able to see all the number starting from 0 in the correct order printed on the console.

In case we’d rather like to have first the even numbers printed and then the odds, we have a solution for that too and that’s the method join() inherited from Thread. The thread calling that method will “join” the main thread which is the highest in the threads’ hierarchy and all other threads are run inside the main thread and that will pull its execution first.

public class PrinterTest {

	public static void main(String[] args){
		// create our thread
		EvenPrinter evens = new EvenPrinter();
		// and start it
		evens.start();
		try {
			// join this thread to the main thread
			evens.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		// create our new Runnable
                OddPrinter op = new OddPrinter();
                // use it to create a new Thread
                Thread odds = new Thread(op);
                // start it
                odds.start();
	}

}

Now if you have the patience to wait for all even numbers to be printed out you’ll see the odds coming afterward… Or you could always reduce the interval by replacing Integer.MAX_VALUE by a smaller integer ;-)

Java is the first mainstream language that implements threading explicitly instead of leaving that job to the operating system. A Java program can have many threads as all threads have been taken care of by the class java.lang.Thread. All threads run concurrently and asynchronously, but mostly there is the option to synchronize them.

As with many other things in Java with threads there isn’t only one way of creating them. We’re provided with two options:

1. Extending the class Thread

One of the shortest ways to creating your threads is extending the Thread class and overwriting the run() function. Let’s have a look at the following example – a class that will print out all the even number, of course only in the limits of Java’s simple type int.

public class EvenPrinter extends Thread {	

	public void run(){
		// what does this thread
		// aimlessly print out even numbers
		for(int i=0; i<Integer.MAX_VALUE; i+=2){
			System.out.println(i);
		}
	}

}

public class PrinterTest {

	public static void main(String[] args){
		// create our thread
		EvenPrinter evens = new EvenPrinter();
		// and start it
		evens.start();
	}

}

In the main method of the PrinterTest class you can see how we initialize our thread and put it to action.

Let’s now have a look at the option we have to create a thread in Java:

2. Implementing the interface Runnable

If we go for this option, our class will have to implement the interface Runnable and we’ll need to implement the function run(). Further in our program we’d need to create a new instance of our class and then create a new thread, passing our runnable object to the constructor.

public class OddPrinter implements Runnable {

	public void run() {
		// what does this thread
		// aimlessly print out odd numbers
		for(int i=1; i<Integer.MAX_VALUE; i+=2){
			System.out.println(i);
		}
	}

}

public class PrinterTest {

	public static void main(String[] args){
		// create our thread
		EvenPrinter evens = new EvenPrinter();
		// and start it
		evens.start();

		// create our new Runnable
                OddPrinter op = new OddPrinter();
                // use it to create a new Thread
                Thread odds = new Thread(op);
                // start it
                odds.start();
	}

}

Now if you’ve accidentally tried to run the last code of PrinterTest you’ve realized that both threads evens as well as odds are running very fast and slightly chaotic. Don’t worry there’s a remedy for that too and if you’re in the mood to follow, go to Synchronizing threads in Java.

• 0:18 – S compatible plot symbols
• 19:25 – further R plot symbols
• 26:31 – unused – a value from this range will be ignored
• 32:127 – ASCII characters

For more detailed information please check the manual for the points function.

SELECT * FROM `tablename` WHERE `column_a`=’x’ AND `col_b`=’y’

I already knew how to use the extract function (using the []) to get a part of matrix or vector by matching single logical condition on all matrix elements. And that in two ways – more about selecting elements and finding indexes of elements see the post about how to select elements or find their index in a vector or a matrix in R.

Let’s use the same example matrix:

x<-matrix( c(.007, 0.012, .022, 0.000, .005, 0.112, .027, 1.000, .037, .001, .061, .055), nrow=4, ncol=3, byrow=TRUE )
which (again) looks like that:

[,1]      [,2]    [,3]
[1,] 0.007   0.012  0.022
[2,] 0.000   0.005  0.112
[3,] 0.027   1.000  0.037
[4,] 0.001   0.061  0.055

Say, we're only interested in those rows of the matrix with values in the 2nd and in the 3rd column greater than 0.05. Well that's fairly easy and we can also do it in both ways - using simple logical expression or using the which() function.
Using the first:


x[ x[,2]>0.05 && x[,3]>0.05 ]


But if we need the row and column index of the matrix (or simply the index if extracting from vector) of the matches we go the second way - using which():

indx<-which(x[,2]>0.05 && x[,3]>0.05)
# indx[ ,1] contains the row index of the matches
# indx[ ,2] contains the column index of the matches

# extract the desired elements from the matrix
x[indx]


And of course, no matter which way you use for your needs you can alternatively have longer and more complicated logical expressions.

x <- matrix( c(.007, 0.012, .022, 0.000, .005, 0.112, .027, 1.000, .037, .001, .061, .055), nrow=4, ncol=3, byrow=TRUE )

which looks like that:

       [,1]         [,2]        [,3]
[1,] 0.007     0.012     0.022
[2,] 0.000     0.005     0.112
[3,] 0.027     1.000     0.037
[4,] 0.001     0.061     0.055

1. You can use a logical condition to extract elements of vector or matrix. In the following we’d like to know which elements in our matrix x are greater than 0.05

y <- x>0.05
y

The logical expression x > 0.05 will deliver a matrix (as x in our case is a matrix) with the same dimensions as x and which contains values of boolean type:
       [,1]     [,2]     [,3]
[1,] FALSE FALSE FALSE
[2,] FALSE FALSE TRUE
[3,] FALSE TRUE FALSE
[4,] FALSE TRUE TRUE

and when you match the matrix x with the logical result matrix y:

x[y]

you get a vector with the values matching our logical expression x > 0.05:
[1] 1.000 0.061 0.112 0.055

2. Alternatively or for other purposes you may also use the which() function.

y <- which(x>0.05)
y

[1] 7 8 10 12
As you can see it returns the index(es) of the match(es). And if you’re searching in a matrix as in our case, the result will be a vector of indexes, as the matrix is automatically converted to vector by R. That’s made in R’s default way by concatenating the columns and it leads to the conclusion that which(x) == which(as.vector(x)). If you however would rather like to know the row and colum index, you’ll need to set the function’s argument arr.in to TRUE.

y <- which(x>0.05, arr.in=TRUE)
y
row  col
[1,] 3  2
[2,] 4  2
[3,] 2  3
[4,] 4  3

Now that’s what I’d call a better result. And of course you can use the which function to extract elements of a vector or a matrix.

x[y]

is the same as the shorter and memory saving way:

x[which(x>0.05)]