javajiggle.com

I’ve recently had a discussion with a colleague on whether it is a good practice using Math.pow() to square a number?

My friend’s argument is that Math.pow() is designed to raise a number to a partial power, such as 7^2.5.  Therefore it will use complicated and inefficient math raising a number to 2.0 instead of more efficient way of simply x*x.  He advocated implementing and using a square function below instead of using Math,pow( x, 2.0);

So the question remains:

A) public static double square( double x ){ return x * x; }

or

B) Math.pow( x, 2.0 );

?????

Please give us your input!

———————————————

pow

public static double pow(double a,
                         double b)

Returns the value of the first argument raised to the power of the second argument. Special cases:

• If the second argument is positive or negative zero, then the result is 1.0.
• If the second argument is 1.0, then the result is the same as the first argument.
• If the second argument is NaN, then the result is NaN.
• If the first argument is NaN and the second argument is nonzero, then the result is NaN.
• If
  • the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or
  • the absolute value of the first argument is less than 1 and the second argument is negative infinity,

  then the result is positive infinity.

• If
  • the absolute value of the first argument is greater than 1 and the second argument is negative infinity, or
  • the absolute value of the first argument is less than 1 and the second argument is positive infinity,

  then the result is positive zero.

• If the absolute value of the first argument equals 1 and the second argument is infinite, then the result is NaN.
• If
  • the first argument is positive zero and the second argument is greater than zero, or
  • the first argument is positive infinity and the second argument is less than zero,

  then the result is positive zero.

• If
  • the first argument is positive zero and the second argument is less than zero, or
  • the first argument is positive infinity and the second argument is greater than zero,

  then the result is positive infinity.

• If
  • the first argument is negative zero and the second argument is greater than zero but not a finite odd integer, or
  • the first argument is negative infinity and the second argument is less than zero but not a finite odd integer,

  then the result is positive zero.

• If
  • the first argument is negative zero and the second argument is a positive finite odd integer, or
  • the first argument is negative infinity and the second argument is a negative finite odd integer,

  then the result is negative zero.

• If
  • the first argument is negative zero and the second argument is less than zero but not a finite odd integer, or
  • the first argument is negative infinity and the second argument is greater than zero but not a finite odd integer,

  then the result is positive infinity.

• If
  • the first argument is negative zero and the second argument is a negative finite odd integer, or
  • the first argument is negative infinity and the second argument is a positive finite odd integer,

  then the result is negative infinity.

• If the first argument is finite and less than zero
  • if the second argument is a finite even integer, the result is equal to the result of raising the absolute value of the first argument to the power of the second argument
  • if the second argument is a finite odd integer, the result is equal to the negative of the result of raising the absolute value of the first argument to the power of the second argument
  • if the second argument is finite and not an integer, then the result is NaN.
• If both arguments are integers, then the result is exactly equal to the mathematical result of raising the first argument to the power of the second argument if that result can in fact be represented exactly as a double value.

(In the foregoing descriptions, a floating-point value is considered to be an integer if and only if it is finite and a fixed point of the method ceil or, equivalently, a fixed point of the method floor. A value is a fixed point of a one-argument method if and only if the result of applying the method to the value is equal to the value.)

The computed result must be within 1 ulp of the exact result. Results must be semi-monotonic.

Parameters:

a – the base.

b – the exponent.

Returns:

the value ab.

public class hello_world {

public static void main( String [] arg ){

System.out.println(“Hello World”);

}

}

Know Your Logic

Many are not aware of the optimized logic statements. This could lead to the logic errors. In Java there are two AND and two OR statements. One is optimized and one is not. The optimized operator will not evaluate a second (right) statement if the final outcome is clear from evaluation of the first (left) statement.

For example, A || B, if A is TRUE the result of the statement is TRUE regardless of what B evaluates to. Therefore B will not be evaluated. That is an optimized OR statement, if you require that both sides of the operator evaluated, use unoptimized operator |. That would be, A | B, so even if A is true, B will be evaluated regardless.

The AND operator works in a similar fashion. For example, A && B, if A evaluates to FALSE the result of the statement will be FALSE regardless of what B evaluates to. Therefore B will not be evaluated. Again, if you require both sides of the expression evaluated, use unoptimized & operator.

That would be, A & B, so event if A evaluates to false, B will be evaluated regardless.

See this example:

class test {

public static boolean checkSomething( String from ){

System.out.println(“checkSomething() from-> ” + from );

return true;

}

public static void main( String [] arg ){

if( true || checkSomething(” || “) )

System.out.println(” || test”);

if( true | checkSomething( ” | “) )

System.out.println(” | test”);

if( false && checkSomething( ” && “) )

System.out.println(” && test” );

if( false & checkSomething( ” & “) )

System.out.println(” & test” );

}

}

Output:

|| test

checkSomething() from-> |

| test

checkSomething() from-> &

You can see, that checkSomething(String) is evaluated only with unoptimized operators.

Know your logic! Code bug free!

I know you want to, give us a jiggle

I want to open this blog by discussing a few techniques of launching a java server and it’s side kick rmi-registry. It is often that we (java developers) are faced with a requirement for launching a server and creating a failsafe mechanism. To keep it short I will focus on the Unix based platforms. If there is strong interest I will write an article on how to achieve the same thing on windows.

Before I get into details, I want to make it clear what it is that we trying to achieve here. Our goal is to launch a java program that acts as a server of some capacity. To be more specific, let’s assume that we are launching an RMI based server. In other words, we want to launch a java server that will run in the background waiting for requests. Since we are running an RMI based server, we need to launch an rmiregistry along with it. For those not familiar, rmiregistry is a separate executable usually provided along with a JDK.

