KAHIBARO Bookshelves
Discord Login Register

13.4. Adding Equations, Images, and Outputs

Working with Rich Content in Live Scripts

MATLAB live scripts let you mix executable code, formatted text, equations, images, and outputs in a single document. This chapter focuses on adding equations, images, and controlling how outputs appear, all inside a live script.

Adding Equations with LaTeX

In a live script, you can write mathematical equations directly in text using LaTeX syntax. You do this in text regions, not code regions.

To insert a text region, place the cursor where you want it, then switch the line or section to text using the live editor toolbar. Once you are in a text area, you can insert an equation.

For inline equations that appear inside a sentence, surround LaTeX code with single dollar signs. For example, in a text region write:

The quadratic formula is $x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$.

In the rendered live script, this displays as standard mathematical notation.

For display equations that appear centered on their own line, use double dollar signs. For example, in text:

$$\int_0^1 x^2 \, dx = \frac{1}{3}$$

This displays the integral neatly as a separate line.

MATLAB live scripts understand a large subset of LaTeX math syntax. You can use exponents such as $x^2$, subscripts such as $a_1, a_2, \dots, a_n$, fractions with \frac{numerator}{denominator}, square roots with \sqrt{ }, and Greek letters such as \alpha, \beta, or \lambda. You can also write matrices, for example:

$$A = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix}$$

The live editor previews equations immediately, so you can adjust your LaTeX until it looks correct. If an equation does not render, check for missing closing dollar signs, unbalanced braces, or unsupported LaTeX commands.

You can mix formatted text and equations to create self-contained explanations next to code. For instance, you may describe an algorithm in words, present the mathematical formula in LaTeX, and then follow with the MATLAB code that implements it.

Inserting and Displaying Images

You can include images in live scripts to illustrate concepts, show external figures, or display logos and diagrams.

There are two main ways to bring images into a live script. The first is to insert an image as part of the document’s text. In a text region, you can use the toolbar to insert an image from a file. This image becomes embedded in the live script and appears where you place it in the text flow. You can usually resize it by dragging its corners and align it with the surrounding text.

The second method is to generate images programmatically inside code sections. For example, if you read an image from a file and display it with a plotting function, the resulting figure appears directly below that code when you run the section. A typical pattern is:

img = imread('peppers.png');
imshow(img);

In a live script, the image shown by imshow is captured as an inline output in the document. This is different from the classic figure window, because the result is attached to the code section and saved in the live script.

You can combine both approaches. For example, you may include a static diagram as an inserted image in a text region, and next to it show a MATLAB generated visualization produced by code. This is useful for teaching, reports, or interactive documents where you want both explanations and computed graphics in one place.

MATLAB live scripts also let you update images when you rerun code. If your script loads different image files depending on parameters, the displayed output will change accordingly, while the textual content and any manually inserted images stay the same until you edit them.

Controlling Code Outputs in Live Scripts

Live scripts automatically capture and display outputs from code sections, including numeric results, tables, and plots. For beginners this is very helpful, but it is also important to learn how to control which outputs appear.

Numeric and textual outputs behave similarly to the command window. Any expression you enter at the end of a line without a semicolon shows its result. For example, in a live script code section:

x = 1:5;
x

The variable x is displayed as an output under that code section. If you do not want that intermediate result to appear, end the line with a semicolon:

x = 1:5;

The assignment still happens, but no output is shown in the live script. You can selectively show only important results by omitting the semicolon on certain lines, for example:

x = 0:0.1:2*pi;
y = sin(x);
max_y = max(y);
max_y

Here, the intermediate arrays x and y remain hidden, and only the scalar max_y appears.

Some functions print textual information directly, such as disp or fprintf. In a live script, these messages appear as text output below the code, which can be useful for labeling results. For instance:

r = rand(1,3);
disp('Random row vector:');
disp(r);

The printed lines are part of the stored output and will update when you rerun the section.

Graphical outputs such as plots or images appear automatically when you call plotting or display functions. You can generate multiple outputs from a single code section, for example a numeric result and several figures, and they will all be stacked underneath the code region in the order they are created.

