Category: Matlab

Data export (or output) in MATLAB means to write into files. MATLAB allows you to use your data in another application that reads ASCII files. For this, MATLAB provides several data export options.

You can create the following type of files −

• Rectangular, delimited ASCII data file from an array.
• Diary (or log) file of keystrokes and the resulting text output.
• Specialized ASCII file using low-level functions such as fprintf.
• MEX-file to access your C/C++ or Fortran routine that writes to a particular text file format.

Apart from this, you can also export data to spreadsheets.

There are two ways to export a numeric array as a delimited ASCII data file −

• Using the save function and specifying the -ascii qualifier
• Using the dlmwrite function

Syntax for using the save function is −

save my_data.out num_array -ascii

where, my_data.out is the delimited ASCII data file created, num_array is a numeric array and −ascii is the specifier.

Syntax for using the dlmwrite function is −

dlmwrite('my_data.out', num_array, 'dlm_char')

where, my_data.out is the delimited ASCII data file created, num_array is a numeric array and dlm_char is the delimiter character.

Example

The following example demonstrates the concept. Create a script file and type the following code −

num_array = [ 1 2 3 4 ; 4 5 6 7; 7 8 9 0];
save array_data1.out num_array -ascii;
type array_data1.out
dlmwrite('array_data2.out', num_array, ' ');
type array_data2.out

When you run the file, it displays the following result −

   1.0000000e+00   2.0000000e+00   3.0000000e+00   4.0000000e+00
   4.0000000e+00   5.0000000e+00   6.0000000e+00   7.0000000e+00
   7.0000000e+00   8.0000000e+00   9.0000000e+00   0.0000000e+00

1 2 3 4
4 5 6 7
7 8 9 0

Please note that the save -ascii command and the dlmwrite function does not work with cell arrays as input. To create a delimited ASCII file from the contents of a cell array, you can

• Either, convert the cell array to a matrix using the cell2mat function
• Or export the cell array using low-level file I/O functions.

If you use the save function to write a character array to an ASCII file, it writes the ASCII equivalent of the characters to the file.

For example, let us write the word ‘hello’ to a file −

h = 'hello';
save textdata.out h -ascii
type textdata.out

MATLAB executes the above statements and displays the following result. which is the characters of the string ‘hello’ in 8-digit ASCII format.

1.0400000e+02   1.0100000e+02   1.0800000e+02   1.0800000e+02   1.1100000e+02

Writing to Diary Files

Diary files are activity logs of your MATLAB session. The diary function creates an exact copy of your session in a disk file, excluding graphics.

To turn on the diary function, type −

diary

Optionally, you can give the name of the log file, say −

diary logdata.out

To turn off the diary function −

diary off

You can open the diary file in a text editor.

Exporting Data to Text Data Files with Low-Level I/O

So far, we have exported numeric arrays. However, you may need to create other text files, including combinations of numeric and character data, nonrectangular output files, or files with non-ASCII encoding schemes. For these purposes, MATLAB provides the low-level fprintf function.

As in low-level I/O file activities, before exporting, you need to open or create a file with the fopen function and get the file identifier. By default, fopen opens a file for read-only access. You should specify the permission to write or append, such as ‘w’ or ‘a’.

After processing the file, you need to close it with fclose(fid) function.

The following example demonstrates the concept −

Example

Create a script file and type the following code in it −

% create a matrix y, with two rows
x = 0:10:100;
y = [x; log(x)];
 
% open a file for writing
fid = fopen('logtable.txt', 'w');
 
% Table Header
fprintf(fid, 'Log     Function\n\n');
 
% print values in column order
% two values appear on each row of the file
fprintf(fid, '%f    %f\n', y);
fclose(fid);

% display the file created
type logtable.txt

When you run the file, it displays the following result −

Log         Function

0.000000    -Inf
10.000000    2.302585
20.000000    2.995732
30.000000    3.401197
40.000000    3.688879
50.000000    3.912023
60.000000    4.094345
70.000000    4.248495
80.000000    4.382027
90.000000    4.499810
100.000000    4.605170

Importing data in MATLAB means loading data from an external file. The importdata function allows loading various data files of different formats. It has the following five forms −

By default, Octave does not have support for importdata() function, so you will have to search and install this package to make following examples work with your Octave installation.

