Course Code: 20EC0454 R20

SIDDHARTH INSTITUTE OF ENGINEERING & TECHNOLOGY

(AUTONOMOUS)
(Approved by AICTE, New Delhi& Affiliated to JNTUA, Ananthapuramu)
(Accredited by NBA for Civil, EEE, Mech., ECE & CSE)
(Accredited by NAAC with ‘A+’ Grade)
Puttur -517583, Tirupati District, A.P. (India)
QUESTION BANK WITH SOLUTION
Subject with MATLABPROGRAMMING(20EC0454) Course & B.Tech. – CSE, CSIT
Code Branch
Year & Sem IV-B.Tech.&I-Sem Regulation R20
UNIT-III
FUNCTIONS AND FILES
1.a. Discuss about Exponential and Logarithmic Functions in elementary mathematical function with
appropriate commands. [L1][CO1][6M]

Exponential and Logarithmic Functions

MATLAB has functions for computing exponents and logarithms for real and complex numbers.

 Exponential Function:
o Command: exp(x)
o Description: Computes e^x, where e is the base of natural logarithms (approximately 2.7183).
o Example:

result = exp(2); % Result is approximately 7.3891 (e^2)

 Natural Logarithm (Base e ):

o Command: log(x)
o Description: Computes the natural logarithm ln(x)\ln(x).
o Example:

result = log(10); % Result is approximately 2.3026

 Base-10 Logarithm:
o Command: log10(x)
o Description: Computes the base-10 logarithm log10(x).
o Example:

result = log10(100); % Result is 2, because log10(100) = 2

 Base-2 Logarithm:
o Command: log2(x)
o Description: Computes the base-2 logarithm log2(x).
o Example:

result = log2(8); % Result is 3, because log2(8) = 3

1. b. Compute the following using MATLAB commands.

a ¿ √ −144
3y
b) e
c) log10(2y)
Course Code: 20EC0454 R20
d) log (-4x). [L3][CO2][6M]

a) √ −144

 Since √−144 involves the square root of a negative number, the result will be a complex number.
 MATLAB Command:

Res=sqrt(-144);
disp(Res);

 Result : 12i

b) e 3 y

 MATLAB Command :

Y=[1 , 2] ;
res=exp(3 * y);
disp(res);

 Result : 20.0855 403.4288

 Explaination : The command exp(3 * y) calculates the exponential of each element in 3 * y, which
means it computes exp(3×1) and exp(3×2) for y = [1, 2]

C) log10(2y)

 MATLAB Command :

Y=[1 , 2 , 3] ;
res=log10(2 * y);
disp(res);

 Result : 0.3010 0.6021 0.7782

 Explaination : The command log10(2 * y) calculates the base-10 logarithm of each element in 2 *
y, which means it computes log10(2×1), log10(2×2), and log10(2×3) for y = [1, 2, 3]

d) log (-4x).

 MATLAB Command :

X = 5;
res=log(-4 * x);
disp(res);

 Result : 3.0445 + 3.1416i

Explaination : The command log(-4 * x) calculates the natural logarithm of -4 * x, which is

log(−20) when x=5.
Course Code: 20EC0454 R20
Since the logarithm of a negative number results in a complex number, MATLAB will return a complex
output.

2. a. Explain how complex functions are handled by MATLAB. Give some examples.

In MATLAB, a complex function is any function or operation that can handle and manipulate complex
numbers, which have both real and imaginary parts. Complex numbers in MATLAB are represented as
a+bi or a+bj, where a is the real part, b is the imaginary part, and i or j represents the imaginary unit
(equivalent to √ −1 ).

Creating a Complex Number

 Syntax: z = a + bi or z = complex(a, b)

 Here are some common functions and examples that demonstrate how MATLAB handles
complex functions:
 1. abs – Absolute Value (Magnitude)

 The abs function in MATLAB returns the magnitude (or modulus) of a complex number, which is
the distance from the origin to the point in the complex plane.
 Example:

z = 3 + 4i;
magnitude = abs(z); % Result: magnitude = 5

In this example, the magnitude of z=3+4i is √ 32 +4 2 =5 .

 2. angle – Phase Angle

 The angle function returns the phase angle (or argument) of a complex number, which is the
angle in radians between the positive real axis and the line connecting the origin to the point.
 Example:

z = 3 + 4i;
theta = angle(z); % Result: theta ≈ 0.9273 radians

Here, the phase angle for z=3+4i is approximately 0.9273 radians.

 3. real and imag – Real and Imaginary Parts

 The real function extracts the real part of a complex number, while imag extracts the imaginary
