Matlab catch error

try, catch

try
   statements
catch exception
   statements
end

Описание

A = rand(3);
B = ones(5);

C = [A; B];

Error using vertcat
Dimensions of matrices being concatenated are not consistent.

try
   C = [A; B];
catch ME
   if (strcmp(ME.identifier,'MATLAB:catenate:dimensionMismatch'))
      msg = ['Dimension mismatch occurred: First argument has ', ...
            num2str(size(A,2)),' columns while second has ', ...
            num2str(size(B,2)),' columns.'];
        causeException = MException('MATLAB:myCode:dimensions',msg);
        ME = addCause(ME,causeException);
   end
   rethrow(ME)
end 

Error using vertcat
Dimensions of matrices being concatenated are not consistent.

Caused by:
    Dimension mismatch occurred: First argument has 3 columns while second has 5 columns.

try
    a = notaFunction(5,6);
catch
    warning('Problem using function.  Assigning a value of 0.');
    a = 0;
end

Warning: Problem using function.  Assigning a value of 0.

try
    a = notaFunction(5,6);
catch ME
    switch ME.identifier
        case 'MATLAB:UndefinedFunction'
            warning('Function is undefined.  Assigning a value of NaN.');
            a = NaN;
        case 'MATLAB:scriptNotAFunction'
            warning(['Attempting to execute script as function. '...
                'Running script and assigning output a value of 0.']);
            notaFunction;
            a = 0;
        otherwise
            rethrow(ME)
    end
end

Warning: Function is undefined.  Assigning a value of NaN. 

Представлено до R2006a

Exception Handling is a mechanism used to resolve/handle Runtime errors that arise during the execution of a program. Most programming languages offer some level of exception handling to deal with errors that arise while the program is executing. Exception handling deals with these events to avoid the program or system crashing, and without this process, exceptions would disrupt the normal flow of a program. In MATLAB, this feature is provided in form of try-catch constructs. 

In this article, we will learn to incorporate exception handling in MATLAB using the try-catch construct.

Syntax:

try

    statements

catch

    statements

end

The statements within the try block are executed. If any statement in the try block produces an error, program control goes immediately to the catch block, which contains exception handling statements. If no errors arise during the execution of the try block, the catch block won’t be executed. The end keyword is used to denote the end of the try-catch clause (could be used to denote the end of other constructs as well). try-catch blocks could be nested. try-catch statements are useful if

• Want to finish the program in ways that avoid errors.
• Side effects of the error are to be cleaned.
• Have many problematic input parameters or commands.

Try-Catch Usage in MATLAB:

In this example, we would explicitly produce an error (Matlab: UndefinedFunction) within the try block and would respond to it within the catch block.

Example 1:

Output:

The function is undefined

Explanation:

In the above code, we try to call a function named fun within the try block. Since the function hasn’t been defined it led to an error. This error got handled by the catch block, leading to the execution of the statements within. This led to “this function is undefined” being displayed in the output, denoting that an error occurred within the try block and the catch block did get executed.  If the function was called without placing it within the try block, it would have led to an error and program termination. But since we are using try-catch, this code catches any exception and repackages it as a warning, allowing MATLAB to continue executing subsequent commands.

The above was a very trivial example of the usage of try-catch. But in practice, a way more specific usage of the construct is required. i.e. In the above code, the catch statement would handle any exception produced within the try block whether or not it was required to be resolved or not. This allows certain errors to slip by as everything got handled by the catch statement. So in practice, it is generally advised to mention the error that is required to be handled if it arises. In the subsequent code, we would learn how to determine which error got handled, and to extract information/change the flow of the code based on it.

Example 2:

Output:

MATLAB:UndefinedFunction
Function is undefined

Explanation:

Where the error identifier is displayed at first, then a switch case based on the identifier got executed and displayed Function is undefined. This is because the error that got produced is because of an undefined function. If the error is produced by some other reason (divide by zero, non-matching dimension, etc.) Some other errors that occurred would be displayed along with the identifier of the error. 

