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.

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.

It looks to me like you:

• don't want globMat1 to be static

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

• need to instantiate globMat1 inside your constructor

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.

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

import com.cycling74.max.*;

public class ynsMf_mat extends MaxObject {

    public static float[][] globMat1;

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

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

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

    public void matCols() {
        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?

import com.cycling74.max.*;

public class ynsMf_rec extends ynsMf_mat {

    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).

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:

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

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

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

or

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

Or something along those lines.

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 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.

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.

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.

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).

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

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.

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:

YNSMf_mat.java

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;
    }
}

and use it like this:

ynsMf_rec.java

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.