MATLAB: Alternative for eval of dynamic variables

dynamic variablesefficiencyevalfunctionMATLABmeshgridvariablesxyz

Hello,

From what I understand from the online community is that the use of dynamic variables is not acceptable/accurate/buggy.

I have 11 meshgrids (xyz-grids; to make it easy e.g. A,B,…,K) laying next to each other. For each of these 11 grids I want to calculate changing volumes over the years using 17 datasets (= xyz-data through the years). (the meshgrids have different sizes, that's why I did not make an overall grid)

I already assigned the xyz-data to my grids with scatteredInterpolant, so right now I have 17 variables (98,00,…,17) containing the same xy-values but different z-values (through the years; in total 11×17=189 variables; e.g. A_98,A_00,…,A17,B_98,…,K_17).

Now I need to calculate the volumes (=(difference between z-value & reference level)*gridsize; e.g. 50×50 and ref level -20) for each dataset for each mesh grid (so 17×11 times); afterwards I'll compare the results to each other so no need to worry about that.

The reason I like to use dynamic variables is the fact that results can be interpreted (more?) easily and that I don't really understand the online solutions for this.

Is there an efficient way to make a function or adjust my method/grids/variables/names to calculate the volumes of at least all datasets of 1 meshgrid (so 17x times) or even a way this can be done for all meshgrids at once (so 17×11 times)? (In the past I wrote everything 11×17 times which was very inefficient/dangerous for mistakes)

Thanks in advance for reading this (& maybe even helping me)!

Best Answer

If you use a cell array you can store everything in a single array even if the size are different. Because you can index into the cell array you can use a simple for loop, removing any need to repeat your code.

Related Solutions

MATLAB: Invalid index into an array of size {6, 22} with 132.

This might be because you are assigning first element of soilInfo (which is a matrix) to soiltype and second element (which is a character) to soliState.

% [soilType; soilState; frAdd]

I assume from this comment that soilType and soilState are first and second elements of the matrix [1;1;0] in soilInfo. You may define soilType and soilState as

 soilType = soilInfo{1}(1);
 soilState = soilInfo{1}(2);

Also use soilType and soilState values such that they are less than 6 and 22 respectively for DxMap matrix defined above

MATLAB: Assignin and eval functions

You totally misunderstand the issue if you think that eval, evalin or assignin are faulty.

There is nothing wrong with eval, evalin, or assignin, in the sense that they work exactly as documented and do exactly what they are supposed to do. Sometimes these functions are useful. But...

The problem is that what they do lets many beginners use them totally inappropriately, to solve tasks that would be much better solved using simpler, faster, neater, more efficient, easier to debug and much more robust methods (usually indexing is the simpler solution). Simply put, those beginners design their code in such a way that they force themselves to write bad code: slow, buggy, hard to debug, insecure, complex, ugly code. By deciding to write such bad code they remove all of the inbuilt code checking and code helper tools. They also remove any ability for the JIT compiler to speed up their code. They remove the ability to search for and locate variables. The list goes on. Even if all other things were equal, any one of these disadvantages would be reason enough to avoid dynamic variable names.

Or, to put it another way, the problem is not using eval in particular, the main problem is dynamically accessing variable names. It just happens that magically defining or accessing variable names is most commonly achieved using eval and assignin, but the problem actually occurs regardless of what tool or method is used to access them: it also applies to load, for example, when load is called without an output variable.

You need to stop asking "what is the problem with eval?", and start asking yourself "why is it so inefficient to dynamically access variable names?". To help understand some of the issues that is causes, read this thread:

https://www.mathworks.com/matlabcentral/answers/304528-tutorial-why-variables-should-not-be-named-dynamically-eval

You are not the first beginner to ask this question. Some of them get really confused, because they think that there is a problem with eval. For example, read this discussion, including all of the answers and comments:

https://www.mathworks.com/matlabcentral/answers/352237-is-there-the-more-elegant-way-to-do-this

"The experienced contributors to the forum always emphasize avoiding usage of assignin and eval functions due to many reasons."

You will notice that the title of my tutorial is actually "TUTORIAL: Why Variables Should Not Be Named Dynamically (eval)". All of the discussions and links within that tutorial are focused on one topic: dynamically accessing variable names. You need to start reading about this topic if you really want to understand it.

Related Question