Example 1

Let us load and display an image file. Create a script file and type the following code in it −

filename = 'smile.jpg';
A = importdata(filename);
image(A);

When you run the file, MATLAB displays the image file. However, you must store it in the current directory.

Example 2

In this example, we import a text file and specify Delimiter and Column Header. Let us create a space-delimited ASCII file with column headers, named weeklydata.txt.

Our text file weeklydata.txt looks like this −

SunDay  MonDay  TuesDay  WednesDay  ThursDay  FriDay  SaturDay
95.01   76.21   61.54    40.57       55.79    70.28   81.53
73.11   45.65   79.19    93.55       75.29    69.87   74.68
60.68   41.85   92.18    91.69       81.32    90.38   74.51
48.60   82.14   73.82    41.03       0.99     67.22   93.18
89.13   44.47   57.63    89.36       13.89    19.88   46.60

Create a script file and type the following code in it −

filename = 'weeklydata.txt';
delimiterIn = ' ';
headerlinesIn = 1;
A = importdata(filename,delimiterIn,headerlinesIn);

% View data
for k = [1:7]
   disp(A.colheaders{1, k})
   disp(A.data(:, k))
   disp(' ')
end

When you run the file, it displays the following result −

SunDay
   95.0100
   73.1100
   60.6800
   48.6000
   89.1300
 
MonDay
   76.2100
   45.6500
   41.8500
   82.1400
   44.4700
 
TuesDay
   61.5400
   79.1900
   92.1800
   73.8200
   57.6300

WednesDay
   40.5700
   93.5500
   91.6900
   41.0300
   89.3600
 
ThursDay
   55.7900
   75.2900
   81.3200
   0.9900
   13.8900
 
FriDay
   70.2800
   69.8700
   90.3800
   67.2200
   19.8800

SaturDay
   81.5300
   74.6800
   74.5100
   93.1800
   46.6000

Example 3

In this example, let us import data from clipboard.

Copy the following lines to the clipboard −

Mathematics is simple

Create a script file and type the following code −

A = importdata('-pastespecial')

When you run the file, it displays the following result −

A = 
   'Mathematics is simple'

Low-Level File I/O

The importdata function is a high-level function. The low-level file I/O functions in MATLAB allow the most control over reading or writing data to a file. However, these functions need more detailed information about your file to work efficiently.

MATLAB provides the following functions for read and write operations at the byte or character level −

Import Text Data Files with Low-Level I/O

MATLAB provides the following functions for low-level import of text data files −

• The fscanf function reads formatted data in a text or ASCII file.
• The fgetl and fgets functions read one line of a file at a time, where a newline character separates each line.
• The fread function reads a stream of data at the byte or bit level.

Example

We have a text data file ‘myfile.txt’ saved in our working directory. The file stores rainfall data for three months; June, July and August for the year 2012.

The data in myfile.txt contains repeated sets of time, month and rainfall measurements at five places. The header data stores the number of months M; so we have M sets of measurements.

The file looks like this −

Rainfall Data
Months: June, July, August
 
M = 3
12:00:00
June-2012
17.21  28.52  39.78  16.55 23.67
19.15  0.35   17.57  NaN   12.01
17.92  28.49  17.40  17.06 11.09
9.59   9.33   NaN    0.31  0.23 
10.46  13.17  NaN    14.89 19.33
20.97  19.50  17.65  14.45 14.00
18.23  10.34  17.95  16.46 19.34
09:10:02
July-2012
12.76  16.94  14.38  11.86 16.89
20.46  23.17  NaN    24.89 19.33
30.97  49.50  47.65  24.45 34.00
18.23  30.34  27.95  16.46 19.34
30.46  33.17  NaN    34.89  29.33
30.97  49.50  47.65  24.45 34.00
28.67  30.34  27.95  36.46 29.34
15:03:40
August-2012
17.09  16.55  19.59  17.25 19.22
17.54  11.45  13.48  22.55 24.01
NaN    21.19  25.85  25.05 27.21
26.79  24.98  12.23  16.99 18.67
17.54  11.45  13.48  22.55 24.01
NaN    21.19  25.85  25.05 27.21
26.79  24.98  12.23  16.99 18.67

We will import data from this file and display this data. Take the following steps −

