i have the following code in which the size of the public static float[][] glodMat1 should be determined by the arguments in the mxj object.

for some reason the size of globMat1 stays 0 x 0.

what am i doing wrong? or should i determine globMat1's size in another way?

public class ynsMf_mat extends MaxObject {

    public ynsMf_mat(int a1, int a2) {

    public static float[][] globMat1 = new float[rows][cols];

        outlet(1, globMat1[matInd]);

    public void matSize(int matInd) {

        outlet(1, globMat1[matInd].length);

i have the following code in which the size of the public static float[][] glodMat1 should be determined by the arguments in the mxj object. 

	private static int rows = 0;
	private static int cols = 0;

	public ynsMf_mat(int a1, int a2) {
		rows = a1;
		cols = a2;
		declareIO(2,1);
		post(rows + " rows");
		post(cols + " cols");
	}

	public static float[][] globMat1 = new float[rows][cols];

	public void mat(int matInd) {
		outlet(1, globMat1[matInd]);
	}

	public void matSize(int matInd) {
		outlet(1, globMat1[matInd].length);
	}
}


determining-size-of-public-static-float-by-mxj-arguments

All code outside of your methods gets called when the object is instantiated, before the constructor is called. In the case of static code, it is only called the first time the class is loaded.

 to globMat1, the constructor has only been declared, not called. rows and cols are still 0.

If you really want globMat1 to be static (which would mean that no matter how many of these objects you make in max, there will only be ONE of them), you are better off making the object take a message that re-initializes that static member:

import com.cycling74.max.*;

public class ynsMf_mat extends MaxObject {

    public static float[][] globMat1;

    public ynsMf_mat() {
        declareIO(2,1);
    }

    public void remakeMat(int rows, int cols) {
        globMat1 = new float[rows][cols];
    }        

    public void mat(int matInd) {
        outlet(1, globMat1[matInd]);
    }

    public void matSize(int matInd) {
        outlet(1, globMat1[matInd].length);
    }
}

This would re-allocate the array whenever you send the appropriate message to any instance of this object. Note that in "normal" java code, remakeMat would be properly declared static, but here it can't be in order to be called directly from Max.

EDIT: i just saw your other posts. i guess you do want globMat1 to be static.

In short, at the time you assign new float[rows][cols] to globMat1, the constructor has only been declared, not called. rows and cols are still 0.

don't need rows and cols as variables outside of your constructor at all

need to instantiate globMat1 inside your constructor

EDIT: i just saw your other posts. i guess you do want globMat1 to be static.


thanks for your suggestion, it works! i solved it like this to get the arguments determining teh size of the float[][]:

    public static float[][] globMat1;

    public ynsMf_mat(int rows, int cols) {

        globMat1 = new float[rows][cols];

        outlet(1, globMat1.length);

        outlet(1, globMat1[1].length);

but now the mxj objects which extend this class to refer to the global variable can't find the class anymore when i use arguments in the class above, when i remove the arguments it's no problem. her is the code for the class which extends the class above, could you tell me what i'm doing wrong?

public class ynsMf_rec extends ynsMf_mat {

                globMat1[i1][i2] = item;

                item = item + 1;

	public ynsMf_mat(int rows, int cols) {
		declareIO(2,1);
		globMat1 = new float[rows][cols];
	}

	public void matRows() {
		outlet(1, globMat1.length);
	}

	public void matCols() {
		outlet(1, globMat1[1].length);
	}
}

	public ynsMf_rec() {
		declareIO(2,1);
	}

	public void fillMat() {
		float item = 1f;
		for(int i1=0; i1
			for(int i2=0; i2
				globMat1[i1][i2] = item;
				item = item + 1;
			}
		}
	}
}


Short version: don't make the change to my code that you made. You are using a static member, but initializing it every time you instantiate a new instance of the class. This makes no sense. If you want a global, static member, use the code that i gave you and send the appropriate message to one of the mxj objects when you want to initialize it.

Unless I'm mistaken, the code you supplied here shouldn't even compile. Your parent class has only one constructor and it takes 2 parameters. Your child class' constructor doesn't explicitly call the super class' constructor, so it tries to call super(). This will fail because super() doesn't exist, only super(int,int).

 in your objects constructor, java automatically calls 

 before executing any of the code in your constructor. So your constructor actually is doing this:

public ynsMf_rec() {
     super();
     declareIO(2,1);
}

public ynsMf_rec() {
     super(20, 45);
     declareIO(2,1);
}

public ynsMf_rec(int a1, int a2) {
     super(a1, a2);
     declareIO(2,1);
}

I was thinking of mentioning a couple of other thoughts on this subject, but first could you elaborate a little more about what you are trying to accomplish? I have a feeling you want some object to have typed in arguments to set the array size and other objects to have no arguments? If that is going on or something completely different is there may be some other things to consider (I'd elaborate now, but am really tired and it would take a lot of energy to share these thoughts clearly and I may be answering off topic questions).

In the meantime, if anyone else wants to weigh in, I'm thinking designing a singleton class to store 

 would make a little more sense. While subclassing to share global data does feel like a very Java way to handle it, it also feels lind of like a hack to me since (if I am imagining yns' needs correctly) it doesn't seem like the children of ynsMf_mat would satisfy an "is a" relationship and are only subclassing to share data. I'd be happy to post a singleton example tomorrow.

If you do not explictly make a call to super in your objects constructor, java automatically calls super() before executing any of the code in your constructor.  So your constructor actually is doing this:

So if you need to call public ynsMf_mat(int a1, int a2) from ynsMf_rec() you must do so explictly:

I was thinking of mentioning a couple of other thoughts on this subject, but first could you elaborate a little more about what you are trying to accomplish? I have a feeling you want some object to have typed in arguments to set the array size and other objects to have no arguments?  If that is going on or something completely different is there may be some other things to consider (I'd elaborate now, but am really tired and it would take a lot of energy to share these thoughts clearly and I may be answering off topic questions).

In the meantime, if anyone else wants to weigh in, I'm thinking designing a singleton class to store float[][] globMat1 would make a little more sense.  While subclassing to share global data does feel like a very Java way to handle it, it also feels lind of like a hack to me since (if I am imagining yns' needs correctly) it doesn't seem like the children of ynsMf_mat would satisfy an "is a" relationship and are only subclassing to share data.  I'd be happy to post a singleton example tomorrow.


Hmm, now I am also wondering if you could just put 

 in its own class and access it with static methods instead of a true singleton object would probably be even better and more Javaie.

Hmm, now I am also wondering if you could just put float[][] globMat1 in its own class and access it with static methods instead of a true singleton object would probably be even better and more Javaie.


This is one of the areas I was avoiding for now in my posts. I have a feeling yns chose to make that modification so that initialization of the static member can happen when the [mxj] loads instead of requiring a message to be sent. If that is what you want yns (because the issue with your code mentioned above is true) there are other ways to acheive that.

This is one of the areas I was avoiding for now in my posts. I have a feeling yns chose to make that modification so that initialization of the static member can happen when the [mxj] loads instead of requiring a message to be sent.  If that is what you want yns (because the issue with your code mentioned above is true) there are other ways to acheive that.

It compiles because a super() call to ynsMf_mat just turns into a call to super() in MaxObject.


No it doesn't. When I was looking at the code assuming it compiled, I too thought "Oh, will Java just call the MaxObject() default constructor? Okay." But if you think about it, it makes no sense, and if you try it, you'll find that it doesn't compile.

OOPS! Thanks for correcting that, ignore my post above.

I'd recommend writing something like this:

public class YNSMf_mat {

private static float[][] globMat1;

    public static void initialize(int rows, int cols) {
        globMat1 = new float[rows][cols];
    }

    public static float[] mat(int matInd) {
        return globMat1[matInd];
    }

    public static int matRows() {
        return globMat1.length;
    }

    public static int matCols() {
        return globMat1[1].length;
    }

    public static float getCell(int x, int y) {
        return globMat1[x][y];
    }

    public static void setCell(int x, int y, float val) {
        globMat1[x][y] = val;
    }
}

import com.cycling74.max.*;

public class ynsMf_rec extends MaxObject {

    public ynsMf_rec() {
        YNSMf_mat.initialize(30, 10);
        declareIO(2,1);
    }

    public void fillMat() {
        float item = 1f;
        for(int i1=0; i1

This example won't work that well in practice because every 

. Also, there is nothing done to handle problems if you try to call a method of 

. I can share some thoughts on this, but like I mentioned last night, need to know a little more about your goals to really be helpful.

public class YNSMf_mat {

private static float[][] globMat1;

	public static void initialize(int rows, int cols) {
		globMat1 = new float[rows][cols];
	}

	public static float[] mat(int matInd) {
		return globMat1[matInd];
	}

	public static int matRows() {
		return globMat1.length;
	}

	public static int matCols() {
		return globMat1[1].length;
	}

	public static float getCell(int x, int y) {
		return globMat1[x][y];
	}

	public static void setCell(int x, int y, float val) {
		globMat1[x][y] = val;
	}
}

import com.cycling74.max.*;

public class ynsMf_rec extends MaxObject {

	public ynsMf_rec() {
		YNSMf_mat.initialize(30, 10);
		declareIO(2,1);
	}

	public void fillMat() {
		float item = 1f;
		for(int i1=0; i1

N.B.:This example won't work that well in practice because every [mxj ynsMf_rec] you make will reinitialize the float[][] in YNSMf_mat.  Also, there is nothing done to handle problems if you try to call a method of YNSMf_mat before you call YNSMf_mat.initialize().  I can share some thoughts on this, but like I mentioned last night, need to know a little more about your goals to really be helpful.


I used and modified your last proposal Roth. Thanks for that! There are still some things I would like to add to my objects which I can't figure out though. I'll try to explain what I would like to make:

In the end I'm aiming for a set of objects that share a couple of matrices,. I would like to have an object that can store lists, one that can read them and one or more that can analyze the lists. Those operations at them selfs are not the problem, I already programmed them into another object, all together in one object.

The thing is that I would like to have some kind of system which works like MSP's buffer system. It would be nice if I could determine the name of the list that the object refers to by an argument, just like it works with MSP buffers. I find a way to this by creating 10 float[][]'s and letting the first argument of the object (an int) determine the float[][] to refer to. The code I used to this is in the bottom of this post. It works but it requires a lot of code and therefore doesn't seem very efficient to me, I might be wrong off course. Besides that it would be nice to have an unlimited amount of float[][]'s that can be created instead of being limited by how much float[][]'s i programmed into the object. And it would be nice to refer by names (strings) instead of numbers.

Another thing that would be nice but might be impossible is to let the number of arguments determine the number of dimensions of the matrix. So if there are (besides the "refer-to" argument) 2 arguments there would a float[][], when there are 3 arguments a float[][][] would be created and so on. I have no clue how I could do this or if it's even possible.

Here is the adjustment I made to Roth's code for the matrix storage class:

    public static void init(int matInd, int rows, int cols) {

            globMat1 = new float[rows][cols];

        } else if (matInd == 2) {

            globMat2 = new float[rows][cols];

        } else if (matInd == 3) {

            globMat3 = new float[rows][cols];

        } else if (matInd == 4) {

            globMat4 = new float[rows][cols];

        } else if (matInd == 5) {

            globMat5 = new float[rows][cols];

        } else if (matInd == 6) {

            globMat6 = new float[rows][cols];

        } else if (matInd == 7) {

            globMat7 = new float[rows][cols];

        } else if (matInd == 8) {

            globMat8 = new float[rows][cols];

        } else if (matInd == 9) {

            globMat9 = new float[rows][cols];

        } else if (matInd == 10) {

            globMat10 = new float[rows][cols];

    public static float[] matRow(int matInd, int row) {

            return globMat1[row];

            return globMat2[row];

            return globMat3[row];

            return globMat4[row];

            return globMat5[row];

            return globMat6[row];

            return globMat7[row];

            return globMat8[row];

            return globMat9[row];

            return globMat10[row];

    public static int matRows(int matInd) {

            return globMat1.length;

            return globMat2.length;

            return globMat3.length;

            return globMat4.length;

            return globMat5.length;

            return globMat6.length;

            return globMat7.length;

            return globMat8.length;

            return globMat9.length;

            return globMat10.length;

    public static int matCols(int matInd) {

            return globMat1[1].length;

            return globMat2[1].length;

            return globMat3[1].length;

            return globMat4[1].length;

            return globMat5[1].length;

            return globMat6[1].length;

            return globMat7[1].length;

            return globMat8[1].length;

            return globMat9[1].length;

            return globMat10[1].length;

    public static float getCell(int matInd, int x, int y) {

            return globMat1[x][y];

            return globMat2[x][y];

            return globMat3[x][y];

            return globMat4[x][y];

            return globMat5[x][y];

            return globMat6[x][y];

            return globMat7[x][y];

            return globMat8[x][y];

            return globMat9[x][y];

            return globMat10[x][y];

    public static void setCell(int matInd, int x, int y, float val) {

            globMat1[x][y] = val;

            globMat2[x][y] = val;

            globMat3[x][y] = val;

            globMat4[x][y] = val;

            globMat5[x][y] = val;

            globMat6[x][y] = val;

            globMat7[x][y] = val;

            globMat8[x][y] = val;

            globMat9[x][y] = val;

            globMat10[x][y] = val;

And here is the code I used for the "record" object:

public class ynsMf_rec extends MaxObject {

    public ynsMf_rec(int matInd, int rows, int cols) {

        ynsMf_mat.init(matInd, rows, cols);

        outlet(1, ynsMf_mat.matRow(matIndex, row));

        outlet(1, ynsMf_mat.matRows(matIndex));

        outlet(1, ynsMf_mat.matCols(matIndex));

                ynsMf_mat.setCell(matIndex, i1, i2, item);

Another thing that would be nice but might be impossible is to let the number of  arguments determine the number of dimensions of the matrix. So if there are (besides the "refer-to" argument) 2 arguments there would a float[][], when there are 3 arguments a float[][][] would be created and so on. I have no clue how I could do this or if it's even possible.

private static float[][] globMat1;
private static float[][] globMat2;
private static float[][] globMat3;
private static float[][] globMat4;
private static float[][] globMat5;
private static float[][] globMat6;
private static float[][] globMat7;
private static float[][] globMat8;
private static float[][] globMat9;
private static float[][] globMat10;

	public static void init(int matInd, int rows, int cols) {
		if (matInd == 1) {
			globMat1 = new float[rows][cols];
		} else if (matInd == 2) {
			globMat2 = new float[rows][cols];
		} else if (matInd == 3) {
			globMat3 = new float[rows][cols];
		} else if (matInd == 4) {
			globMat4 = new float[rows][cols];
		} else if (matInd == 5) {
			globMat5 = new float[rows][cols];
		} else if (matInd == 6) {
			globMat6 = new float[rows][cols];
		} else if (matInd == 7) {
			globMat7 = new float[rows][cols];
		} else if (matInd == 8) {
			globMat8 = new float[rows][cols];
		} else if (matInd == 9) {
			globMat9 = new float[rows][cols];
		} else if (matInd == 10) {
			globMat10 = new float[rows][cols];
		}
	}

	public static float[] matRow(int matInd, int row) {
		if (matInd == 1) {
			return globMat1[row];
		} else if (matInd == 2) {
			return globMat2[row];
		} else if (matInd == 3) {
			return globMat3[row];
		} else if (matInd == 4) {
			return globMat4[row];
		} else if (matInd == 5) {
			return globMat5[row];
		} else if (matInd == 6) {
			return globMat6[row];
		} else if (matInd == 7) {
			return globMat7[row];
		} else if (matInd == 8) {
			return globMat8[row];
		} else if (matInd == 9) {
			return globMat9[row];
		} else {
			return globMat10[row];
		}
	}

	public static int matRows(int matInd) {
		if (matInd == 1) {
			return globMat1.length;
		} else if (matInd == 2) {
			return globMat2.length;
		} else if (matInd == 3) {
			return globMat3.length;
		} else if (matInd == 4) {
			return globMat4.length;
		} else if (matInd == 5) {
			return globMat5.length;
		} else if (matInd == 6) {
			return globMat6.length;
		} else if (matInd == 7) {
			return globMat7.length;
		} else if (matInd == 8) {
			return globMat8.length;
		} else if (matInd == 9) {
			return globMat9.length;
		} else {
			return globMat10.length;
		}
	}

	public static int matCols(int matInd) {
		if (matInd == 1) {
			return globMat1[1].length;
		} else if (matInd == 2) {
			return globMat2[1].length;
		} else if (matInd == 3) {
			return globMat3[1].length;
		} else if (matInd == 4) {
			return globMat4[1].length;
		} else if (matInd == 5) {
			return globMat5[1].length;
		} else if (matInd == 6) {
			return globMat6[1].length;
		} else if (matInd == 7) {
			return globMat7[1].length;
		} else if (matInd == 8) {
			return globMat8[1].length;
		} else if (matInd == 9) {
			return globMat9[1].length;
		} else {
			return globMat10[1].length;
		}
	}

	public static float getCell(int matInd, int x, int y) {
		if (matInd == 1) {
			return globMat1[x][y];
		} else if (matInd == 2) {
			return globMat2[x][y];
		} else if (matInd == 3) {
			return globMat3[x][y];
		} else if (matInd == 4) {
			return globMat4[x][y];
		} else if (matInd == 5) {
			return globMat5[x][y];
		} else if (matInd == 6) {
			return globMat6[x][y];
		} else if (matInd == 7) {
			return globMat7[x][y];
		} else if (matInd == 8) {
			return globMat8[x][y];
		} else if (matInd == 9) {
			return globMat9[x][y];
		} else {
			return globMat10[x][y];
		}
	}

	public static void setCell(int matInd, int x, int y, float val) {
		if (matInd == 1) {
			globMat1[x][y] = val;
		} else if (matInd == 2) {
			globMat2[x][y] = val;
		} else if (matInd == 3) {
			globMat3[x][y] = val;
		} else if (matInd == 4) {
			globMat4[x][y] = val;
		} else if (matInd == 5) {
			globMat5[x][y] = val;
		} else if (matInd == 6) {
			globMat6[x][y] = val;
		} else if (matInd == 7) {
			globMat7[x][y] = val;
		} else if (matInd == 8) {
			globMat8[x][y] = val;
		} else if (matInd == 9) {
			globMat9[x][y] = val;
		} else if (matInd == 10)  {
			globMat10[x][y] = val;
		}
	}
}

	public ynsMf_rec(int matInd, int rows, int cols) {
		ynsMf_mat.init(matInd, rows, cols);
		matIndex = matInd;
		declareIO(2,1);
	}

	public void matRow(int row) {
		outlet(1, ynsMf_mat.matRow(matIndex, row));
	}

	public void matRows() {
		outlet(1, ynsMf_mat.matRows(matIndex));
	}

	public void matCols() {
		outlet(1, ynsMf_mat.matCols(matIndex));
	}

	public void fillMat() {
		float item = 1f;
		for(int i1=0; i1
			for(int i2=0; i2
				ynsMf_mat.setCell(matIndex, i1, i2, item);
				item = item + 1;
			}
		}
	}
}


You want to do things that basically mean you don't want to use arrays. For some unspecified number of matrices, I would suggest looking at the java.util.ArrayList class.

import java.util.ArrayList;

public class ynsMf_mat {

    private static ArrayList matrices = new ArrayList();

    public static void init(int numMatrices, int rows, int cols) {
        for (int i = 0; i != numMatrices; i++) {
            matrices.add(new float[rows][cols]);
        }
    }

    public static float[] matRow(int matInd, int row) {
        return matrices.get(matInd)[row];
    }

    public static int matRows(int matInd) {
        return matrices.get(matInd).length;
    }

    public static int matCols(int matInd) {
        return matrices.get(matInd)[0].length;
    }

    public static float getCell(int matInd, int x, int y) {
        return matrices.get(matInd)[x][y];
    }

    public static void setCell(int matInd, int x, int y, float val) {
        matrices.get(matInd)[x][y] = val;
    }
}

Although to be frank, I find this encapsulation of every operation on an array to be kind of ridiculous.

If you really want n-dimensional matrices, and you're working in Max, using Jitter is probably the way to go.

import java.util.ArrayList;

public class ynsMf_mat {

	private static ArrayList matrices = new ArrayList();

	public static void init(int numMatrices, int rows, int cols) {
		for (int i = 0; i != numMatrices; i++) {
			matrices.add(new float[rows][cols]);
		}
	}

	public static float[] matRow(int matInd, int row) {
		return matrices.get(matInd)[row];
	}

	public static int matRows(int matInd) {
		return matrices.get(matInd).length;
	}

	public static int matCols(int matInd) {
		return matrices.get(matInd)[0].length;
	}

	public static float getCell(int matInd, int x, int y) {
		return matrices.get(matInd)[x][y];
	}

	public static void setCell(int matInd, int x, int y, float val) {
		matrices.get(matInd)[x][y] = val;
	}
}

If you really want n-dimensional matrices, and you're working in Max, using Jitter is probably the way to go.


You may want to check out using HashTable instead of ArrayList since that will allow you to use strings as keys.

I kind of agree. If you weren't aware, Jitter is integrated with the Max Java SDK really nicely and so you may be better off using Jitter for sharing matrix data between your [mxj]s. I guess it is up to you to look at the advantages of using Jitter or your own custom data structure (I've been thinking about a similar issue recently with some fft externals I'm writing in C.

I kind of agree.  If you weren't aware, Jitter is integrated with the Max Java SDK really nicely and so you may be better off using Jitter for sharing matrix data between your [mxj]s.  I guess it is up to you to look at the advantages of using Jitter or your own custom data structure (I've been thinking about a similar issue recently with some fft externals I'm writing in C.


If you actually want a map, you almost definitely want HashMap and not Hashtable.

Thanks for your reply's. Brain, what your suggesting seems quite nice and a good solution, but when I saw it I figured it would be nice for the float[][]'s themselves to be of a variable size. The float[][] is there to store a list of lists. It would be nice if a list would be added to the list of lists and thus change the size of the list of lists. This so later on (in another object) I can loop trough the list.

The thing is that I have no clue to do this with ArrayList, Hashtable or HashMap since I'm quite new to Java. Since I am not really familiar with Jitter this kind of frightens me.

I should add that efficiency (Memory but especially CPU wise) is very very important to me. I'm willing to do some concessions when it comes tot the convenience of the objects since the writing and reading will have to happen at intervals up to 1 ms.

The thing is that I have no clue to do this with ArrayList, Hashtable or HashMap since I'm quite new to Java.

Google is your friend. All of the standard Java libraries are fully and publicly documented 

http://download.oracle.com/javase/1.5.0/docs/api/

If you want to change the size of a list at runtime, do not use an array. An array has a fixed size. Use ArrayList or some other java collection with a variable size.

I should add that efficiency (Memory but especially CPU wise) is very very important to me.

Trying to optimize for performance before you've identified bottlenecks is silly. Performance and "convenience" are not necessarily contradictory.

Google is your friend. All of the standard Java libraries are fully and publicly documented http://download.oracle.com/javase/1.5.0/docs/api/

Well I figured there could be a difference in CPU usage in for instance, writing lists into a float[][] or into an ArrayList because an ArrayList needs to dynamically add a list in contrast to a float[][] which only needs to fill a list.

Also indexing lists by strings sounds like it would needs more CPU than indexing them by integers. I might be totally wrong, but if there are more things like these I'd love to know them in advance.

determining size of public static float[][] by mxj arguments