part.
 Example:

z = 5 - 2i;
real_part = real(z); % Result: real_part = 5
imaginary_part = imag(z); % Result: imaginary_part = -2

In this case, real_part is 5, and imaginary_part is -2 for z=5−2i.

2. b. Explain the following MATLAB commands with suitable examples.

a)The round function,
b) The ceilfunction,

c) The floor function.

Course Code: 20EC0454 R20
a) The round Function

Definition: The round function rounds a number to the nearest integer. If the fractional part of the
number is exactly 0.5, MATLAB rounds to the nearest even integer.

Syntax: round(x)

Examples:

->x = 3.6;
y = round(x); % Result: y = 4

Here, 3.6 rounds up to the nearest integer, 4.

-> x = 3.4;
y = round(x); % Result: y = 3

Here, 3.4 rounds down to the nearest integer, 3.

b) The ceil Function

Definition: The ceil function rounds each element of x to the nearest integer greater than or equal to that
element, also known as rounding up.

Syntax: ceil(x)

Examples:

->x = 2.1;
y = ceil(x); % Result: y = 3

Here, 2.1 is rounded up to 3.

->x = -1.7;
y = ceil(x); % Result: y = -1

Here, -1.7 is rounded up to -1, as it’s the nearest integer greater than -1.7.

c) The floor Function

Definition: The floor function rounds each element of x to the nearest integer less than or equal to that
element, also known as rounding down.

Syntax: floor(x)

Examples:

->x = 2.9;
y = floor(x); % Result: y = 2

Here, 2.9 is rounded down to 2.

->x = -3.2;
y = floor(x); % Result: y = -4

Here, -3.2 is rounded down to -4, the nearest integer less than -3.2.
Course Code: 20EC0454 R20

3. a. Explain how Trigonometric Functions and Hyperbolic Functionsare handled by MATLAB. Give
some examples.

MATLAB provides a wide range of trigonometric and hyperbolic functions that can operate on real and
complex numbers.

Trigonometric Functions in MATLAB

Trigonometric functions in MATLAB include sine (sin), cosine (cos), tangent (tan), and their inverses
(asin, acos, atan, etc.).

1. Sine Function

 Definition: Calculates the sine of an angle (in radians).

 Syntax: sin(x)
 Example:

x = pi / 2;
y = sin(x); % Result: y = 1

2. Cosine Function

 Definition: Calculates the cosine of an angle (in radians).

 Syntax: cos(x)
 Example:

matlab
Copy code
x = pi;
y = cos(x); % Result: y = -1

3. Tangent Function

 Definition: Calculates the tangent of an angle (in radians).

 Syntax: tan(x)
 Example:

x = pi / 4;
y = tan(x); % Result: y = 1

4. Inverse Trigonometric Functions

These functions return the angle for a given trigonometric ratio.

 Syntax: asin(x), acos(x), atan(x)

 Example:

Copy code
x = 0.5;
angle_sin = asin(x); % Result: angle_sin ≈ 0.5236 radians (30 degrees)

5. Trignometric Function in Degrees

These functions return the value of given degree for a trigonometric ratio.

 Syntax: sind(x),cosd(x),tand(x),asind(x)
 Example:
Course Code: 20EC0454 R20
x = 90;
y = sind(x); % Result: y = 1

Hyperbolic Functions in MATLAB

Hyperbolic functions include hyperbolic sine (sinh), hyperbolic cosine (cosh), hyperbolic tangent
(tanh), and their inverses (asinh, acosh, atanh).

1. Hyperbolic Sine Function

 Definition: Calculates the hyperbolic sine of a number.

 Syntax: sinh(x)
 Example:

x = 1;
y = sinh(x); % Result: y ≈ 1.1752

2. Hyperbolic Cosine Function

 Definition: Calculates the hyperbolic cosine of a number.

 Syntax: cosh(x)
 Example:

x = 1;
y = cosh(x); % Result: y ≈ 1.5431

3. Hyperbolic Tangent Function

 Definition: Calculates the hyperbolic tangent of a number.

 Syntax: tanh(x)
 Example:

x = 1;
y = tanh(x); % Result: y ≈ 0.7616

4. Inverse Hyperbolic Functions

These functions return the hyperbolic angle corresponding to a given hyperbolic ratio.

 Syntax: asinh(x), acosh(x), atanh(x)

 Example:

x = 1;
angle_sinh = asinh(x); % Result: angle_sinh ≈ 0.8814