• Open the file with fopen function and get the file identifier.
• Describe the data in the file with format specifiers, such as ‘%s‘ for a string, ‘%d‘ for an integer, or ‘%f‘ for a floating-point number.
• To skip literal characters in the file, include them in the format description. To skip a data field, use an asterisk (‘*’) in the specifier.For example, to read the headers and return the single value for M, we write −M = fscanf(fid, ‘%*s %*s\n%*s %*s %*s %*s\nM=%d\n\n’, 1);
• By default, fscanf reads data according to our format description until it does not find any match for the data, or it reaches the end of the file. Here we will use for loop for reading 3 sets of data and each time, it will read 7 rows and 5 columns.
• We will create a structure named mydata in the workspace to store data read from the file. This structure has three fields – time, month, and raindata array.

Create a script file and type the following code in it −

filename = '/data/myfile.txt';
rows = 7;
cols = 5;
 
% open the file
fid = fopen(filename);
 
% read the file headers, find M (number of months)
M = fscanf(fid, '%*s %*s\n%*s %*s %*s %*s\nM=%d\n\n', 1);
 
% read each set of measurements
for n = 1:M
   mydata(n).time = fscanf(fid, '%s', 1);
   mydata(n).month = fscanf(fid, '%s', 1);
 
   % fscanf fills the array in column order,
   % so transpose the results
   mydata(n).raindata  = ...
  fscanf(fid, '%f', [rows, cols]);
end
for n = 1:M
   disp(mydata(n).time), disp(mydata(n).month)
   disp(mydata(n).raindata)
end
 
% close the file
fclose(fid);

When you run the file, it displays the following result −

12:00:00
June-2012
   17.2100   17.5700   11.0900   13.1700   14.4500
   28.5200       NaN    9.5900       NaN   14.0000
   39.7800   12.0100    9.3300   14.8900   18.2300
   16.5500   17.9200       NaN   19.3300   10.3400
   23.6700   28.4900    0.3100   20.9700   17.9500
   19.1500   17.4000    0.2300   19.5000   16.4600
   0.3500   17.0600   10.4600   17.6500   19.3400

09:10:02
July-2012
   12.7600       NaN   34.0000   33.1700   24.4500
   16.9400   24.8900   18.2300       NaN   34.0000
   14.3800   19.3300   30.3400   34.8900   28.6700
   11.8600   30.9700   27.9500   29.3300   30.3400
   16.8900   49.5000   16.4600   30.9700   27.9500
   20.4600   47.6500   19.3400   49.5000   36.4600
   23.1700   24.4500   30.4600   47.6500   29.3400

15:03:40
August-2012
   17.0900   13.4800   27.2100   11.4500   25.0500
   16.5500   22.5500   26.7900   13.4800   27.2100
   19.5900   24.0100   24.9800   22.5500   26.7900
   17.2500       NaN   12.2300   24.0100   24.9800
   19.2200   21.1900   16.9900       NaN   12.2300
   17.5400   25.8500   18.6700   21.1900   16.9900
   11.4500   25.0500   17.5400   25.8500   18.6700

A function is a group of statements that together perform a task. In MATLAB, functions are defined in separate files. The name of the file and of the function should be the same.

Functions operate on variables within their own workspace, which is also called the local workspace, separate from the workspace you access at the MATLAB command prompt which is called the base workspace.

Functions can accept more than one input arguments and may return more than one output arguments.

Syntax of a function statement is −

function [out1,out2, ..., outN] = myfun(in1,in2,in3, ..., inN)

Example

The following function named mymax should be written in a file named mymax.m. It takes five numbers as argument and returns the maximum of the numbers.

Create a function file, named mymax.m and type the following code in it −

function max = mymax(n1, n2, n3, n4, n5)

%This function calculates the maximum of the
% five numbers given as input
max =  n1;
if(n2 > max)
   max = n2;
end
if(n3 > max)
   max = n3;
end
if(n4 > max)
   max = n4;
end
if(n5 > max)
   max = n5;
end

The first line of a function starts with the keyword function. It gives the name of the function and order of arguments. In our example, the mymax function has five input arguments and one output argument.

The comment lines that come right after the function statement provide the help text. These lines are printed when you type −

help mymax

MATLAB will execute the above statement and return the following result −

This function calculates the maximum of the
   five numbers given as input