Sometimes you may want to hide all outputs from a section while keeping the computations. One approach is to end all lines with semicolons and avoid any explicit display functions. Another is to split your script into multiple sections, so that only the section that summarizes or visualizes the final result produces visible outputs, while earlier sections purely prepare the data.

Combining Explanations, Equations, Images, and Outputs

The real strength of live scripts comes from integrating text, equations, images, and code outputs into a single flow. A common pattern is to start with a text section describing a problem in words, followed by an equation that expresses the mathematics, then code that implements the method, and finally the resulting output or plot.

For example, you might write a short description of a damped oscillator, include the differential equation in LaTeX, insert an image illustrating the physical system, and then add a code section that simulates and plots the motion. Each part sits in the same document, so someone reading it can see the reasoning, the mathematics, and the computed behavior together.

You can also alternate explanation and computation. For instance, after a plot output, you may insert a text region that interprets the graph, perhaps adding another equation to explain a feature in the data, then continue with further code that refines the analysis.

By using text styling, equations with LaTeX, embedded images, and carefully chosen code outputs, you can turn a live script into a readable and reproducible report that is easier to understand than raw code alone.

Key points to remember:
Write equations only in text regions, using $...$ for inline math and $$...$$ for display equations.
Use LaTeX syntax for mathematical symbols, fractions, roots, and matrices.
Insert images either directly into text regions or generate them with code so they appear as outputs.
Control numeric and textual outputs with semicolons and display functions to show only what is important.
Combine explanations, equations, images, and outputs to create clear, self-contained live scripts.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

Where to Move