try , catch

Execute statements and catch resulting errors

Syntax

Description

try statements , catch statements end executes the statements in the try block and catches resulting errors in the catch block. This approach allows you to override the default error behavior for a set of program statements. If any statement in a try block generates an error, program control goes immediately to the catch block, which contains your error handling statements.

exception is an MException object that allows you to identify the error. The catch block assigns the current exception object to the variable in exception .

Both try and catch blocks can contain nested try/catch statements.

Examples

Supplement Error Message

Create two matrices that you cannot concatenate vertically.

Use try/catch to display more information about the dimensions.

If matrix dimensions do not agree, MATLAB ® displays more information about the mismatch. Any other errors appear as usual.

Repackage Error as Warning

Catch any exception generated by calling the nonexistent function, notaFunction . If there is an exception, issue a warning and assign the output a value of 0.

By itself, the call to notaFunction results in an error. If you use try and catch , this code catches any exception and repackages it as a warning, allowing MATLAB to continue executing subsequent commands.

Handle Different Types of Errors

Use try/catch to handle different types of errors in different ways.

If the function notaFunction is undefined, issue a warning instead of an error and assign the output a value of NaN .

If notaFunction.m exists, but is a script instead of a function, issue a warning instead of an error, run the script, and assign the output a value of 0 .

If MATLAB throws an error for any other reason, rethrow the exception.

You cannot use multiple catch blocks within a try block, but you can nest complete try/catch blocks.

Unlike some other languages, MATLAB does not allow the use of a finally block within try/catch statements.

Extended Capabilities

Thread-Based Environment
Run code in the background using MATLAB® backgroundPool or accelerate code with Parallel Computing Toolbox™ ThreadPool .

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

Version History

R2022a: Improved performance when statements run error-free

The try block shows improved performance when the statements within the block run error-free. For example, this code is approximately 6x faster than in the previous release.

The approximate execution times are:

The code was timed on a Windows ® 10, Intel ® Xeon ® CPU E5-1650 v4 @ 3.60 GHz test system using the timeit function.

Источник

try , catch

Execute statements and catch resulting errors

Syntax

Description

try statements , catch statements end executes the statements in the try block and catches resulting errors in the catch block. This approach allows you to override the default error behavior for a set of program statements. If any statement in a try block generates an error, program control goes immediately to the catch block, which contains your error handling statements.

exception is an MException object that allows you to identify the error. The catch block assigns the current exception object to the variable in exception .

Both try and catch blocks can contain nested try/catch statements.

Examples

Supplement Error Message

Create two matrices that you cannot concatenate vertically.

Use try/catch to display more information about the dimensions.

If matrix dimensions do not agree, MATLAB ® displays more information about the mismatch. Any other errors appear as usual.

Repackage Error as Warning

Catch any exception generated by calling the nonexistent function, notaFunction . If there is an exception, issue a warning and assign the output a value of 0.

By itself, the call to notaFunction results in an error. If you use try and catch , this code catches any exception and repackages it as a warning, allowing MATLAB to continue executing subsequent commands.

Handle Different Types of Errors

Use try/catch to handle different types of errors in different ways.

If the function notaFunction is undefined, issue a warning instead of an error and assign the output a value of NaN .

If notaFunction.m exists, but is a script instead of a function, issue a warning instead of an error, run the script, and assign the output a value of 0 .

If MATLAB throws an error for any other reason, rethrow the exception.

You cannot use multiple catch blocks within a try block, but you can nest complete try/catch blocks.

Unlike some other languages, MATLAB does not allow the use of a finally block within try/catch statements.

Extended Capabilities

Thread-Based Environment
Run code in the background using MATLAB® backgroundPool or accelerate code with Parallel Computing Toolbox™ ThreadPool .

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

Version History

R2022a: Improved performance when statements run error-free