3 .b Compute the following using MATLAB.

a)For several values of x in the range 0 ≤x ≤ 2, confirm that
tan (2 x) = 2 tan x/ (1-tan2x).

b) For several values of x in the range 0 ≤x ≤5, confirm that sin(ix)= isinhx..
Course Code: 20EC0454 R20
a) Verifying tan(2x)=2tan(x) / 1−tan^2(x) for 0≤ x ≤20 .

This identity can be checked by defining a vector of values for xxx within the range and calculating both
the left-hand side (tan(2*x)) and the right-hand side (2 * tan(x) / (1 - tan(x)^2)).

Matlab code:

% Define x values from 0 to 2 in increments of 0.1

x = 0:0.1:2;
% Define a tolerance for comparison
tolerance = 1e-6;
% Loop through each x value to check the equality
for i = 1:length(x)
% Calculate the left-hand side and right-hand side for each x
lhs = tan(2 * x(i));
rhs = (2 * tan(x(i))) / (1 - tan(x(i))^2);
% Check if they are approximately equal
if abs(lhs - rhs) < tolerance
disp(['x = ', num2str(x(i)), ' : equals']);
else
disp(['x = ', num2str(x(i)), ' : not equals']);
end

end

b) Verifying sin(ix)=isinh(x)\sin(ix) for 0≤ x ≤5 .

In this identity, iii is the imaginary unit, and xxx is a real number. To test this, we can calculate the left-
hand side (sin(i*x)) and the right-hand side (i * sinh(x)) for several values of x between 0 and 5.

Mat lab Code:

% Define x values from 0 to 5 in increments of 0.5
x = 0:0.5:5;
% Define a tolerance for comparison
tolerance = 1e-6;
% Loop through each x value to check the equality
for i = 1:length(x)
% Calculate the left-hand side and right-hand side for each x
lhs = sin(1i * x(i));
rhs = 1i * sinh(x(i));
% Check if they are approximately equal
if abs(lhs - rhs) < tolerance
disp(['x = ', num2str(x(i)), ' : equals']);
else
disp(['x = ', num2str(x(i)), ' : not equals']);
end

end

4. a. What is User-Defined Functions? Give Some Simple Function Examples.

In MATLAB, a user-defined function is a custom function created by the user to perform specific
operations or calculations. Unlike built-in functions, these are saved as separate files with the extension
.m, and can be called by their file name to perform their defined tasks. User-defined functions help
organize code, avoid repetition, and make programs easier to maintain.

Syntax for a User-Defined Function

A user-defined function in MATLAB typically follows this syntax:

function [output1, output2, ...] = functionName(input1, input2, ...)

% Function code here
end
Course Code: 20EC0454 R20
 Function : Keyword that defines a new function.
 output1, output2, ... : Optional output variables the function returns.
 functionName : The name of the function file (must match the filename).
 input1, input2, ... : Input arguments the function accepts.

Example 1:

This function calculates the square of a number. Save the function as squareNumber.m.

function result = squareNumber(x)

% Calculates the square of the input number
result = x^2;
end

% Main script

x = 4;
output = squareNumber(x);
disp(output); % Output will be 16

Example 2:

This function takes two numbers and returns their sum. Save this function as addNumbers.m.

function sum = addNumbers(a, b)

% Adds two numbers and returns the result
sum = a + b;
end

% Main script

a = 5;
b = 3;
output = addNumbers(a, b);
disp(output); % Output will be 8

4. b. Write short note on minimizing a function of one variable.

Minimizing a function of one variable involves finding the point at which the function takes its
smallest value over a given interval or domain. This process is common in optimization, where
we seek the minimum of a function f(x) over an interval [a,b]. In MATLAB, this is typically
done using numerical methods like fminbnd.

MATLAB Example Using fminbnd:

The function fminbnd in MATLAB is specifically designed to find the minimum of a single-variable
function over a specified interval.

Syntax:
x_min = fminbnd(@functionName, a, b);

 @functionName : Handle to the function you want to minimize.

 a, b : The interval within which MATLAB will search for the minimum.

Example: Minimizing f(x)=(x−3)^2+5

Define and minimize this function over an interval [0,5].

% Define the function as an anonymous function

f = @(x) (x - 3)^2 + 5;
Course Code: 20EC0454 R20

% Find the minimum over the interval [0, 5]

x_min = fminbnd(f, 0, 5);

% Display the minimum value

disp(['Minimum occurs at x = ', num2str(x_min)]);
disp(['Minimum value is f(x) = ', num2str(f(x_min))]);