Option 1. Launch a server with “&” at the end of the command string.

java myServer &

This actually would not work! When launched this way the process runs in the background but is still associated with the tty (terminal) that launched it. This means that when you exit a terminal by logging off, the terminal will send a signal to stop the jvm running your program. Needless to say there is no failsafe mechanism here.

Option 2. Use a “nohup” command.

nohup java myServer &

Nohup command is a unix command that runs a process and suspends a signal used by the terminal to stop all of the programs associated with it. This allows the program to run even after a user logged off. What happens if the jvm or the rmiregistry crashes? Once the process is kicked off using a nohup command and you log off the system, there is nothing you can do if the process decides to retire other than logging back in and manually restarting the process.

Man page for nohup.

Option 3. Use a “cron job” to test if the process is running, if not restart it.

Cron is a process dedicated to scheduling jobs. Cron can be configured to run a process every 5 minutes or so. This process will check if the server is running by trying to connect to it. If it is not running cron restarts it. The syntax is relatively simple. However, this does require that you implement a whole separate program or a complicated shell script that will check the server status and restart it if necessary. I will not get into a cron usage here and will instead jump ahead to the next solution which I believe is a bit more elegant.

Man page for cron.

Option 4. Use an “init daemon” to start a java server and an rmi-registry.

The Init daemon is an OS built-in process perfectly suited to launch any server application, including a java server and an RMI registry. There are three basic features that the init daemon offers:

1. The init daemon will run your process in the background.
2. The init daemon will restart your server if the server was restarted.
3. The init daemon will monitor your process and re-spawn it if it crashed.
4. Init daemon is very easy to configure.

Unfortunately init is often overlooked by many java developers not familiar with unix technologies.
Note: The example below was tested on Sun Solaris. Other unix based OSs have similar technology in place, however the syntax may vary.

The init daemon is configured using an /etc/inittab file. Before we configure the init daemon, we need to create 4 launch scripts, two for the server and two for the rmi-registry. Why two scripts? Because whenever the process is launched by the init daemon it runs in the super user mode. Running in a super user mode is highly undesirable and is often prohibited by the administrator. For that purpose, we have two scripts, first will switch users and second will actually launch your server. Don’t worry; these scripts are one line each!

1. Switch users script for the rmi-registry (/usr/bin/su_for_rmiregistry):
   #!/bin/sh
   exec su –s pupsik –c “exec /home/pupsik/runRMI”

1. Switch users script for the java server. (/usr/bin/su_for_javaserver)
   #!/bin/sh
   exec su –s pupsik –c “exec /home/pupsik/serverLaunchScript”
2. Launch an RMI registry. (/home/pupsik/runRMI).
   #!/bin/sh
   exec <jre_path>/bin/rmiregistry
   
   
3. Launch a java server. (/home/pupsik/serverLaunchScript).
   #!/bin/sh
   exec <jre_path>/bin/java –cp <classpath> myServer.jar <server class>

We used two unix commands above: SU (switch user) that switched execution from a default super user to pupsik; Exec that launched a command specified in the argument but did not create a new process and so that process id stays the same. The text, heap and stack are replaced by the new program.
Man page for su. Man page for exec.

It is time to configure the init daemon. You will need super user access to edit /etc/inittab that configures the init daemon. Add two lines used to launch scripts 1 and 2 as follows:

mm:234:respawn:/usr/bin/su_for_rmiregistry
mc:234:respawn:/usr/bin/su_for_javaserver

This tells the init daemon to launch this process during system run levels 2, 3 and 4. Respawn these processes if they crash. Now tell the init daemon to reload the inittab file by typing init –q. Check to see if your process is running using a ps command as follows:

ps –ef | grep pupsik.

For the ultimate test, use a kill command to terminate your java process. Do the PS command again, the process should be respawned automatically by the init daemon. (Make sure a new process has a different process id than the one you just killed.)

I’m sure you have questions. Let me know.

Man page for the init.

—————————————–

I thought I should add this comment to the article:

Armin that’s a good point. You are right, that if the RMI registry crashes, the java servers need to be reset.

This can be acomplished by launching the rmi registry and the java server(s) in one script.

1. The idea is that the rmi sever will be launched first.
2. The java rmi server will be launched next.
3. The launch script will than block using a wait command to check if rmi registry terminates.
4. If wait unblocks, that means that rmi registry terminated. When this happens, kill the java server(s) and repeat steps 1-3.

Below is a sample script. You can tested it by killing the rmi registry and see it respawn both rmi registry and a java server.

Here is a sample: (Note: this should work but has not been tested for syntax)

#!/bin/sh

#kick off the rmi registry
./rmiRegistry &

#store the PID of the RMI registry
rmiRegistryPID=$!
echo Started RMI registry with PID= $rmiRegistryPID”

#kick off the java server in a script
./startJavaServer &

#store PID for java server
javaServerPID=$!
echo Started Java server with PID= $javaServerPID”

While [ 1 ]
do

wait $rmiRegistryPID
echo “RMI Registry (PID=$rmiRegistryPID ) terminated…”
#kill -9 $javaServerPID
kill -TERM $javaServerPID
echo “Terminated Java Server”

./rmiRegistry &
rmiRegistryPID=$!
echo “Respawned RMI registry with PID= $rmiRegistryPID”

./startJavaServer &
javaServerPID=$!
echo “Respawned Java server with PID= $javaServerPID”

done

———————————————

startJavaServer script could look something like that:

#!/bin/sh
done=0
while [ “$done” -eq 0 ]
do

java &
jvmPID=$!
trap “kill -TERM $jvmPID;done=1? TERM
wait $jvmPID
echo “respawning JVM”

done
kill -TERM $jvmPID