You can call the function as −

mymax(34, 78, 89, 23, 11)

MATLAB will execute the above statement and return the following result −

ans = 89

Anonymous Functions

An anonymous function is like an inline function in traditional programming languages, defined within a single MATLAB statement. It consists of a single MATLAB expression and any number of input and output arguments.

You can define an anonymous function right at the MATLAB command line or within a function or script.

This way you can create simple functions without having to create a file for them.

The syntax for creating an anonymous function from an expression is

f = @(arglist)expression

Example

In this example, we will write an anonymous function named power, which will take two numbers as input and return first number raised to the power of the second number.

Create a script file and type the following code in it −

power = @(x, n) x.^n;
result1 = power(7, 3)
result2 = power(49, 0.5)
result3 = power(10, -10)
result4 = power (4.5, 1.5)

When you run the file, it displays −

result1 =  343
result2 =  7
result3 =  1.0000e-10
result4 =  9.5459

Primary and Sub-Functions

Any function other than an anonymous function must be defined within a file. Each function file contains a required primary function that appears first and any number of optional sub-functions that comes after the primary function and used by it.

Primary functions can be called from outside of the file that defines them, either from command line or from other functions, but sub-functions cannot be called from command line or other functions, outside the function file.

Sub-functions are visible only to the primary function and other sub-functions within the function file that defines them.

Example

Let us write a function named quadratic that would calculate the roots of a quadratic equation. The function would take three inputs, the quadratic co-efficient, the linear co-efficient and the constant term. It would return the roots.

The function file quadratic.m will contain the primary function quadratic and the sub-function disc, which calculates the discriminant.

Create a function file quadratic.m and type the following code in it −

function [x1,x2] = quadratic(a,b,c)

%this function returns the roots of 
% a quadratic equation.
% It takes 3 input arguments
% which are the co-efficients of x2, x and the 
%constant term
% It returns the roots
d = disc(a,b,c); 
x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end   % end of quadratic

function dis = disc(a,b,c) 
%function calculates the discriminant
dis = sqrt(b^2 - 4*a*c);
end   % end of sub-function

You can call the above function from command prompt as −

quadratic(2,4,-4)

MATLAB will execute the above statement and return the following result −

ans = 0.7321

Nested Functions

You can define functions within the body of another function. These are called nested functions. A nested function contains any or all of the components of any other function.

Nested functions are defined within the scope of another function and they share access to the containing function’s workspace.

A nested function follows the following syntax −

function x = A(p1, p2)
...
B(p2)
   function y = B(p3)
   ...
   end
...
end

Example

Let us rewrite the function quadratic, from previous example, however, this time the disc function will be a nested function.

Create a function file quadratic2.m and type the following code in it −

function [x1,x2] = quadratic2(a,b,c)
function disc  % nested function
d = sqrt(b^2 - 4*a*c);
end   % end of function disc

disc;
x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end   % end of function quadratic2

You can call the above function from command prompt as −

quadratic2(2,4,-4)

MATLAB will execute the above statement and return the following result −

ans =  0.73205

Private Functions

A private function is a primary function that is visible only to a limited group of other functions. If you do not want to expose the implementation of a function(s), you can create them as private functions.

Private functions reside in subfolders with the special name private.

They are visible only to functions in the parent folder.

Example

Let us rewrite the quadratic function. This time, however, the disc function calculating the discriminant, will be a private function.

Create a subfolder named private in working directory. Store the following function file disc.m in it −

function dis = disc(a,b,c) 
%function calculates the discriminant
dis = sqrt(b^2 - 4*a*c);
end      % end of sub-function

Create a function quadratic3.m in your working directory and type the following code in it −

function [x1,x2] = quadratic3(a,b,c)

%this function returns the roots of 
% a quadratic equation.
% It takes 3 input arguments
% which are the co-efficient of x2, x and the 
%constant term
% It returns the roots
d = disc(a,b,c); 

x1 = (-b + d) / (2*a);
x2 = (-b - d) / (2*a);
end      % end of quadratic3

You can call the above function from command prompt as −

quadratic3(2,4,-4)

MATLAB will execute the above statement and return the following result −

ans =  0.73205

Global Variables

Global variables can be shared by more than one function. For this, you need to declare the variable as global in all the functions.