The try block shows improved performance when the statements within the block run error-free. For example, this code is approximately 6x faster than in the previous release.

The approximate execution times are:

The code was timed on a Windows ® 10, Intel ® Xeon ® CPU E5-1650 v4 @ 3.60 GHz test system using the timeit function.

Источник

error

Throw error and display message

Syntax

Description

error( msg ) throws an error and displays an error message.

error( msg , A1. An ) displays an error message that contains formatting conversion characters, such as those used with the MATLAB ® sprintf function. Each conversion character in msg is converted to one of the values A1. An .

error( errID , ___ ) includes an error identifier on the exception. The identifier enables you to distinguish errors and to control what happens when MATLAB encounters the errors. You can include any of the input arguments in the previous syntaxes.

error( errorStruct ) throws an error using the fields in a scalar structure.

error( correction , ___ ) provides a suggested fix for the exception. You can include any of the input arguments in the previous syntaxes.

Examples

Throw Error

Throw Error with Formatted Message

Throw a formatted error message with a line break. You must specify more than one input argument with error if you want MATLAB to convert special characters (such as n ) in the error message. Include information about the class of variable n in the error message.

If you only use one input argument with error , then MATLAB does not convert n to a line break.

Throw an error with an identifier.

Use the MException.last to view the last uncaught exception.

Throw Error Using Structure

Create structure with message and identifier fields. To keep the example simple, do not use the stack field.

Throw the error.

Throw Error with Suggested Fix

Create a function hello that requires one input argument. Add a suggested input argument «world» to the error message.

Call the function without an argument.

Input Arguments

msg — Information about error
text scalar containing format specification

Information about the error, specified as a text scalar containing format specification. This message displays as the error message. To format the message, use escape sequences, such as t or n . You also can use any format specifiers supported by the sprintf function, such as %s or %d . Specify values for the conversion specifiers via the A1. An input arguments. For more information, see Formatting Text.

Note

You must specify more than one input argument with error if you want MATLAB to convert special characters (such as t , n , %s , and %d ) in the error message.

Example: ‘File not found.’

errID — Identifier for error
text scalar containing component and mnemonic fields

Identifier for the error, specified as a text scalar containing component and mnemonic fields. Use the error identifier to help identify the source of the error or to control a selected subset of the errors in your program.

The error identifier includes one or more component fields and a mnemonic field. Fields must be separated with colon. For example, an error identifier with a component field component and a mnemonic field mnemonic is specified as ‘component:mnemonic’ . The component and mnemonic fields must each begin with a letter. The remaining characters can be alphanumerics (A–Z, a–z, 0–9) and underscores. No white-space characters can appear anywhere in errID . For more information, see MException .

Example: ‘MATLAB:singularMatrix’

Example: ‘MATLAB:narginchk:notEnoughInputs’

A1. An — Values
character vector | string scalar | numeric scalar

Values that replace the conversion specifiers in msg , specified as a character vector, string scalar, or numeric scalar.

errorStruct — Error reporting information
scalar structure

Error reporting information, specified as a scalar structure. The structure must contain at least one of these fields.

Error message. For more information, see msg .

Error identifier. For more information, see errID .

Stack field for the error. When errorStruct includes a stack field, error uses it to set the stack field of the error. When you specify stack , use the absolute file name and the entire sequence of functions that nests the function in the stack frame. This character vector is the same as the one returned by dbstack(‘-completenames’) .

correction — Suggested fix for this exception
matlab.lang.correction.AppendArgumentsCorrection object | matlab.lang.correction.ConvertToFunctionNotationCorrection object | matlab.lang.correction.ReplaceIdentifierCorrection object

When you throw an error, MATLAB captures information about it and stores it in a data structure that is an object of the MException class. You can access information in the exception object by using try/catch . Or, if your program terminates because of an exception and returns control to the Command Prompt, you can use MException.last .