Expected Output:

Minimum occurs at x = 3
Minimum value is f(x) = 5

5. a. Compute the area A and circumference C of a circle, given its radius(r=4) as an input
argument.

To calculate the area A and circumference C of a circle given its radius r=4, we can use the following
formulas:

 Area: A=πr^2
 Circumference : C =2πr

MATLAB Code

Save the following code as circleProperties.m:

function [A, C] = circleProperties(r)

% This function calculates the area and circumference of a circle
% given its radius r.

% Calculate the area

A = pi * r^2;

% Calculate the circumference

C = 2 * pi * r;
end

Main Script :

r = 4;
[A, C] = circleProperties(r);

% Display the results

disp(['Area A = ', num2str(A)]);
disp(['Circumference C = ', num2str(C)]);

Output :

Area A = 50.2655 Circumference C = 25.1327

5 .b. What are the advantages of User-Defined Functions in MATLAB?

User-defined functions in MATLAB provide the following advantages:

1. Reusability : Functions can be used multiple times, saving time and reducing redundancy.
2. Readability : Code is easier to read and follow by breaking it into modular pieces.
3. Simplified Debugging : Functions can be tested individually, simplifying error-finding.
Course Code: 20EC0454 R20
4. Reduced Code Length : Calling functions avoids repetitive code, making scripts shorter.
5. Scalability : Functions make it easy to add or modify features as projects grow.
6. Encapsulation : Functions encapsulate specific tasks, hiding implementation details for better
abstraction.

6. a. Distinguish between Local Variables and Global Variables.

Local Variables

 Definition: Variables that are defined within a function and are only accessible within that specific
function.
 Scope: Limited to the function in which they are defined. They cannot be accessed or modified outside that
function.
 Example:

function myFunction()
x = 10; % Local variable
disp(x);
end

Here, x is a local variable to myFunction and cannot be accessed outside of it.

Global Variables

 Definition: Variables that can be accessed and modified from any function or workspace in MATLAB,
provided they are declared as global in each context they are used.
 Scope: Available across different functions or workspaces where they are explicitly declared as global.
 Usage: To use a global variable in MATLAB, declare it with the keyword global in each function or
workspace where you want to access it.
 Example:

global y; % Declare global variable in base workspace

y = 20;

function modifyGlobal()
global y; % Declare global in this function too
y = y + 5;
end

modifyGlobal(); % This will change y to 25

disp(y); % Displays 25 in the base workspace

Here, y is a global variable and can be accessed and modified by any function or workspace where it's
declared as global.

6. b. Explain about methods for calling functions.

In MATLAB, there are several ways to call functions, depending on the function type as follows :

1. Calling Built-in MATLAB Functions

MATLAB has a large library of built-in functions, such as sin, cos, mean, sum, and others, which can be
called directly with the required input arguments.

Example :
result = mean([1, 2, 3, 4, 5]);
Course Code: 20EC0454 R20
Here, mean is a built-in function, and you call it by passing in an array as an argument.

2. Calling User-Defined Functions

Functions created by the user can be saved as separate .m files and then called in the script or command
window. Each .m file should be named after the function it defines.

% Example: File "myFunction.m"

function output = myFunction(input)
output = input^2;
end

% Calling the function

result = myFunction(5); % Output will be 25

3. Calling Nested Functions

A nested function is defined within another function, and it has access to the variables of the outer
function. Nested functions are helpful for tasks that require helper functions.

Example :
function mainFunction()
x = 10;
disp(nestedFunction(x));

function y = nestedFunction(x)
y = x^2;
end
end

Here, nestedFunction can only be called within mainFunction.

4. Calling Subfunctions

Subfunctions are additional functions defined within the same .m file as the main function but outside of
its main body. Subfunctions can only be called by the main function or other subfunctions within the
same file.

% Example: File "mainFunction.m"

function result = mainFunction()
result = helperFunction(5);
end

function output = helperFunction(input)

output = input^2;
end

Here, helperFunction is a subfunction and can be called by mainFunction.

5. Calling Anonymous Functions

Anonymous functions are functions that are defined in a single line using the @ symbol. They are often
used for short, simple operations and can be called directly or passed as arguments.

Example :
square = @(x) x^2;
result = square(5); % Output will be 25

7. What is mean by functions? Explain various types functions in MATLAB with suitable
example.
Course Code: 20EC0454 R20
Function :