Move chapter:

  • ☰ 1. Getting Started with MATLAB
    • ☰ 1.1. What Is MATLAB and What Is It Used For
      • ☰ 1.2. Installing MATLAB and Setting Up the Environment
        • ☰ 1.3. Understanding the MATLAB Desktop Interface
          • ☰ 1.4. Command Window, Workspace, and Current Folder
            • ☰ 1.5. Basic Workflow and Running Simple Commands
              • ☰ 1.6. Getting Help and Documentation
              • ☰ 2. MATLAB Language Basics
                • ☰ 2.1. MATLAB Syntax and Expressions
                  • ☰ 2.2. Variables and Assignment
                    • ☰ 2.3. Data Types and Type Conversion
                      • ☰ 2.4. Vectors and Matrices Fundamentals
                        • ☰ 2.5. Creating and Indexing Arrays
                          • ☰ 2.6. Basic Arithmetic and Elementwise Operations
                            • ☰ 2.7. Using Built-In Constants and Functions
                            • ☰ 3. Working with Variables and the Workspace
                              • ☰ 3.1. Creating, Viewing, and Editing Variables
                                • ☰ 3.2. Workspace Browser and Variable Inspector
                                  • ☰ 3.3. Saving and Loading Data Files
                                    • ☰ 3.4. MAT-Files and Importing External Data
                                      • ☰ 3.5. Clearing Variables and Managing the Workspace
                                      • ☰ 4. Vectors, Matrices, and Arrays
                                        • ☰ 4.1. Row and Column Vectors
                                          • ☰ 4.2. Matrix Creation and Concatenation
                                            • ☰ 4.3. Indexing, Slicing, and Logical Indexing
                                              • ☰ 4.4. Matrix Operations vs Elementwise Operations
                                                • ☰ 4.5. Reshaping and Rearranging Arrays
                                                  • ☰ 4.6. Special Matrices and Functions
                                                  • ☰ 5. Basic Programming Constructs
                                                    • ☰ 5.1. Scripts vs Functions
                                                      • ☰ 5.2. Control Flow with if, elseif, else
                                                        • ☰ 5.3. Loops with for and while
                                                          • ☰ 5.4. break, continue, and return
                                                            • ☰ 5.5. Logical Expressions and Relational Operators
                                                              • ☰ 5.6. Best Practices for Clear and Readable Code
                                                              • ☰ 6. Functions in MATLAB
                                                                • ☰ 6.1. Creating Simple Functions
                                                                  • ☰ 6.2. Function Inputs and Outputs
                                                                    • ☰ 6.3. Function Files and the Path
                                                                      • ☰ 6.4. Local vs Global Variables
                                                                        • ☰ 6.5. Anonymous Functions
                                                                          • ☰ 6.6. Organizing Code into Multiple Functions
                                                                          • ☰ 7. Working with Numbers and Math
                                                                            • ☰ 7.1. Scalars and Vectorized Computations
                                                                              • ☰ 7.2. Basic Mathematical Functions
                                                                                • ☰ 7.3. Trigonometric and Exponential Functions
                                                                                  • ☰ 7.4. Complex Numbers in MATLAB
                                                                                    • ☰ 7.5. Rounding, Modulo, and Special Values
                                                                                      • ☰ 7.6. Numerical Precision and Floating Point Considerations
                                                                                      • ☰ 8. Strings, Characters, and Categorical Data
                                                                                        • ☰ 8.1. Character Arrays and String Arrays
                                                                                          • ☰ 8.2. Creating and Manipulating Strings
                                                                                            • ☰ 8.3. Converting Between Data Types and Strings
                                                                                              • ☰ 8.4. Comparing and Searching Strings
                                                                                                • ☰ 8.5. Categorical Arrays Basics
                                                                                                • ☰ 9. Tables, Structures, and Cell Arrays
                                                                                                  • ☰ 9.1. Introduction to Tables
                                                                                                    • ☰ 9.2. Creating Tables and Accessing Data
                                                                                                      • ☰ 9.3. Modifying and Joining Tables
                                                                                                        • ☰ 9.4. Structures and Nested Structures
                                                                                                          • ☰ 9.5. Cell Arrays and Cell Indexing
                                                                                                            • ☰ 9.6. Choosing the Right Container Type
                                                                                                            • ☰ 10. Importing and Exporting Data
                                                                                                              • ☰ 10.1. Reading Text and CSV Files
                                                                                                                • ☰ 10.2. Importing Excel Spreadsheets
                                                                                                                  • ☰ 10.3. Importing Data with the Import Tool
                                                                                                                    • ☰ 10.4. Exporting Data to Files
                                                                                                                      • ☰ 10.5. Working with Image and Audio Files
                                                                                                                        • ☰ 10.6. Basic File Management from MATLAB
                                                                                                                        • ☰ 11. Plotting and Visualization
                                                                                                                          • ☰ 11.1. Introduction to 2D Plotting
                                                                                                                            • ☰ 11.2. Customizing Plots and Axes
                                                                                                                              • ☰ 11.3. Multiple Plots in One Figure
                                                                                                                                • ☰ 11.4. Labels, Titles, Legends, and Annotations
                                                                                                                                  • ☰ 11.5. Plotting with Different Line and Marker Styles
                                                                                                                                    • ☰ 11.6. Saving and Exporting Figures
                                                                                                                                    • ☰ 12. Advanced Plotting for Beginners
                                                                                                                                      • ☰ 12.1. Subplots and Tiled Layouts
                                                                                                                                        • ☰ 12.2. Bar, Scatter, and Stem Plots
                                                                                                                                          • ☰ 12.3. Histograms and Density Plots
                                                                                                                                            • ☰ 12.4. 3D Plots and Surface Plots
                                                                                                                                              • ☰ 12.5. Using plottools and Interactive Editing
                                                                                                                                                • ☰ 12.6. Basics of Handle Graphics
                                                                                                                                                • ☰ 13. Working with Scripts and Live Scripts
                                                                                                                                                  • ☰ 13.1. Creating and Running Script Files
                                                                                                                                                    • ☰ 13.2. Sectioning Code and Running Sections
                                                                                                                                                      • ☰ 13.3. Live Scripts and Rich Text
                                                                                                                                                        • ☰ 13.4. Adding Equations, Images, and Outputs
                                                                                                                                                          • ☰ 13.5. Sharing and Exporting Live Scripts
                                                                                                                                                          • ☰ 14. Debugging and Code Quality
                                                                                                                                                            • ☰ 14.1. Finding and Fixing Syntax Errors
                                                                                                                                                              • ☰ 14.2. Setting Breakpoints and Stepping Through Code
                                                                                                                                                                • ☰ 14.3. Inspecting Variable Values During Execution
                                                                                                                                                                  • ☰ 14.4. Using the Editor Debugging Tools
                                                                                                                                                                    • ☰ 14.5. Using Code Analyzer and Warnings
                                                                                                                                                                      • ☰ 14.6. Writing Clean and Maintainable MATLAB Code
                                                                                                                                                                      • ☰ 15. Basic Linear Algebra with MATLAB
                                                                                                                                                                        • ☰ 15.1. Vectors and Norms
                                                                                                                                                                          • ☰ 15.2. Matrix Addition and Multiplication
                                                                                                                                                                            • ☰ 15.3. Solving Linear Systems with Backslash
                                                                                                                                                                              • ☰ 15.4. Inverses, Determinants, and Rank
                                                                                                                                                                                • ☰ 15.5. Eigenvalues and Eigenvectors
                                                                                                                                                                                  • ☰ 15.6. Using Linear Algebra Functions Safely
                                                                                                                                                                                  • ☰ 16. Data Analysis and Statistics Fundamentals
                                                                                                                                                                                    • ☰ 16.1. Descriptive Statistics and Summary Measures
                                                                                                                                                                                      • ☰ 16.2. Sorting, Filtering, and Grouping Data
                                                                                                                                                                                        • ☰ 16.3. Basic Correlation and Regression
                                                                                                                                                                                          • ☰ 16.4. Simple Data Cleaning Techniques
                                                                                                                                                                                            • ☰ 16.5. Basic Time Series Handling
                                                                                                                                                                                            • ☰ 17. Working with Time and Dates
                                                                                                                                                                                              • ☰ 17.1. Representing Dates and Times
                                                                                                                                                                                                • ☰ 17.2. Creating and Formatting datetime Arrays
                                                                                                                                                                                                  • ☰ 17.3. Date Calculations and Differences
                                                                                                                                                                                                    • ☰ 17.4. Plotting Data over Time
                                                                                                                                                                                                    • ☰ 18. Introduction to Signal and Image Handling
                                                                                                                                                                                                      • ☰ 18.1. Basic Signal Representation in MATLAB
                                                                                                                                                                                                        • ☰ 18.2. Simple Filtering and Transformations
                                                                                                                                                                                                          • ☰ 18.3. Reading, Displaying, and Writing Images
                                                                                                                                                                                                            • ☰ 18.4. Basic Image Transformations
                                                                                                                                                                                                            • ☰ 19. Automation and Scripting Tasks
                                                                                                                                                                                                              • ☰ 19.1. Batch Processing of Files
                                                                                                                                                                                                                • ☰ 19.2. Writing Reusable Utility Scripts
                                                                                                                                                                                                                  • ☰ 19.3. Using Relative Paths and the MATLAB Path
                                                                                                                                                                                                                    • ☰ 19.4. Simple User Interaction with input and disp
                                                                                                                                                                                                                    • ☰ 20. Introduction to Toolboxes
                                                                                                                                                                                                                      • ☰ 20.1. What Are Toolboxes and How to Use Them
                                                                                                                                                                                                                        • ☰ 20.2. Exploring Installed Toolboxes
                                                                                                                                                                                                                          • ☰ 20.3. Finding Functions in Toolboxes
                                                                                                                                                                                                                            • ☰ 20.4. Add-Ons and MATLAB File Exchange
                                                                                                                                                                                                                            • ☰ 21. Best Practices and Next Steps
                                                                                                                                                                                                                              • ☰ 21.1. Organizing Projects and Folders
                                                                                                                                                                                                                                • ☰ 21.2. Version Control Basics with MATLAB
                                                                                                                                                                                                                                  • ☰ 21.3. Performance Tips for Beginners
                                                                                                                                                                                                                                    • ☰ 21.4. Learning Resources and Documentation Path
                                                                                                                                                                                                                                      • ☰ 21.5. Suggested Practice Projects for Beginners