halfdan/eva2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

MatlabControl is not required any more

Browse Source
This commit is contained in:
Marcel Kronfeld 2008-02-26 17:54:26 +00:00
parent 197b4b5e6b
commit 4ecb9e9841
1 changed files with 0 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

284
src/javaeva/tools/MatlabControl.java
View File

@ -1,284 +0,0 @@
package javaeva.tools;
/* MatlabControl.java
*
* "Copyright (c) 2001 and The Regents of the University
* of California. All rights reserved.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose, without fee, and without written agreement is
* hereby granted, provided that the above copyright notice and the following
* two paragraphs appear in all copies of this software.
*
* IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
* CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
*
* $\Id$
*/
/**
* This class interfaces with the current Matlab session, allowing you
* to call matlab commands from Java objects
*
* @author <a href="mailto:kamin@cs.berkeley.edu">Kamin Whitehouse</a>
*/
import com.mathworks.jmi.*;
public class MatlabControl {
Matlab matlab = null; //this is the com.mathworks.jmi.Matlab class,which has functionality allowing one to interact with the matlab session.
boolean useCb=false;
Object returnVal;
String callbackFunction;
/***************CONSTRUCTORS****************/
/*** usually, the default constructor with no arguments is fine.
* Sometimes, a callback function is useful. A callback function
* allows the user to pass the command and its arguments to a
* matlab function, which will figure out the best way to execute
* it, instead of trying to execute it directly from java. This
* is often useful for handling/printing errors as well as dealing
* with native matlab data types, like cell arrays. The cell
* array is not really converted to a java type, only the handle
* of the cell array is converted to a java type, so often a
* matlab callback function is useful for dealing specially with
* cell arrays, etc.
***/
public MatlabControl() {
this(false);
}
public Matlab getMatlab() {
return matlab;
}
public MatlabControl(boolean useCallback) {
this(useCallback,new String("matlabControlcb"));
}
public MatlabControl(boolean useCallback, String CallBackFunction) {
try {
if (matlab == null)
matlab = new Matlab();//this command links to the current matlab session
} catch (Exception e) {
System.out.println(e.toString());
}
returnVal = new String("noReturnValYet");
this.useCb=useCallback;
callbackFunction=CallBackFunction;
}
/***************USER-LEVEL FUNCTIONS****************/
/***call these from any java thread (as long as the thread
* originated from within matlab)
***/
/**Evaluate a string, Matlab script, or Matlab function**/
public void eval(String Command) {
Matlab.whenMatlabReady(new MatlabEvalCommand(Command,useCb));
}
/**Evaluate a Matlab function that requires arguments. Each element of
the "args" vector is an argument to the function "Command"**/
public void feval(String Command, Object[] args) {
Matlab.whenMatlabReady(new MatlabFevalCommand(Command, args,useCb));
}
/**Evaluate a Matlab function that requires arguments and provide return arg.
* Each element of the "args" vector is an argument to the function "Command"**/
public Object blockingFeval(String Command, Object[] args) throws InterruptedException {
returnVal = new String("noReturnValYet");
Matlab.whenMatlabReady(new MatlabBlockingFevalCommand(Command, args, useCb, this));
if (returnVal.equals("noReturnValYet")) {
synchronized(returnVal){
returnVal.wait();
}
}
return returnVal;
}
/**Echoing the eval statement is useful if you want to see in
* matlab each time that a java function tries to execute a matlab
* command **/
public void setEchoEval(boolean echo){
Matlab.setEchoEval(echo);
}
/**********TEST FUNCTIONS***********************/
/***call these functions from within Matlab itself. These are examples of the general execution order:
1. instantiate java object from matlab
2. spawn a new Java thread
3. call matlab functions from new java thread
EXAMPLE (from matlab prompt):
>> mc=MatlabControl;
>> mc.testEval('x = 5')
x =
5
> mc.testFeval('help',{'sqrt'})
SQRT Square root.
SQRT(X) is the square root of the elements of X. Complex
results are produced if X is not positive.
See also SQRTM.
Overloaded methods
help sym/sqrt.m
>> mc.testBlockingFeval('sqrt',{x})
2.2361
****/
public void testEval(final String Command) {
class Caller extends Thread{
public void run(){
try{
eval(Command);
} catch(Exception e){
// System.out.println(e.toString());
}
}
}
Caller c = new Caller();
c.start();
}
public void testFeval(final String Command, final Object[] args) {
class Caller extends Thread{
public void run(){
try{
feval(Command, args);
} catch(Exception e){
// System.out.println(e.toString());
}
}
}
Caller c = new Caller();
c.start();
}
public void testBlockingFeval(final String Command, final Object[] args) {
class Caller extends Thread{
public void run(){
try{
Object rets[] = new Object[1];
rets[0] = blockingFeval(Command, args);
feval("disp",rets );
} catch(Exception e){
// System.out.println(e.toString());
}
}
}
Caller c = new Caller();
c.start();
}
/******** INTERNAL FUNCTIONS AND CLASSES *******/
public void setReturnVal(Object val) {
synchronized(returnVal){
Object oldVal = returnVal;
returnVal = val;
oldVal.notifyAll();
}
}
/** This class is used to execute a string in Matlab **/
protected class MatlabEvalCommand implements Runnable {
String command;
boolean useCallback,eval;
Object[] args;
public MatlabEvalCommand(String Command, boolean useCallback) {
command = Command;
this.useCallback = useCallback;
eval=true;
args=null;
}
protected Object useMatlabCommandCallback(String command, Object[] args){
int numArgs = (args==null)? 0 : args.length;
Object newArgs[] = new Object[numArgs+1] ;
newArgs[0]=command;
for(int i=0;i<numArgs;i++){
newArgs[i+1] = args[i];
}
try{
return Matlab.mtFevalConsoleOutput(callbackFunction, newArgs, 0);
}
catch(Exception e){
System.out.println(e.toString());
return null;
}
}
public void run() {
try {
if(useCallback){
useMatlabCommandCallback(command, args);
}
else if(eval){
matlab.evalConsoleOutput(command);
}
else{
matlab.fevalConsoleOutput(command, args);
}
} catch (Exception e) {
System.out.println(e.toString());
}
}
}
/** This class is used to execute a function in matlab and pass parameters**/
protected class MatlabFevalCommand extends MatlabEvalCommand {
public MatlabFevalCommand(String Command, Object[] Args, boolean useCallback) {
super(Command, useCallback);
args = Args;
eval=false;
}
}
/** This class is used to execute a function in matlab and pass parameters
* and it also return arguments**/
protected class MatlabBlockingFevalCommand extends MatlabFevalCommand {
MatlabControl parent;
public MatlabBlockingFevalCommand(String Command, Object[] Args, boolean useCallback, MatlabControl parent) {
super(Command, Args, useCallback);
this.parent=parent;
}
public void run() {
try {
if(useCallback){
parent.setReturnVal(useMatlabCommandCallback(command, args));
}
else{
//parent.setReturnVal(matlab.evalConsoleOutput(command));
parent.setReturnVal(Matlab.mtFevalConsoleOutput(command, args, 0));
}
} catch (Exception e) {
// System.out.println(e.toString());
}
}
}
}