how to make a 2 files .mat become 1?

i want to make 2 .mat files become 1 file. For example, I have 1 mat file when I give name databasefitur, and databasefitur1. In this case databasefitur and databasefitur1 have 2 rows and 255 columns. I want to make them as a group.

For example, I use this code in my program :

load file_name.mat 
file1=strcat('..\Project Tugas Akhir\Histogram LoG\',file_name); 
I=imread(file1); 
imhist(I) 
[n,xout]=imhist(I);  %nilai piksel 
featureSize=size(n); 
featuresN=reshape(n,1,featureSize(1));  %jumlah piksel 
featureSize=size(xout); 
featuresXout=reshape(xout,1,featureSize(1));  %save ke databasefitur 
databaseFitur2=[featuresN;featuresXout]; 
save('databaseFitur2','databaseFitur2');

[Jan]

@Veizal: Sorry, your thread has been hijacked by a discussion, which does not help to solve your problem. You can ignore these comments without loosing any detail.

Note that the output array can be created easier:

[n, xout]      = imhist(I);
databaseFitur2 = [n(:).'; xout(:).'];

Answer 1

[Image Analyst]

I don't quite understand the question, but in general, to save variables in a .mat file, you give the filename and follow with variable names enclosed in single quotes:

matFullFileName = fullfile(someFolder, 'databaseFiture.mat'); % someFolder could be pwd if you want it in the current folder.
% Save both databaseFitur1 and databaseFitur2 variables in file databaseFitur.mat.
save(matFullFileName, 'databaseFitur1', 'databaseFitur2');

or whatever.

[Veizal Rasyid]

my question is "How to merge 2 or more file .mat?"

[Image Analyst]

You obviously already know how to call load() since you did it (though I would have assigned the return value to a structure like the others are also recommending). All that was missing was how to combine variables in a third .mat file. You did that incorrectly by forgetting to include the output filename as the first argument to save(), so I showed you how to do that. Just pass in the filename, followed by variables in single quotes, regardless of how you got them -- like from calling load to pull them out of another .mat file or by creating brand new variables or both -- and all those variables will be combined in your new .mat file.

[Adam]

"advanced programming comments that is not needed to solve this question"

Your answer is 8 lines of code including the functions 'who' and 'matfile' as well as creating a cell array.

Stephen's code is 3 lines, 2 of which are the highly intuitive and un-complicated calls to 'load' and 'save'. People vote for answers for a reason, and that is before we even consider all the other good reasons for doing it that way.

Tagging your answer on to the answer which currently happens to be at the top of the list through being upvoted is no better than spamming adverts in random threads or answers.

Answer 2

[Stephen23]

Actually it is really easy to efficiently merge two (or more) .mat files into one .mat file (to get the set union of the variables): the trick is to load and save a structure (which you should always be doing anyway!). First lets create some fake data and save it in two .mat files:

>> A = 'aaa';
>> B = 1:3;
>> save A.mat A
>> save B.mat B

We can now efficiently merge the contents of the two .mat files together:

>> copyfile('A.mat','C.mat') % C will be the merged file
>> S = load('B.mat');
>> save('C.mat','-struct','S','-append')

That is all!

Now C.mat contains all of the fields of A.mat and B.mat. Lets have a look:

>> new = load('C.mat')
new = 
    A: 'aaa'
    B: [1 2 3]

It could even be done in a loop if you have multiple .mat files to merge, something like this (untested):

D = dir('*.mat');
copyfile(D(1).name,'ZZZ.mat')
for k = 2:numel(D)
    S = load(D(k).name);
    save('ZZZ.mat','-struct','S','-append')
end

Note that you should never simply load into the workspace (always load into a structure), and using very inefficient introspective commands, like who or whos, is not required for this task.

[John BG]

why should people never ever load mat files into the workspace?

If some one doesn't really such structure, not using it saves the reading of the structure, doesn't it?

So you suggest every one should be always loading mat files into structures, then reading from the structures.

And once all the work done, what are the people supposed to do with the structures, clean as we go and bin them?

Again another step that may be unnecessary, avoidable not using the structure out of load.

[John BG]

and command who is not exactly the same as command whos

[Jan]

 why should people never ever load mat files into the workspace?

After a load('file.mat') without catching the output in a struct, reading the source code does not allow to know, if e.g. xyz(2) is a function call or a local variable loaded from the MAT file. This concerns the human reader, but Matlab also: exactly as the other methods to create variables dynamically like eval, it reduces the clarity of the code and the processing speed massively.

I agree with Stephen: Avoid cluttering the current workspace, but always catch the output in a struct by S = load(...).

[Stephen23]

"why should people never ever load mat files into the workspace?"

Because load-ing into a structure is an easy way to:

1. avoid pointless bugs because variable tracking is simpler.
2. make input checking simpler, if the user want to check the input values.
3. allow either an unknown number of parameters to be processed, or a fixed number. This is very useful for optional arguments for any process.
4. allow the static code checking tools to work effectively.
5. prevent accidental overwriting of existing variables.
6. allow the MATLAB JIT code optimization to work efficiently with the structure.
7. allow the MATLAB parser to uniquely identify variables and functions.
8. make it trivially easy to efficiently process all fields (e.g. loop over numbered fields).
9. write clear code that is easy to understand, which reduces bugs.

In comparison using load directly into the workspace:

1. has the needless risk of overwriting existing variables.
2. offers no efficient way to check which variables have been loaded.
3. hinders the JIT code optimization.
4. is ambiguous for the parser which object is being referenced (see example).
5. ... therefor also impedes the Code Analyzer to identify variables and functions correctly.
6. makes debugging harder as the origin of variables cannot be traced.
7. ...which also means that the static code checking tools are not effective.
8. allows numbered variables to be loaded which then cannot be accessed efficiently without writing slow, buggy, obfuscated code.

"So you suggest every one should be always loading mat files into structures, then reading from the structures."

Yes. Basically all expert MATLAB users would themselves write code that load-s into a structure, because it is much more efficient, easier to debug, and much more reliable. All expert MATLAB users also give this advice to beginners because some beginners are also interested in learning how to write efficient and reliable code, e.g.:

https://www.mathworks.com/matlabcentral/answers/134091-variable-changes-value-after-using-load#answer_140751

This is also the advice that TMW staff give, e.g.:

https://www.mathworks.com/matlabcentral/answers/335253-mat-files-not-loading-correctly#answer_262994

https://www.mathworks.com/matlabcentral/answers/28676-why-use-x-load-myfile-mat

"and command who is not exactly the same as command whos"

Both whos and who are run-time introspection, which as the MATLAB documentation states, is not efficient: "Run-time introspection is computationally expensive"

source: https://www.mathworks.com/help/matlab/matlab_prog/techniques-for-improving-performance.html

Note that TMW staff clearly advise to avoid runtime introspection:

https://www.mathworks.com/matlabcentral/answers/320839-how-bad-is-the-performance-of-run-time-introspection

[John BG]

Really??

so if it so important and crucial to always load to a structure

1.

why is is that the command load allows users to load WITHOUT using a structure?

If so important, Mathworks would force the use of load with always a structure, it would return an error when attempting to load without structure output. wouldn't it?

But no, at Mathworks they allow load to load without structure, for the simplicity and time saving that represents not having to read a structure to retrieve the variables, and then remove the structure, completely unnecessary most of times loading from mat files.

2.

If it's true what you say, have you reported to Mathworks recommending the enforcement of load with always a structure?

to for instance return error when attempting to use load without

S=load ..

And if you did so, because something tells me you didn't report to Mathworks earlier than Veizal's question, report your opinion about the apparently critical importance of never using load without an output structure, what did Mathworks answer?

[Stephen23]

"Really??"

Yes. You can check these yourself, if you really want to learn something useful and improve your code.

"why is is that the command load allows users to load WITHOUT using a structure?"

As far as I can tell, for two reasons:

1. convenience when playing with data in the command window (see also discussions on command vs. function syntax). For this purpose it is very useful.
2. compatibility and historic reasons.

"Mathworks would force the use of load with always a structure..."

As has been discussed previously: just with like any other programming language it is up to the user to write code as well or as badly as they want, and it is not MATLAB's job to force people to write code in one particular way. If a beginner prefers to write slower, buggier, harder-to-debug code then that is their problem, not mine. All we can do is show them how they could write better code.

So far you are the only one who has suggested that load itself should be changed, no one else has suggested this. It is certainly very convenient to use load from the command line, and play around with the data: in that situation any inefficiency, incorrect syntax checking, overwriting, or variable tracking is usually not of primary concern. But when code is written to be robust, efficient, neat, reliable, easy to debug, etc., then a different coding paradigm is required to when someone is simply mucking about in the command window. Learning this marks a significant step on the way to writing reliable, robust, efficient code.

[Jan]

@John BG: The documentation of Matlab, the comments by the staff and the common sense in the community of the users of this forum are clear and unequivocal in this point: Avoid the dynamic creation of variables, because it produces more problems than it solves.

If you have concerning questions, please open your own thread and learn from the answers. Insisting to teach bad programming techniques, ignoring the given explanations and hijacking one thread after the other by these tedious discussions is not welcome.

[Walter Roberson]

"But no, at Mathworks they allow load to load without structure, for the simplicity and time saving that represents not having to read a structure to retrieve the variables, and then remove the structure, completely unnecessary most of times loading from mat files."

Within a function, if loading to an output structure is used, then the JIT can create a slot for the structure at parsing time, and hang the content of the input structure off of the known slot at execution time, and when the structure is used, it already knows where the slot is, so the symbol table does not need to be search for the variable. The symbol table for the structure might need to be searched, but that is a limited context, with no possibility that the name is (for example) a shared variable or a global variable, so the field name lookup can be fast.

If you do not have eval() or assignin() in your code, and you do not have load() without an output, and you do not have cd(), then every variable-name slot can be "finalized": the contents might change (including the data type), but the location of the variable cannot change, including the scope of resolution.

If, however, one does a load without a structure output, or eval() or assignin(), then the JIT can only put in a tentative decision about how a name will be resolved, at most a hint, and at each point of execution after the load or eval, the code need to re-check whether a different variable was created with the same name that needs to be referred to instead. This is not a one-time patch-up, because the next time you load even from the same file, it might have different contents!

The load without output does not just affect the efficiency of access of the variables that are imported: it affects the efficiency of every variable referenced after that point. Including any loop control variables, since they might have been overwritten...

"There are 2 hard problems in computer science: cache invalidation, naming things, and off-by-1 errors." -- Leon Bambrick

load without an output is an example of cache invalidation.

So... in a function it is more efficient to load to a structure, reference a field of the structure, and then zap the structure, than it is to do a load without assignment.

Note: it is more efficient to assign [] to a variable name to free the memory associated with it than it is to "clear" the variable, as "clear" forces the name to be re-resolved if the variable is used again. For example, if you do

   pi = 1.234;
   clear pi
   sin(pi)

then this does not generate an error about using a deleted variable pi : it forces re-resolution of the name pi which will be found to be a function. (The pseudo-constants pi, i, and j, are implemented as functions.)

[John BG]

but who is going to use 'pi' for 1.234 while doing trigonometric operations !?!?

All your reasoning and explanations are not wrong, but they are completely unnecessary to solve this question.

Just focus on the question and forget your ultra advanced programming top skills

1. loading
2. get the complete list of variables
3. saving

I answered this question on August 20th, all the other contributions advocate the use of a structure that is completely unnecessary and diverts time, programmer's time, computer time, to reading, sorting structure fields that are not required in the context of this question.

Therefore, my answer deserves to be considered as the correct answer to this question.

[Stephen23]

".. ..advocate the use of a structure that is completely unnecessary and diverts time, programmer's time, computer time, to reading, sorting structure fields that are not required in the context of this question."

• "unnecessary": using a structure is not necessary as of course there are always other ways to solve any coding problem, and thus no particular code or tool could be regarded as necessary. But in this situation using a structure is very efficient, and certainly more efficient than any method using introspective commands, and also avoids all of the pitfalls of loading directly into the workspace.
• "diverts time, programmer's time": three simple lines of code and just three functions are surely not very taxing, even for beginners. It is not clear how eight lines of code and four functions is simpler for the programmer.
• "computer time": could you please show the timeit script and results that show that. I would be quite surprised if you made unfounded accusations, so I am sure that you have made these measurements, and I would be interested to see them. I am sure others would be interested as well.
• "sorting structure fields": can you please show where are these structure fields sorted? I cannot find any reference to sorting fields anywhere in this thread, except for in your comment.

@John BG: so far you have made statements but not provided any links, references, or measurements to back them up. You will note that previously I provided you with links to the MATLAB documentation explaining that introspection is inefficient, and to threads explaining some of the risks of loading directly into the workspace: I would expect you to have the same decency and provide the references and measurements that justify your statements. It would be extremely disappointing if your comments and criticisms of my answer were unfounded.

[Jan]

@John BG: You almost got the point now:

 all the other contributions advocate the use of a structure that
 is completely unnecessary and diverts time, programmer's time,
 computer time, to reading, sorting structure fields

Exactly this work is done much more efficiently inside a struct, than inside the list of variables in the workspace. Inside a struct the JIT and the programmer can manage these data efficiently, but inside the workspace this is not possible in theory and practice.

This has been explained repeatedly and insisting on claiming the opposite is not reasonable anymore.

Your arguments for advertising your answer are weak. I do not consider your answer to deserve to be accepted and I've voted for the better solutions.

Your criticism does not help to solve the problem and advertising an own answer as comment to another answer is awkward.

[Walter Roberson]

"but who is going to use 'pi' for 1.234 while doing trigonometric operations !?!?"

Less than two weeks ago someone was using "pi" as the name of a variable for pressure intensity calculations. We recommended against that, but the user really wanted to use it...

pi was just a convenient example of demonstrating that clear forces complete re-resolution of variable names in a way that assignment of the empty array does not. If you prefer you could imagine

   sum = 0;
   for k=1:20
     sum = sum + X(k, :); 
   end

Then if the user does

   clear sum
   sum(1:2)

then this is not an error about attempting to reference a deleted variable: instead MATLAB had to go through the entire variable resolution process to find the sum function that is appropriate for the input datatype. Exactly the same process would have been used if the user had used total as the variable name instead.

[John BG]

ok,

this discussion is diverging to trigonometric basics.

The point is, Veizal has a reshaped image histogram in one variable, and another reshaped histogram in another variable clearly named differently,

featureSize=size(n); 
featuresN=reshape(n,1,featureSize(1));  %jumlah piksel 
featureSize=size(xout); 
featuresXout=reshape(xout,1,featureSize(1));  %save ke databasefitur 
databaseFitur2=[featuresN;featuresXout];

.

It's simple, there's absolutely no need for an additional complicated structure, at all

As simple as putting 2 variables in one .mat file, Veizal already tries with this line

save('databaseFitur2','databaseFitur2');

 and the objective of the question is to merge 2 .mat files with such variables into 1 .mat file.

Why do you want Veizal bring the whole toolbox when there's only need for 1 and only one Philips size 11 ??

Please don't mention that because the majority says 'use struct' then a structure has to be used.

It's not about democracy, democracies can also go wrong, as history irrevocably proves.

Don't you all agree that it's about serving the right answer to Veizal?

You are telling Veizal to use a structure, but there's no need for a structure. It's about putting 2 image histograms clearly named with distinct variable names in 2 .mat files into another .mat file, or merge them.

Please any one help me solve this question by choosing my answer as the correct answer and I will owe you one correct answer. Point at another jammed question of yours, and I will see what can be done to fix the jamming.

Appreciating time and attention

[José-Luis]

Please any one help me solve this question by choosing my answer as the correct answer and I will owe you one correct answer. To use a popular term these days: That's collusion!

On a comedy level, it's fun to think that OP might never read this and has probably moved on with his life.

[Adam]

'You are telling Veizal to use a structure, but there's no need for a structure'

Where does this notion of 'need' come from? Your answer tells him to write 8 or 10 lines of code using whos and matfile. He doesn't 'need' to use either to achieve his aim. Irrespective of any arguments of general good code, the use of a struct is incidental other than that it allows for a neat 3 line solution that doesn't require all those other lines of code. That is the simplest reason to use a struct - because it results in clear, short, easy to understand code.

[Jan]

Sorry, do we really need to discuss the difference between

S = load('B.mat');
save('A.mat', '-struct', 'S', '-append')

and:

load('file1.mat')
load('file2.mat')
matobj1=matfile('file1.mat')
matobj2=matfile('file2.mat')
L1=who(matobj1)'
L2=who(matobj2)'
L={L1{:} L2{:}}
save('file3.mat',L{:})

? Beside the obvious advantages the problems of load without catching the output have been explained already.

This discussion provides time and attention to John BG, but does not help to solve the problem of the OP anymore.

Answer 3

[Jan]

It depends on what you want to merge: The data or the saved fields.

• Case 1: The data:

Data = rand(255, 2);  % Some test data
save('YourFile.mat', 'Data');
...
Data     = rand(255, 2);  % Some test data
FileCont = load('YourFile.mat');
Data     = cat(1, FileCont.Data, Data);   % Merge the data
save('YourFile.mat', 'Data');

Now the file contains a [512 x 2] matrix.

• Case 2: The fields:

Data1 = rand(255, 2);  % Some test data
save('YourFile.mat', 'Data1');
...
Data2 = rand(255, 2);  % Some test data
save('YourFile.mat', 'Data2', '-append');

Now the file contains the 2 fields 'Data1' and 'Data2'.

Answer 4

[John BG]

Hi Veizal Rasyid

this is John BG <mailto:[e-mail] [e-mail]>

combining mat files into a single mat file is simple:

1.

load the mat files in the workspace

load('file1.mat')
load('file2.mat')

2.

get the handles of each input mat file

matobj1=matfile('file1.mat')
matobj2=matfile('file2.mat')

3.

get the names of the variables contained in each input mat file

L1=who(matobj1)'
L2=who(matobj2)'

4.

built a complete list of variable names to save in resulting mat file

L={L1{:} L2{:}}

5.

save all variables in output mat file

save('file3.mat',L{:})

6.

check

clear all
load file3.mat

if you find this answer useful would you please be so kind to consider marking my answer as Accepted Answer?

To any other reader, if you find this answer useful please consider clicking on the thumbs-up vote link

thanks in advance

John BG

<mailto:[e-mail] [e-mail]>

[Walter Roberson]

Instead of using matfile() and who() to find the variable names, you could instead whos() the file:

L1 = whos('-file', 'file1.mat');
L2 = whos('-file', 'file2.mat');
L = {L1.name, L2.name};