MATLAB does not cease execution of a program if an error occurs within a try block. In this case, MATLAB passes control to the catch block.

If all inputs to error are empty, MATLAB does not throw an error.

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

Has no effect in standalone code even when run-time error detection is enabled. See Generate Standalone C/C++ Code That Detects and Reports Run-Time Errors (MATLAB Coder) .

Thread-Based Environment
Run code in the background using MATLAB® backgroundPool or accelerate code with Parallel Computing Toolbox™ ThreadPool .

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Usage notes and limitations:

This function accepts GPU arrays, but does not run on a GPU.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox) .

Источник

Error Handling

To make your code more robust, check for edge cases and problematic conditions. The simplest approach is to use an if or switch statement to check for a specific condition, and then issue an error or warning. try/catch statements allow you to catch and respond to any error.

MATLAB Language Syntax

Functions

Topics

To flag unexpected conditions when running a program, issue a warning. To flag fatal problems within the program, throw an error. Unlike warnings, errors halt the execution of a program.

Your program might issue warnings that do not always adversely affect execution. To avoid confusion, you can hide warning messages during execution by changing their states from ‘on’ to ‘off’ .

You can save the warning current states, modify warning states, and restore the original warning states. This technique is useful if you temporarily turn off some warnings and later reinstate the original settings.

You can control how warnings appear in MATLAB ® , including the display of warning suppression information and stack traces.

Use a try/catch statement to execute code after your program encounters an error.

It is a good programming practice to leave your program environment in a clean state that does not interfere with any other program code.

Источник

Matlab if error occurs

The MATLAB ® software, by default, terminates the currently running program when an exception is thrown. If you catch the exception in your program, however, you can capture information about what went wrong and deal with the situation in a way that is appropriate for the particular condition. This requires a try/catch statement.

The try/catch Statement

When you have statements in your code that could generate undesirable results, put those statements into a try/catch block that catches any errors and handles them appropriately.

A try/catch statement looks something like the following pseudocode. It consists of two parts:

A try block that includes all lines between the try and catch statements.

A catch block that includes all lines of code between the catch and end statements.

The program executes the statements in the try block. If it encounters an error, it skips any remaining statements in the try block and jumps to the start of the catch block (shown here as point A ). If all operations in the try block succeed, then execution skips the catch block entirely and goes to the first line following the end statement (point B ).

Specifying the try , catch , and end commands and also the code of the try and catch blocks on separate lines is recommended. If you combine any of these components on the same line, separate them with commas:

Note

You cannot define nested functions within a try or catch block.

The Try Block

On execution, your code enters the try block and executes each statement as if it were part of the regular program. If no errors are encountered, MATLAB skips the catch block entirely and continues execution following the end statement. If any of the try statements fail, MATLAB immediately exits the try block, leaving any remaining statements in that block unexecuted, and enters the catch block.

The Catch Block

The catch command marks the start of a catch block and provides access to a data structure that contains information about what caused the exception. This is shown as the variable ME in the preceding pseudocode. ME is an MException object. When an exception occurs, MATLAB creates an MException object and returns it in the catch statement that handles that error.

You are not required to specify any argument with the catch statement. If you do not need any of the information or methods provided by the MException object, just specify the catch keyword alone.

The MException object is constructed by internal code in the program that fails. The object has properties that contain information about the error that can be useful in determining what happened and how to proceed. The MException object also provides access to methods that enable you to respond to the exception.

Having entered the catch block, MATLAB executes the statements in sequence. These statements can attempt to

Attempt to resolve the error.

Capture more information about the error.

Switch on information found in the MException object and respond appropriately.

Clean up the environment that was left by the failing code.

The catch block often ends with a rethrow command. The rethrow causes MATLAB to exit the current function, keeping the call stack information as it was when the exception was first thrown. If this function is at the highest level, that is, it was not called by another function, the program terminates. If the failing function was called by another function, it returns to that function. Program execution continues to return to higher level functions, unless any of these calls were made within a higher-level try block, in which case the program executes the respective catch block.