In MATLAB, functions are self-contained blocks of code designed to perform specific tasks. They take
inputs, process them, and return outputs. Functions help in organizing code, improving readability, and
reusability. MATLAB has several types of functions, including built-in functions, user-defined functions,
anonymous functions, nested functions, variable argument lists, private functions, and subfunctions.

Types of Functions in MATLAB

1. Built-in Functions

These are predefined functions provided by MATLAB for various mathematical and engineering
operations.

Syntax:

output = builtInFunction(input)

Example:

% Using the built-in function 'sqrt' to calculate the square root of a number
result = sqrt(16);
disp(result); % Output: 4

2. User-defined Functions

User-defined functions are created by the user to perform specific tasks. They can take input arguments
and return output values.

Syntax:

function output = functionName(input1, input2, ...)

% Function body
end

Example:

% Define a user-defined function 'addNumbers' in a file named 'addNumbers.m'

function result = addNumbers(a, b)
result = a + b; % Add two numbers
end

% Call the user-defined function

sum = addNumbers(5, 10);
disp(sum); % Output: 15

3. Anonymous Functions

Anonymous functions are one-line functions defined without a separate file. They are useful for simple
operations and can be created using the @ symbol.

Syntax:

f = @(input) expression

Example:

% Define an anonymous function that squares a number

square = @(x) x^2;
Course Code: 20EC0454 R20

% Call the anonymous function

result = square(4);
disp(result); % Output: 16

4. Nested Functions

Nested functions are defined within another function. They can access variables from the parent
function's workspace.

Syntax:

function output = outerFunction(input)

% Nested function
function innerOutput = innerFunction(innerInput)
% Access outer function variables
end
output = innerFunction(input);
end

Example:

% Define a function 'outerFunction' with a nested function 'innerFunction'

function outerFunction()
a = 5; % Variable in the outer function
% Define the nested function
function b = innerFunction()
b = a + 10; % Accessing variable 'a' from the outer function
end
result = innerFunction(); % Call the nested function
disp(result); % Output: 15
end

% Call the outer function

outerFunction();

5. Private Functions

Private functions are defined in a separate file and are only accessible to functions in the same directory
or in subdirectories. They are useful for encapsulating functionality that should not be exposed to users of
your primary function or module.

Syntax:

% In 'myFunction.m'
function output = myFunction(x)
output = privateFunction(x); % Call the private function
end

Example of Private Function:

1. Create a folder named myFunctions.

2. Create a file named myFunction.m inside the folder:

function output = myFunction(x)

% Call the private function
output = privateFunction(x);
end

3. Create another file named privateFunction.m inside the myFunctions/private directory:

function result = privateFunction(y)

Course Code: 20EC0454 R20
% This function is private to 'myFunction'
result = y^2; % Square the input
end

4. Call the function from the command window:

% Set the current folder to 'myFunctions'

result = myFunction(5);
disp(result); % Output: 25

6. Subfunctions

Subfunctions are functions defined within the same file as another function. They can only be called by
the main function in that file or other subfunctions defined in the same file. Subfunctions are useful for
organizing code related to a primary function without making them accessible outside of that context.

Syntax:

function output = mainFunction(input)

% Call the subfunction
end

function output = subFunction(input)

% This is a subfunction
end

Example of Subfunction:

1. Create a file named mainFunction.m:

function result = mainFunction(x)

% Call the subfunction
result = squareValue(x);
end

function result = squareValue(y)

% This is a subfunction
result = y^2; % Square the input
end

2. Call the function from the command window:

result = mainFunction(4);
disp(result); % Output: 16

8. a. Explain about Anonymous Functions with suitable example.

Anonymous Functions

Anonymous functions are one-line functions defined without a separate file. They are useful for simple
operations and can be created using the @ symbol.

Syntax:

f = @(input) expression

Example:

% Define an anonymous function that squares a number

square = @(x) x^2;
Course Code: 20EC0454 R20

% Call the anonymous function

result = square(4);
disp(result); % Output: 16

8. b. How Multiple-Input Arguments are handled in Anonymous Functions

In MATLAB, anonymous functions can handle multiple input arguments using the same syntax as regular
functions. The key is to define the function using a single variable for all inputs and then use that variable
as needed within the function body. Here's how it works:

Syntax for Multiple-Input Arguments

To create an anonymous function that accepts multiple input arguments, use the following syntax:

f = @(input1, input2, ...) expression

Example: Using Multiple Input Arguments in an Anonymous Function

create an anonymous function that takes two inputs and performs a mathematical operation.

Example 1: Sum of Two Numbers

