Out of memory ошибка matlab

Clear Variables When No Longer Needed

Make it a practice to clear variables when they are no longer needed. To clear
items from memory, use the clear function.

A = rand(1e4);
disp(max(A,[],"all"))
B = rand(1e4);

A = rand(1e4);
disp(max(A,[],"all"))
clear A
B = rand(1e4);

For more information, see Strategies for Efficient Use of Memory.

Use Appropriate Data Storage

Memory requirements differ for MATLAB data types. You might be able to reduce the amount of memory used
by your code by using the appropriate data type and storage. For more
information about the solutions in this section, see Strategies for Efficient Use of Memory.

Use the Appropriate Numeric Class.  The numeric class you should use depends on your intended actions. In
MATLAB, double is the default numeric data type
and provides sufficient precision for most computational tasks:

Reduce the Amount of Overhead When Storing Data.  When you create a numeric or character array, MATLAB allocates a block of memory to store the array data.
MATLAB also stores information about the array data, such as its
class and dimensions, in a small, separate block of memory called a
header. Because simple numeric and character arrays
have the least overhead, use them whenever possible. Use other data
structures only for data that is too complex to store in a simple
array.

For structures and cell arrays, MATLAB creates a header not only for the array, but also for each
field of the structure or each cell of the cell array. Therefore, the amount
of memory required to store a structure or cell array depends not only on
how much data it holds, but also on how it is constructed. As a result, cell
arrays with many small elements or structures with many fields containing
little content have large overhead and should be avoided.

% S has 15,000 fields (3 fields per array element)
for i = 1:100
    for j = 1:50
        S(i,j).R = 0;  % Each field contains a numeric scalar
        S(i,j).G = 0;
        S(i,j).B = 0;
    end
end

% S has 3 fields 
S.R = zeros(100,50);  % Each field contains a numeric array
S.G = zeros(100,50);
S.B = zeros(100,50);

Make Arrays Sparse When Possible.  A good practice is to store matrices with few nonzero elements using
sparse storage. When a full matrix has a small number of nonzero elements,
converting the matrix to sparse storage typically improves memory usage and
code execution time. MATLAB has several functions that support sparse storage. For
example, you can use the speye function to create a
sparse identity matrix.

I = eye(1000);

I = speye(1000);

Import Data Using the Appropriate MATLAB Class.  When reading data from a binary file with fread, a common mistake is
to specify only the class of the data in the file and not the class of the
data MATLAB uses once it is in the workspace. If you do not specify the
class of the data in memory, MATLAB uses double even if you read 8-bit
values.

fileID = fopen("large_file_of_uint8s.bin","r"); 
A = fread(fileID,1e3,"uint8"); 

fileID = fopen("large_file_of_uint8s.bin","r"); 
A = fread(fileID,1e3,"uint8=>uint8"); 

Avoid Unnecessary Copies of Data

To improve memory usage and execution speed, make sure your code does not
result in unnecessary copies of data. For more information about the solutions
in this section, see Avoid Unnecessary Copies of Data and Strategies for Efficient Use of Memory.

Avoid Creating Temporary Arrays.  Avoid creating temporary arrays when they are not necessary. For example,
instead of creating an array of zeros as a temporary variable and then
passing that variable to a function, use one command to do both
operations.

A = zeros(1e6,1);
As = single(A);

As = zeros(1e6,1,"single");

Preallocate Memory.  When you work with large data sets, repeatedly resizing arrays might cause
your program to run out of memory. If you expand an array beyond the
available contiguous memory of its original location, MATLAB must make a copy of the array and move the copy into a memory
block with sufficient space. During this process, two copies of the original
array exist in memory. You can improve the memory usage and code execution
time by preallocating the maximum amount of space required for the array.
For more information, see Preallocation.

x = 0;
for k = 2:1000000
   x(k) = x(k-1) + 5;
end

x = zeros(1,1000000);
for k = 2:1000000
   x(k) = x(k-1) + 5;
end

Use Nested Functions to Pass Fewer Arguments.  When calling a function, MATLAB typically makes a temporary copy of the variable in the
caller’s workspace if the function modifies its value. MATLAB applies various techniques to avoid making unnecessary copies,
but avoiding a temporary copy of an input variable is not always
possible.

One way to avoid temporary copies in function calls is to use nested
functions. A nested function shares the workspace of all outer functions, so
you do not need to pass a copy of variables in the function call. For more
information, see Nested Functions.

Load Only as Much Data as You Need

One way to fix memory issues is to import into MATLAB only as much of a large data set as you need for the problem you
are trying to solve. Data set size is not usually a problem when importing from
sources such as a database, where you can explicitly search for elements
matching a query. But it is a common problem with loading large flat text or
binary files.

The datastore function lets you
work with large data sets incrementally. Datastores are useful any time you want
to load only some portions of a data set into memory at a time.

To create a datastore, provide the name of a file or a directory containing a
collection of files with similar formatting. For example, with a single file,
use the
following.

ds = datastore("path/to/file.csv");

Or
with a collection of files in a folder, use the
following.

ds = datastore("path/to/folder/");

You
also can use the wildcard character * to select all files of
a specific
type.

ds = datastore("path/to/*.csv");

Datastores
support a wide variety of file formats (tabular data, images, spreadsheets, and
so on). For more information, see Select Datastore for File Format or Application.

Aside from datastores, MATLAB also has several other functions to load parts of files. This
table summarizes the functions by the type of files they operate on.

Use Tall Arrays

Tall arrays help you work with data sets that are too large to fit in memory.
MATLAB works with small blocks of the data at a time, automatically
handling all of the data chunking and processing in the background. You can use
tall arrays in two primary ways:

To learn more about tall arrays, see Tall Arrays for Out-of-Memory Data.

Use Memory of Multiple Machines

If you have a cluster of computers, you can use distributed arrays (requires
Parallel Computing Toolbox™) to perform calculations using the combined memory of all the
machines in the cluster. Depending on how your data fits in memory, different
ways to partition data among workers of a parallel pool exist. For more
information, see Distributing Arrays to Parallel Workers (Parallel Computing Toolbox).

Adjust Settings and Preferences

Generally, rewriting code is the most effective way to improve memory
performance. However, if you cannot make changes to your code, these solutions
might provide it with the required amount of memory.

Start MATLAB Without Java Virtual Machine or Decrease the Java Heap Size.  If you either start MATLAB without the Java^® Virtual Machine (JVM™) software or decrease the Java heap size, you can increase the available workspace memory. To
start MATLAB without JVM, use the command-line option -nojvm. For
information on how to decrease the Java heap size, see Java Heap Memory Preferences.

Using -nojvm comes with a penalty in that you lose
several features that rely on JVM, such as the desktop tools and graphics. Starting MATLAB with the -nodesktop option does not save
any substantial amount of memory.

Adjust the Array Size Limit.  If you face an error stating that the array size exceeds the maximum array
size preference, you can adjust this array size limit in MATLAB. For information on adjusting the array size limit, see Workspace and Variable Preferences. This solution is helpful only if the
array you want to create exceeds the current maximum array size limit but is
not too large to fit in memory. Even if you turn off the array size limit,
attempting to create an unreasonably large array might cause MATLAB to run out of memory, or it might make MATLAB or even your computer unresponsive due to excessive memory
paging.