If you want to access that variable from the base workspace, then declare the variable at the command line.

The global declaration must occur before the variable is actually used in a function. It is a good practice to use capital letters for the names of global variables to distinguish them from other variables.

Example

Let us create a function file named average.m and type the following code in it −

function avg = average(nums)
global TOTAL
avg = sum(nums)/TOTAL;
end

Create a script file and type the following code in it −

global TOTAL;
TOTAL = 10;
n = [34, 45, 25, 45, 33, 19, 40, 34, 38, 42];
av = average(n)

When you run the file, it will display the following result −

av =  35.500

Creating a character string is quite simple in MATLAB. In fact, we have used it many times. For example, you type the following in the command prompt −

my_string = 'Tutorials Point'

MATLAB will execute the above statement and return the following result −

my_string = Tutorials Point

MATLAB considers all variables as arrays, and strings are considered as character arrays. Let us use the whos command to check the variable created above −

whos

MATLAB will execute the above statement and return the following result −

Name           Size            Bytes  Class    Attributes
my_string      1x16               32  char

Interestingly, you can use numeric conversion functions like uint8 or uint16 to convert the characters in the string to their numeric codes. The char function converts the integer vector back to characters −

Example

Create a script file and type the following code into it −

my_string = 'Tutorial''s Point';
str_ascii = uint8(my_string)        % 8-bit ascii values
str_back_to_char= char(str_ascii)  
str_16bit = uint16(my_string)       % 16-bit ascii values
str_back_to_char = char(str_16bit)  

When you run the file, it displays the following result −

str_ascii =

   84  117  116  111  114  105   97  108   39  115   32   80  111  105  110  116

str_back_to_char = Tutorial's Point
str_16bit =

   84  117  116  111  114  105   97  108   39  115   32   80  111  105  110  116

str_back_to_char = Tutorial's Point

Rectangular Character Array

The strings we have discussed so far are one-dimensional character arrays; however, we need to store more than that. We need to store more dimensional textual data in our program. This is achieved by creating rectangular character arrays.

Simplest way of creating a rectangular character array is by concatenating two or more one-dimensional character arrays, either vertically or horizontally as required.

You can combine strings vertically in either of the following ways −

• Using the MATLAB concatenation operator [] and separating each row with a semicolon (;). Please note that in this method each row must contain the same number of characters. For strings with different lengths, you should pad with space characters as needed.
• Using the char function. If the strings are of different lengths, char pads the shorter strings with trailing blanks so that each row has the same number of characters.

Example

Create a script file and type the following code into it −

doc_profile = ['Zara Ali                             '; ...
           'Sr. Surgeon                          '; ...
           'R N Tagore Cardiology Research Center']
doc_profile = char('Zara Ali', 'Sr. Surgeon', ...
              'RN Tagore Cardiology Research Center')</code></pre>


When you run the file, it displays the following result −



doc_profile =
Zara Ali                             
Sr. Surgeon                          
R N Tagore Cardiology Research Center
doc_profile =
Zara Ali                            
Sr. Surgeon                         
RN Tagore Cardiology Research Center




You can combine strings horizontally in either of the following ways −




Using the MATLAB concatenation operator, [] and separating the input strings with a comma or a space. This method preserves any trailing spaces in the input arrays.



Using the string concatenation function, strcat. This method removes trailing spaces in the inputs.




Example



Create a script file and type the following code into it −



name =     'Zara Ali                             ';
position = 'Sr. Surgeon                          '; 
worksAt =  'R N Tagore Cardiology Research Center';
profile = [name ', ' position ', ' worksAt]
profile = strcat(name, ', ', position, ', ', worksAt)



When you run the file, it displays the following result −



profile = Zara Ali      , Sr. Surgeon      , R N Tagore Cardiology Research Center
profile = Zara Ali,Sr. Surgeon,R N Tagore Cardiology Research Center




Combining Strings into a Cell Array



From our previous discussion, it is clear that combining strings with different lengths could be a pain as all strings in the array has to be of the same length. We have used blank spaces at the end of strings to equalize their length.



However, a more efficient way to combine the strings is to convert the resulting array into a cell array.



MATLAB cell array can hold different sizes and types of data in an array. Cell arrays provide a more flexible way to store strings of varying length.



The cellstr function converts a character array into a cell array of strings.



Example



