1. static class Complex //static because it is in a .pde
2. {float re, im;
3. //static methods to do math between Complex objects}
4.  
5. class ComplexArray
6. {Complex [] points;
7. ctor(int num_points){...}
8. void deepCopy(ComplexArray ca){...} }
9.  
10. class ComplexFunction
11. {ShapeMatrix inputs, outputs; //one holds the inputs to the function, and the other holds the outputs
12. float[] coefficients;
13. ctor(ShapeMatrix sm, float[] coeffs){//creates new instances based on a deep copy of 'sm', copies coeffs}
14. void evalPoly()//evaluate a polynomial of whole powers, using 'coefficients'
15. /*Note that in my present code, I use 'inputs' or 'outputs' to invoke their methods to plot points or draw lines.  I am not passing anything into their methods.*/}

Rehash of my previous post:

The ShapeMatrix interface used to be a class called ComplexShape , which extended ComplexArray.  I have since abstracted its methods into the interface to break the segmented ComplexShape code into separate classes that handle related segments.

1. class ComplexFunction3D extends ComplexFunction
2. {float [] animation_outputs, point_distances, point_angles; //used for rotating/interpolating between two axes, to produce an animation
3. float theta; //amount to rotate the animation axes
4. int dim1, dim2, dim3;//the three axes to show, option-handed by switch() right now
5. ctor(ComplexFunction cf) {super(cf.inputs, cf.coefficients); ...}
6. void vertexSP(int index); //handles which values to pass to vertex()
7. void any_name(){inputs.drawLines3D(this);} //any_name is actually drawLines3D, but it could end up confusing someone if not read closely, so I changed it}
 

I have had to pass the ComplexFunction3D object invoking any_name(), into drawLines3D() because I need the 'inputs' and 'outputs' members present inside of drawLines3D().  That way I can have access to all of the axes (inputs[].re, inputs[].im, outputs[].re, outputs[].im).

1. class ???Matrix extends ComplexArray implements ShapeMatrix
2. {ctor(float re_origin, float im_origin, float re_interval, float im_interval, int ... metrics) {...}
3. /*the parameters provide instructions for where to start and where to place each grid point, and a measurement metric (something that represents the number of rows and columns in a rectangle, the height of a triangle, or the number of points along a line)*/}
4. Interface ShapeMatrix
5. {void drawPoints2D();
6. void drawLines2D();
7. void drawLines3D();
8. static ShapeMatrix newInstance();}

Yes, my program has always worked.  I never had any problems getting it to the final visual and interactive product, except when I tried to put it into an OO framework to make it easier to follow – this program is being turned in for a class project.  It was an inappropriate application to make into OO, since I don’t plan on releasing it, and I could have just added multi-line comments.  However, I usually have a paranoid need for robust programming as my final product.  Not having encapsulation would have been a security issue for me (another bad reason to go OO, since it is not getting released).

As a mention, when I learned the ideas of OOP I was still programming C-style inside of C++.  I never actually got much practice putting things into real OO code in C++ or Java before I stopped programming entirely.  I am picking it up after 4 years, but with no intention to become a professional.  If I continue on after this, I will read up on it and try again.

My code looked the same from when I first posted.  I didn’t change it in my second message because I was trying to show what it looks like to give a better sense of what was going on.

I wonder why the different Matrix classes are not needed.  That may be another discussion.  Just message me if you’re willing to tell me a little more.  You’ve already helped me a lot, so I thank you for that.  :)  I have a great final product now that I eliminated the ComplexFunction classes.  I just perform the calculation I want, and everything is ready to go!