andrea mancianti

I have two very very similar patches, in which a matrix with random values is transferred to Java-land, and, without doing anything on it, it is sent back to max-land. What is different is only the strategy used in the Java code. 

In the first case I used the method copyVectorToArray() triggered by the bang referencing existing named matrices, while in the second case I used the matrix name method as in the example "jitvecprocess-exemple" to refer a matrix connected straight into the mxj inlet. 

The rest is pretty similar, but the discrepancy in terms of computation is enormous (~14fps in the first vs 60fps in the second). 

Can anybody explain why the second technique is SO much better and/or what have I done horribly wrong in the first example? 

I really need to understand this to be able to use the bridge java-max in a sensible way, as so far I feel like I am running around in circle...

I enclose a picture of the super simple patches and both codes.

Screen Shot 2017-09-07 at 18.37.59.png

public class InOutExperiments extends MaxObject {

    public InOutExperiments(String inputMatrix, String outputMatrix, int width, int height){

        declareInlets(new int[]{DataTypes.ALL});

        declareOutlets(new int[]{DataTypes.ALL});

        input = new JitterMatrix(inputMatrix);

        output = new JitterMatrix(outputMatrix, 2, "float32", width, height);

     planes = input.getPlanecount(); //getMatrix

        for (int i=0; i<size[1]; i++) {

    input.copyVectorToArray(0, offset, array, array.length, 0);

    output.copyArrayToVector(0, offset, array, array.length, 0); 

public class InOutExperiments2 extends MaxObject

        mat = new JitterMatrix();

        outlet(0,"jit_matrix", mat.getAttr("name"));

    public void jit_matrix(String inname)

        int[] offset = new int[2];

        inmat = new JitterMatrix(inname);

        planecount = mat.getPlanecount();    

        if ((vec==null)||(vec.length!=(dim[0]*planecount)))

            vec = new float[dim[0]*planecount];

        for (lineScan=0;lineScan<height;lineScan++) {

            offset[1] = lineScan;    

            inmat.copyVectorToArray(0,offset,vec,vec.length,0);    

            // make smtg here

            mat.copyArrayToVector(0,offset,vec,vec.length,0);    

Hi everybody, 
I have two very very similar patches, in which a matrix with random values is transferred to Java-land, and, without doing anything on it, it is sent back to max-land. What is different is only the strategy used in the Java code.  
In the first case I used the method copyVectorToArray() triggered by the bang referencing existing named matrices, while in the second case I used the matrix name method as in the example "jitvecprocess-exemple" to refer a matrix connected straight into the mxj inlet. 
The rest is pretty similar, but the discrepancy in terms of computation is enormous (~14fps in the first vs 60fps in the second). 
Can anybody explain why the second technique is SO much better and/or what have I done horribly wrong in the first example? 
I really need to understand this to be able to use the bridge java-max in a sensible way, as so far I feel like I am running around in circle...
I enclose a picture of the super simple patches and both codes.
Thanks everybody for the help!


Example 1:
import com.cycling74.max.*;
import com.cycling74.jitter.*;

	JitterMatrix input; 
	JitterMatrix output; 

    int len;
    int planeSize;
    int planes;
    int[] size;
    int[] offset;

	public InOutExperiments(String inputMatrix, String outputMatrix, int width, int height){

		declareInlets(new int[]{DataTypes.ALL});
		declareOutlets(new int[]{DataTypes.ALL});

		input = new JitterMatrix(inputMatrix);
		output = new JitterMatrix(outputMatrix, 2, "float32", width, height);

	   planes = input.getPlanecount(); //getMatrix
	    size = input.getDim();
	    planeSize = size[0]*size[1];
	    len = planeSize*planes;
	    offset = new int[]{0, 0};

		for (int i=0; i<size[1]; i++) {
        	offset[1] = i;
        	input.copyVectorToArray(0, offset, array, array.length, 0);
        	//do smtg here!
        	output.copyArrayToVector(0, offset, array, array.length, 0); 
        }      	      
	}	
}

Example 2:
import com.cycling74.max.*;
import com.cycling74.jitter.*;

public class InOutExperiments2 extends MaxObject
{
	JitterMatrix mat;
	JitterMatrix inmat;
	float[] vec;

   public InOutExperiments2(Atom[] args)
    {
		declareInlets(new int[]{DataTypes.ALL});
		declareOutlets(new int[]{DataTypes.ALL});
 		mat = new JitterMatrix();
   	}

   public void bang()
 	{
		outlet(0,"jit_matrix", mat.getAttr("name"));
	}

	public void jit_matrix(String inname)
	{
		int[] dim;
		int[] offset = new int[2];
		int width;
		int height;
		int planecount;
		int lineScan;
		inmat = new JitterMatrix(inname);

		mat.setinfo(inname);
		dim = mat.getDim();
		planecount = mat.getPlanecount();	

		if ((vec==null)||(vec.length!=(dim[0]*planecount)))
			vec = new float[dim[0]*planecount];

		width = dim[0];
		height = dim[1];
		offset[0] = 0;

		for (lineScan=0;lineScan<height;lineScan++) {
			offset[1] = lineScan;	
			inmat.copyVectorToArray(0,offset,vec,vec.length,0);	
			// make smtg here
			mat.copyArrayToVector(0,offset,vec,vec.length,0);	
		}	
		outlet(0,"jit_matrix", mat.getAttr("name"));
	}
}


Hi everybody, 
I have two very very similar patches, in which a matrix with random values is transferred to Java-land, and, without doing an

Matrix methods performance confusion. HELP! :)