Create a script file and type the following code into it −



name =     'Zara Ali                             ';
position = 'Sr. Surgeon                          '; 
worksAt =  'R N Tagore Cardiology Research Center';
profile = char(name, position, worksAt);
profile = cellstr(profile);
disp(profile)



When you run the file, it displays the following result −



{                                                                               
   [1,1] = Zara Ali                                                              
   [2,1] = Sr. Surgeon                                                           
   [3,1] = R N Tagore Cardiology Research Center                                 
}   




String Functions in MATLAB



MATLAB provides numerous string functions creating, combining, parsing, comparing and manipulating strings.



Following table provides brief description of the string functions in MATLAB −



Function
Purpose
Functions for storing text in character arrays, combine character arrays, etc.
blanks
Create string of blank characters
cellstr
Create cell array of strings from character array
char
Convert to character array (string)
iscellstr
Determine whether input is cell array of strings
ischar
Determine whether item is character array
sprintf
Format data into string
strcat
Concatenate strings horizontally
strjoin
Join strings in cell array into single string
Functions for identifying parts of strings, find and replace substrings
ischar
Determine whether item is character array
isletter
Array elements that are alphabetic letters
isspace
Array elements that are space characters
isstrprop
Determine whether string is of specified category
sscanf
Read formatted data from string
strfind
Find one string within another
strrep
Find and replace substring
strsplit
Split string at specified delimiter
strtok
Selected parts of string
validatestring
Check validity of text string
symvar
Determine symbolic variables in expression
regexp
Match regular expression (case sensitive)
regexpi
Match regular expression (case insensitive)
regexprep
Replace string using regular expression
regexptranslate
Translate string into regular expression
Functions for string comparison
strcmp
Compare strings (case sensitive)
strcmpi
Compare strings (case insensitive)
strncmp
Compare first n characters of strings (case sensitive)
strncmpi
Compare first n characters of strings (case insensitive)
Functions for changing string to upper- or lowercase, creating or removing white space
deblank
Strip trailing blanks from end of string
strtrim
Remove leading and trailing white space from string
lower
Convert string to lowercase
upper
Convert string to uppercase
strjust
Justify character array



Examples



The following examples illustrate some of the above-mentioned string functions −



Formatting Strings



Create a script file and type the following code into it −



A = pi*1000*ones(1,5);
sprintf(' %f \n %.2f \n %+.2f \n %12.2f \n %012.2f \n', A)



When you run the file, it displays the following result −



ans =  3141.592654 
   3141.59 
   +3141.59 
  3141.59 
   000003141.59 




Joining Strings



Create a script file and type the following code into it −



%cell array of strings
str_array = {'red','blue','green', 'yellow', 'orange'};

% Join strings in cell array into single string
str1 = strjoin(str_array, "-")
str2 = strjoin(str_array, ",")



When you run the file, it displays the following result −



str1 = red-blue-green-yellow-orange
str2 = red,blue,green,yellow,orange




Finding and Replacing Strings



Create a script file and type the following code into it −



students = {'Zara Ali', 'Neha Bhatnagar', ...
        'Monica Malik', 'Madhu Gautam', ...
        'Madhu Sharma', 'Bhawna Sharma',...
        'Nuha Ali', 'Reva Dutta', ...
        'Sunaina Ali', 'Sofia Kabir'};
 
% The strrep function searches and replaces sub-string.
new_student = strrep(students(8), 'Reva', 'Poulomi')
% Display first names
first_names = strtok(students)



When you run the file, it displays the following result −



new_student = 
{
   [1,1] = Poulomi Dutta
}
first_names = 
{
   [1,1] = Zara
   [1,2] = Neha
   [1,3] = Monica
   [1,4] = Madhu
   [1,5] = Madhu
   [1,6] = Bhawna
   [1,7] = Nuha
   [1,8] = Reva
   [1,9] = Sunaina
   [1,10] = Sofia
}




Comparing Strings



Create a script file and type the following code into it −



str1 = 'This is test'
str2 = 'This is text'
if (strcmp(str1, str2))
   sprintf('%s and %s are equal', str1, str2)
else
   sprintf('%s and %s are not equal', str1, str2)
end



When you run the file, it displays the following result −



str1 = This is test
str2 = This is text
ans = This is test and This is text are not equal