Suggestions on How to Handle an Exception

The following example reads the contents of an image file. It includes detailed error handling, and demonstrates some suggested actions you can take in response to an error.

The image-reading function throws and catches errors in several ways.

The first if statement checks whether the function is called with an input argument. If no input argument is specified, the program throws an error and suggests an input argument to correct the error.

The try block attempts to open and read the file. If either the open or the read fails, the program catches the resulting exception and saves the MException object in the variable ME1 .

The catch block checks to see if the specified file could not be found. If so, the program allows for the possibility that a common variation of the filename extension (e.g., jpeg instead of jpg ) was used, by retrying the operation with a modified extension. This is done using a try/catch statement nested within the original try/catch .

This example illustrates some of the actions that you can take in response to an exception.

Compare the identifier field of the MException object to possible causes of the error. In this case, the function checks whether the identifier ends in ‘InvalidFid’ , indicating a file could not be found.

Use a nested try/catch statement to retry the operation with improved input. In this case, the function retries the open and read operations using a known variation of the filename extension.

Display an appropriate message.

Add the first MException object to the cause field of the second.

Add a suggested correction to an MException object.

Rethrow the exception. This stops program execution and displays the error message.

Cleaning up any unwanted results of the error is also advisable. For example, close figures that remained open after the error occurred.

MATLAB Command

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Источник

This note briefly discusses how to deal with exceptions in MATLAB. An exception is an event which occurs during the execution of a program and disrupts the normal flow of the program’s instructions. The process to deal with such exceptional events in the program is called Exception handling.

What is exception handling

Good code has to be able to handle exceptional (rare) situations that may occur during the code execution. These exceptions may occur during data input from either command line, terminal window, or an input file. They may also occur as a result of repeated operations on the input data, inside the code. For example, division by zero is an exceptional event in the program that any professionally-written program should be able to catch and handle nicely. Another example can be found in the discussion of data-transfer methods, where we explained a way of handling a wrong number of input command-line arguments. This and similar measures to handle the unexpected runtime situations that could lead to errors nicely is called exception handling.

A simple way of error handling is to write multiple if-blocks each of which handles a specific exceptional situation. In other words, let the code execute some statements, and if something goes wrong, write the program in such a way that it can detect this and jump to a set of statements that handle the erroneous situation as desired.

The try/catch statement

A more modern and flexible way of handling such potential exceptions in MATLAB is through MATLAB’s try/catch construction. You can use a try/catch statement to execute code after your program encounters an exception. The try/catch statements can be useful when,

• you Want to finish the program in another way that avoids errors (which could lead to abrupt interruption of the program) or,
• you want to nicely control the effects of error (for example, when a division by zero happens in your calculations) or,
• you have a function that could take many problematic parameters or commands as input.

The general syntax for try/catch statements is like the following pseudocode,

try
  try statements (all the normal things you would want to do)...
catch exception
  catch block (things to do when the try statements go wrong) ...
end

If an exception occurs within the try block, MATLAB skips any remaining commands in the try block and executes the commands in the catch block. If no error occurs within the try-block, MATLAB skips the entire catch block.

For example, suppose we wanted to read data from a webpage that does not exist,

>> webContent = webread('https://www.cdslab.org/non-existing-page.html')
Error using readContentFromWebService (line 45)
The server returned the status 404 with message "Not Found" in response to the request to URL https://www.cdslab.org/non-existing-page.html.
Error in webread (line 125)
[varargout{1:nargout}] = readContentFromWebService(connection, options); 

In such cases, it would be nice to control the behavior of the problem, and not allow MATLAB to end the program abruptly. We could therefore say,

>> try
    webContent = webread('https://www.cdslab.org/non-existing-page.html')
catch
    disp('The requested page does not exist! Gracefully exiting...')
end
The requested page does not exist! Gracefully exiting...