Running Matlab code from java code

Question

Ok so I need to make a java gui interface to run Matlab code. After a lot of search I am aware of three approaches,the com.mathworks.jmi package, JNI and i/o streams. So as far as the first approach I cannot find that package nowhereto downlaod, so please if anyone knows where to find it, or why I cannot find it... As far as the second and third approach, I need this to run on both linux and windows so JNI is the only way. So first of all if someone has another approach to suggest, I would like to hear! So I have found code to do this but it is not working and the problem is that there is c code in all this, and my c knowledge is not good at all, so as you have probably understand this is more like a c problem than java, but I'm not completely sure. Anyway I'm posting all the code I use, then the commands I used to compile it and at last the problem.
Engine.java
package MatlabNativeInterface;
import java.io.*;
* <b>Java Engine for Matlab via Java Native Interface (JNI)</b><br>
* This class demonstrates how to call Matlab from a Java program via
* JNI, thereby employing Matlab as the computation engine.
* The Matlab engine operates by running in the background as a separate
* process from your own program.
* <p>
* Date: 04.04.03
* <p>
* Copyright (c) 2003 Andreas Klimke, Universit&#65533;t Stuttgart
* <p>
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
* <p>
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
* <p>
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
* @author W. Andreas Klimke, University of Stuttgart
*         ([email protected])
* @version 0.1
public class Engine {
     * Calls the function <code>engOpen</code> of Matlab's C Engine library.
     * Excerpts from the Matlab documentation:
     * "On UNIX systems, if startcmd is NULL or the empty string,
     * <code>engOpen</code> starts MATLAB on the current host using the
     * command <code>matlab</code>. If startcmd is a hostname, <code>engOpen
     * </code> starts MATLAB on the designated host by embedding the specified
     * hostname string into the larger string:
     * <code>rsh hostname \"/bin/csh -c 'setenv DISPLAY\ hostname:0; matlab'\"
     * </code>. If startcmd is any other string (has white space in it, or
     * nonalphanumeric characters), the string is executed literally to start
     * MATLAB. On Windows, the startcmd string must be NULL."<br>     
     * See the Matlab documentation, chapter "External Interfaces/API
     * Reference/C Engine Functions" for further information.
     * @param startcmd The start command string.
     * @throws IOException Thrown if starting the process was not successful.
  public native void open(String startcmd) throws IOException;
      * Calls the function <code>engClose</code> of Matlab's C Engine
      * library.     This routine allows you to quit a MATLAB engine session.
      * @throws IOException Thrown if Matlab could not be closed.
     public native void close() throws IOException;
     * Calls the function <code>engEvalString</code> of Matlab's C Engine
     * library. Evaluates the expression contained in string for the MATLAB
     * engine session previously started by <code>open</code>.
     * See the Matlab documentation, chapter "External Interfaces/API
     * Reference/C Engine Functions" for further information.
     * @param str Expression to be evaluated.
     * @throws IOException Thrown if data could not be sent to Matlab. This
     *                     may happen if Matlab is no longer running.
     * @see #open
  public native void evalString(String str) throws IOException;
      *  Reads a maximum of <code>numberOfChars</code> characters from
      * the Matlab output buffer and returns the result as String.<br>
      * If the number of available characters exceeds <code>numberOfChars</code>,
      * the additional data is discarded. The Matlab process must be opended
      * previously with <code>open()</code>.<br>
      * @return String containing the Matlab output.
      * @see #open
      * @throws IOException Thrown if data could not be received. This may
      *                     happen if Matlab is no longer running.
  public native String getOutputString(int numberOfChars);
      * Initialize the native shared library.
  static {
         System.loadLibrary("Engine");//I have changed this
     //System.loadLibrary("engineJavaMatlab");
     System.err.println("Native Matlab shared library loaded.");
}Engine.c
#include <jni.h>
#include "MatlabNativeInterface_Engine.h"
#include <stdio.h>
#include "engine.h"
#define DEFAULT_BUFFERSIZE 65536
Engine* ep;
char outputBuffer[DEFAULT_BUFFERSIZE];
JNIEXPORT void JNICALL
Java_MatlabNativeInterface_Engine_open(JNIEnv *env, jobject obj, const jstring startcmd) {
  const char *c_string = (*env)->GetStringUTFChars(env, startcmd, 0);
  if (!(ep = engOpen(c_string))) {
    jclass exception;
    (*env)->ReleaseStringUTFChars(env, startcmd, c_string);
    exception = (*env)->FindClass(env, "java/io/IOException");
    if (exception == 0) return;
    (*env)->ThrowNew(env, exception, "Opening Matlab failed.");
    return;
  (*env)->ReleaseStringUTFChars(env, startcmd, c_string);
     /* indicate that output should not be discarded but stored in */
     /* outputBuffer */
  engOutputBuffer(ep, outputBuffer, DEFAULT_BUFFERSIZE);
JNIEXPORT void JNICALL
Java_MatlabNativeInterface_Engine_close(JNIEnv *env, jobject obj) {
     if (engClose(ep) == 1) {
       jclass exception;
    exception = (*env)->FindClass(env, "java/io/IOException");
    if (exception == 0) return;
    (*env)->ThrowNew(env, exception, "Closing Matlab failed.");
    return;
JNIEXPORT void JNICALL
Java_MatlabNativeInterface_Engine_evalString(JNIEnv *env, jobject obj, const jstring j_string) {
  const char *c_string;
     c_string = (*env)->GetStringUTFChars(env, j_string, 0);
  if (engEvalString(ep, c_string) != 0) {
       jclass exception;
    exception = (*env)->FindClass(env, "java/io/IOException");
    if (exception == 0) return;
    (*env)->ThrowNew(env, exception, "Error while sending/receiving data.");
  (*env)->ReleaseStringUTFChars(env, j_string, c_string);
JNIEXPORT jstring JNICALL
Java_MatlabNativeInterface_Engine_getOutputString(JNIEnv *env, jobject obj, jint numberOfChars) {
  char *c_string;
     jstring j_string;
     if (numberOfChars > DEFAULT_BUFFERSIZE) {
          numberOfChars = DEFAULT_BUFFERSIZE;
  c_string = (char *) malloc ( sizeof(char)*(numberOfChars+1) );
     c_string[numberOfChars] = 0;
  strncpy(c_string, outputBuffer, numberOfChars);
     j_string = (*env)->NewStringUTF(env, c_string);
     free(c_string);
  return j_string;
}MatlabNativeInterface_Engine.h (as produced by javah)
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class MatlabNativeInterface_Engine */
#ifndef _Included_MatlabNativeInterface_Engine
#define _Included_MatlabNativeInterface_Engine
#ifdef __cplusplus
extern "C" {
#endif
* Class:     MatlabNativeInterface_Engine
* Method:    open
* Signature: (Ljava/lang/String;)V
JNIEXPORT void JNICALL Java_MatlabNativeInterface_Engine_open
  (JNIEnv *, jobject, jstring);
* Class:     MatlabNativeInterface_Engine
* Method:    close
* Signature: ()V
JNIEXPORT void JNICALL Java_MatlabNativeInterface_Engine_close
  (JNIEnv *, jobject);
* Class:     MatlabNativeInterface_Engine
* Method:    evalString
* Signature: (Ljava/lang/String;)V
JNIEXPORT void JNICALL Java_MatlabNativeInterface_Engine_evalString
  (JNIEnv *, jobject, jstring);
* Class:     MatlabNativeInterface_Engine
* Method:    getOutputString
* Signature: (I)Ljava/lang/String;
JNIEXPORT jstring JNICALL Java_MatlabNativeInterface_Engine_getOutputString
  (JNIEnv *, jobject, jint);
#ifdef __cplusplus
#endif
#endifand a Main.java
import MatlabNativeInterface.*;
import java.io.*;
* Demonstration program for connecting Java with Matlab using the Java
* Native Interface (JNI). Wrapper functions access Matlab via Matlab's
* native C Engine library.
public class Main {
     public static void main(String[] args) {
          Engine engine = new MatlabNativeInterface.Engine();
          try {
               // Matlab start command:
               engine.open("matlab -nosplash -nojvm");
               // Display output:
               System.out.println(engine.getOutputString(500));
      // Example: Solve the system of linear equations Ax = f with
               // Matlab's Preconditioned Conjugate Gradients method.
               engine.evalString("A = gallery('lehmer',10);");  // Define Matrix A
               engine.evalString("f = ones(10,1);");            // Define vector f
               engine.evalString("pcg(A,f,1e-5)");              // Compute x
               // Retrieve output:
               System.out.println(engine.getOutputString(500));
               // Close the Matlab session:
               engine.close();
          catch (Exception e) {
               e.printStackTrace();
}so I compile them with:
javac -d classes @files.txt
javah -classpath classes MatlabNativeInterface.Engine
cc -shared -I/usr/java/jdk1.6.0_06/include/ -I/usr/java/jdk1.6.0_06/include/linux/ -I/usr/local/share/matlab7.6/extern/include/ Engine.c -o libEngine.soso everything gets compiled well and then I run Main:
/javas/classes/_>mv libEngine.so classes/
/javas/classes/_>cd classes/
/javas/classes/_>java -Djava.library.path=. Main
Exception in thread "main" java.lang.UnsatisfiedLinkError: /javas/classes/libEngine.so: /javas/classes/libEngine.so: undefined symbol: engOpen
        at java.lang.ClassLoader$NativeLibrary.load(Native Method)
        at java.lang.ClassLoader.loadLibrary0(ClassLoader.java:1751)
        at java.lang.ClassLoader.loadLibrary(ClassLoader.java:1676)
        at java.lang.Runtime.loadLibrary0(Runtime.java:823)
        at java.lang.System.loadLibrary(System.java:1030)
        at MatlabNativeInterface.Engine.<clinit>(Engine.java:99)
        at Main.main(Main.java:11)So... please help!

Answer 1

I need this to run on both linux and windows so JNI is the only wayHuh? Streams in general work on windows and linux. So maybe some more specific info
about what you mean by "i/o streams."
I am aware of three approachesA fourth approach is to write an application in C which communicates with Matlab directly
and then uses some idiom such as sockets to allow communication to java. This would generally
be the method that I would prefer over all others since it makes debugging and testing easier.
undefined symbol: engOpenSomehow you are missing a library (nothing specific to to with JNI nor java) in you JNI code.
Odd error since I would normally expect something else. Try using System.load/loadLibrary() in java to explicitly load the Matlab
library (or libraries) before your JNI library. The load/LoadLibrary calls don't care if it is JNI or not.