% Define an anonymous function that takes two inputs and returns their sum
sumFunction = @(x, y) x + y;

% Call the anonymous function

result = sumFunction(5, 3);
disp(result); % Output: 8

Example 2: Using Array Inputs

Anonymous functions can also handle array inputs. In this case, the function operates element-wise on
arrays.

% Define an anonymous function that multiplies two arrays element-wise

elementWiseMultiplication = @(x, y) x .* y;

% Call the anonymous function with arrays

result = elementWiseMultiplication([1, 2, 3], [4, 5, 6]);
disp(result); % Output: [4 10 18]

9.a. What are Nested Functions? Explain with suitable example.

Nested Functions

Nested functions are defined within another function. They can access variables from the parent
function's workspace.

Syntax:

function output = outerFunction(input)

% Nested function
function innerOutput = innerFunction(innerInput)
% Access outer function variables
end
output = innerFunction(input);
end

Example:
Course Code: 20EC0454 R20
% Define a function 'outerFunction' with a nested function 'innerFunction'
function outerFunction()
a = 5; % Variable in the outer function
% Define the nested function
function b = innerFunction()
b = a + 10; % Accessing variable 'a' from the outer function
end
result = innerFunction(); % Call the nested function
disp(result); % Output: 15
end

% Call the outer function

outerFunction();

9. b. Explain about Private function with suitable example.

Private Functions :
Private functions are defined in a separate file and are only accessible to functions in the same
directory or in subdirectories. They are useful for encapsulating functionality that should not be
exposed to users of your primary function or module.

Syntax:

% In 'myFunction.m'
function output = myFunction(x)
output = privateFunction(x); % Call the private function
end

Example of Private Function:

3. Create a folder named myFunctions.

4. Create a file named myFunction.m inside the folder:

function output = myFunction(x)

% Call the private function
output = privateFunction(x);
end

4. Create another file named privateFunction.m inside the myFunctions/private directory:

function result = privateFunction(y)

% This function is private to 'myFunction'
result = y^2; % Square the input
end

5. Call the function from the command window:

% Set the current folder to 'myFunctions'

result = myFunction(5);
disp(result); % Output: 25
.
10.a. Briefly explain importing wizard and excel data files in MATLAB.

In MATLAB, importing data from Excel files or using the Import Wizard is by the following methods:

1. Importing Wizard:

 Accessing the Wizard: You can start the Import Wizard by selecting Import Data from the Home tab in
the MATLAB toolstrip or by using the uiimport command in the command window.
 File Selection: The wizard allows you to browse for a file (e.g., .csv, .txt, .xls).
Course Code: 20EC0454 R20
 Data Preview: Once a file is selected, you can see a preview of the data, where you can choose which
variables to import and how to format them.
 Options: You can set options such as specifying delimiters, selecting variable names, and handling missing
data.
 Importing: After configuring the settings, you can import the data into the MATLAB workspace as a table
or array.

2. Importing Excel Data Files:

 Using readtable or readmatrix: You can directly import Excel files using these functions. For
example:
o data = readtable('filename.xlsx'); imports data as a table.
o data = readmatrix('filename.xlsx'); imports data as a numeric matrix.
 Specifying Sheets and Range: You can specify the sheet name and range within the file:

data = readtable('filename.xlsx', 'Sheet', 'Sheet1', 'Range', 'A1:D10');

 Handling Different Data Types: MATLAB automatically detects and converts different data types in the
Excel file, making it easy to work with mixed data.

10.b. How to Export ASCII Data Files in MATLAB?

Exporting ASCII data files in MATLAB can be done using several functions, depending on specific
needs and the format we want by the following ways:

1. Using writematrix

For exporting numeric matrices, writematrix is a straightforward option:

data = rand(5); % Example data (5x5 matrix)

writematrix(data, 'output.txt'); % Exports to a text file

2. Using writetable

If you are working with tables, writetable is ideal:

T = table((1:5)', rand(5,1), 'VariableNames', {'Index', 'Value'});

writetable(T, 'output.txt'); % Exports to a text file

3. Using dlmwrite (for older versions)

For versions of MATLAB prior to R2019a, you can use dlmwrite:

data = rand(5); % Example data

dlmwrite('output.txt', data, 'delimiter', '\t'); % Exports with tab delimiter

4. Using fprintf

For more control over the formatting, fprintf can be used:

data = rand(5); % Example data

fileID = fopen('output.txt', 'w'); % Open file for writing
fprintf(fileID, '%f %f\n', data'); % Write data to file (transposed)
fclose(fileID); % Close the file