fprintf

Write data to text file

Syntax

fprintf(fileID,formatSpec,A1,...,An)

fprintf(formatSpec,A1,...,An)

nbytes = fprintf(___)

Description

fprintf(fileID,formatSpec,A1,...,An) applies the formatSpec to all elements of arrays A1,...An in column order, and writes the data to a text file. fprintf uses the encoding scheme specified in the call to fopen.

fprintf(formatSpec,A1,...,An) formats data and displays the results on the screen.

nbytes = fprintf(___) returns the number of bytes that fprintf writes, using any of the input arguments in the preceding syntaxes.

Examples

Print Literal Text and Array Values

Print multiple numeric values and literal text to the screen.

A1 = [9.9, 9900];
A2 = [8.8,  7.7 ; ...
      8800, 7700];
formatSpec = 'X is %4.2f meters or %8.3f mm\n';
fprintf(formatSpec,A1,A2)

X is 9.90 meters or 9900.000 mm
X is 8.80 meters or 8800.000 mm
X is 7.70 meters or 7700.000 mm

%4.2f in the formatSpec input specifies that the first value in each line of output is a floating-point number with a field width of four digits, including two digits after the decimal point. %8.3f in the formatSpec input specifies that the second value in each line of output is a floating-point number with a field width of eight digits, including three digits after the decimal point. \n is a control character that starts a new line.

Print Double-Precision Values as Integers

Explicitly convert double-precision values with fractions to integer values.

a = [1.02 3.04 5.06];
fprintf('%d\n',round(a));

1
3
5

%d in the formatSpec input prints each value in the vector, round(a), as a signed integer. \n is a control character that starts a new line.

Write Tabular Data to Text File

Write a short table of the exponential function to a text file called exp.txt.

x = 0:.1:1;
A = [x; exp(x)];

fileID = fopen('exp.txt','w');
fprintf(fileID,'%6s %12s\n','x','exp(x)');
fprintf(fileID,'%6.2f %12.8f\n',A);
fclose(fileID);

The first call to fprintf prints header text x and exp(x), and the second call prints the values from variable A.

If you plan to read the file with Microsoft^® Notepad, use '\r\n' instead of '\n' to move to a new line. For example, replace the calls to fprintf with the following:

fprintf(fileID,'%6s %12s\r\n','x','exp(x)');
fprintf(fileID,'%6.2f %12.8f\r\n',A);

MATLAB^® import functions, all UNIX^® applications, and Microsoft Word and WordPad recognize '\n' as a newline indicator.

View the contents of the file with the type command.

type exp.txt

     x       exp(x)
  0.00   1.00000000
  0.10   1.10517092
  0.20   1.22140276
  0.30   1.34985881
  0.40   1.49182470
  0.50   1.64872127
  0.60   1.82211880
  0.70   2.01375271
  0.80   2.22554093
  0.90   2.45960311
  1.00   2.71828183

Get Number of Bytes Written to File

Write data to a file and return the number of bytes written.

Write an array of data, A, to a file and get the number of bytes that fprintf writes.

A = magic(4);

fileID = fopen('myfile.txt','w');
nbytes = fprintf(fileID,'%5d %5d %5d %5d\n',A)

nbytes = 96

The fprintf function wrote 96 bytes to the file.

Close the file.

fclose(fileID);

View the contents of the file with the type command.

type('myfile.txt')

   16     5     9     4
    2    11     7    14
    3    10     6    15
   13     8    12     1

Display Hyperlinks in Command Window

Display a hyperlink (The MathWorks Web Site) on the screen.

url = 'https://www.mathworks.com';
sitename = 'The MathWorks Web Site';

fprintf('<a href = "%s">%s</a>\n',url,sitename)

%s in the formatSpec input indicates that the values of the variables url and sitename, should be printed as text.

Input Arguments

fileID — File identifier

1 (default) | 2 | scalar

File identifier, specified as one of the following:

• A file identifier obtained from fopen.

• 1 for standard output (the screen).

• 2 for standard error.

Data Types: double

formatSpec — Format of output fields

formatting operators

Format of the output fields, specified using formatting operators. formatSpec also can include ordinary text and special characters.

If formatSpec includes literal text representing escape characters, such as \n, then fprintf translates the escape characters.

formatSpec can be a character vector in single quotes, or, starting in R2016b, a string scalar.

Formatting Operator

A formatting operator starts with a percent sign, %, and ends with a conversion character. The conversion character is required. Optionally, you can specify identifier, flags, field width, precision, and subtype operators between % and the conversion character. (Spaces are invalid between operators and are shown here only for readability).

Conversion Character

This table shows conversion characters to format numeric and character data as text.

Value Type	Conversion	Details
Integer, signed	%d or %i	Base 10
Integer, unsigned	%u	Base 10
	%o	Base 8 (octal)
	%x	Base 16 (hexadecimal), lowercase letters a–f
	%X	Same as %x, uppercase letters A–F
Floating-point number	%f	Fixed-point notation (Use a precision operator to specify the number of digits after the decimal point.)
	%e	Exponential notation, such as 3.141593e+00 (Use a precision operator to specify the number of digits after the decimal point.)
	%E	Same as %e, but uppercase, such as 3.141593E+00 (Use a precision operator to specify the number of digits after the decimal point.)
	%g	The more compact of %e or %f, with no trailing zeros (Use a precision operator to specify the number of significant digits.)
	%G	The more compact of %E or %f, with no trailing zeros (Use a precision operator to specify the number of significant digits.)
Characters or strings	%c	Single character
	%s	Character vector or string array. The type of the output text is the same as the type of formatSpec.

Optional Operators

The optional identifier, flags, field width, precision, and subtype operators further define the format of the output text.

• Identifier

  Order for processing the function input arguments. Use the syntax n$, where n represents the positions of the other input arguments in the function call.

  Example: ('%3$s %2$s %1$s %2$s','A','B','C') prints input arguments 'A', 'B', 'C' as follows: C B A B.

  Note: If an input argument is an array, you cannot use identifiers to specify particular array elements from that input argument.

• Flags

  '–'	Left-justify. Example: %-5.2f Example: %-10s
  '+'	Always print a sign character (+ or –) for any numeric value. Example: %+5.2f Right-justify text. Example: %+10s
  ' '	Insert a space before the value. Example: % 5.2f
  '0'	Pad to field width with zeros before the value. Example: %05.2f
  '#'	Modify selected numeric conversions: For %o, %x, or %X, print 0, 0x, or 0X prefix. For %f, %e, or %E, print decimal point even when precision is 0. For %g or %G, do not remove trailing zeros or decimal point. Example: %#5.0f

• Field Width

  Minimum number of characters to print. The field width operator can be a number, or an asterisk (*) to refer to an input argument.

  When you specify * as the field width operator, the other input arguments must provide both a width and a value to be printed. Widths and values can be pairs of arguments or pairs within a numeric array. With * as the field width operator, you can print different values with different widths.

  Example: The input arguments ('%12d',intmax) are equivalent to ('%*d',12,intmax).

  Example: The input arguments ('%*d',[2 10 5 100]) return '10 100', with two spaces allocated for 10 and five spaces for 100. As an alternative, you also can specify the field widths and values as multiple arguments, as in ('%*d',2,10,5,100).

  The function pads to field width with spaces before the value unless otherwise specified by flags.

• Precision

  For %f, %e, or %E	Number of digits to the right of the decimal point Example: '%.4f' prints pi as '3.1416'
  For %g or %G	Number of significant digits Example: '%.4g' prints pi as '3.142'

  The precision operator can be a number, or an asterisk (*) to refer to an argument.

  When you specify * as the field precision operator, the other input arguments must provide both a precision and a value to be printed. Precisions and values can be pairs of arguments, or pairs within a numeric array. With * as the precision operator, you can print different values to different precisions.

  When you specify *.* as field width and precision operators, you must specify field widths, precisions, and values as triplets.

  Example: The input arguments ('%.4f',pi) are equivalent to ('%.*f',4,pi).

  Example: The input arguments ('%6.4f',pi) are equivalent to ('%*.*f',6,4,pi).

  Example: The input arguments ('%*.*f',6,4,pi,9,6,exp(1)) return '3.1416 2.718282', with 9 and 6 as the field width and precision for the output of exp(1).

  Note

  If you specify a precision operator for floating-point values that exceeds the precision of the input numeric data type, the results might not match the input values to the precision you specified. The result depends on your computer hardware and operating system.

• Subtypes

  You can use a subtype operator to print a floating-point value as its octal, decimal, or hexadecimal value. The subtype operator immediately precedes the conversion character. This table shows the conversions that can use subtypes.

  Input Value Type	Subtype and Conversion Character	Output Value Type
  Floating-point number	%bx or %bX %bo %bu	Double-precision hexadecimal, octal, or decimal value Example: %bx prints pi as 400921fb54442d18
  	%tx or %tX %to %tu	Single-precision hexadecimal, octal, or decimal value Example: %tx prints pi as 40490fdb

Text Before or After Formatting Operators

formatSpec can also include additional text before a percent sign, %, or after a conversion character. The text can be:

• Ordinary text to print.

• Special characters that you cannot enter as ordinary text. This table shows how to represent special characters in formatSpec.

  Special Character	Representation
  Single quotation mark	''
  Percent character	%%
  Backslash	\\
  Alarm	\a
  Backspace	\b
  Form feed	\f
  New line	\n
  Carriage return	\r
  Horizontal tab	\t
  Vertical tab	\v
  Character whose Unicode® numeric value can be represented by the hexadecimal number, N	\xN Example: sprintf('\x5A') returns 'Z'
  Character whose Unicode numeric value can be represented by the octal number, N	\N Example: sprintf('\132') returns 'Z'

Notable Behavior of Conversions with Formatting Operators

• Numeric conversions print only the real component of complex numbers.

• If you specify a conversion that does not fit the data, such as a text conversion for a numeric value, MATLAB overrides the specified conversion, and uses %e.

  Example: '%s' converts pi to 3.141593e+00.

• If you apply a text conversion (either %c or %s) to integer values, MATLAB converts values that correspond to valid character codes to characters.

  Example: '%s' converts [65 66 67] to ABC.

A1,...,An — Numeric or character arrays

scalar | vector | matrix | multidimensional array

Numeric or character arrays, specified as a scalar, vector, matrix, or multidimensional array.

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical | char

Output Arguments

nbytes — Number of bytes

scalar

Number of bytes that fprintf writes, returned as a scalar. When writing to a file, nbytes is determined by the character encoding. When printing data to the screen, nbytes is the number of characters displayed on the screen.

Tips

• Format specifiers for the reading functions sscanf and fscanf differ from the formats for the writing functions sprintf and fprintf. The reading functions do not support a precision field. The width field specifies a minimum for writing, but a maximum for reading.

• If you specify an invalid formatting operator or special character, then fprintf prints all text up to the invalid operator or character and discards the rest.

  Example: If formatSpec is 'value = %z', then fprintf prints 'value =' because %z is not a formatting operator.

  Example: If formatSpec is 'character \x99999 = %s', then fprintf prints 'character' because \x99999 is not a valid special character.

References

[1] Kernighan, B. W., and D. M. Ritchie, The C Programming Language, Second Edition, Prentice-Hall, Inc., 1988.

[2] ANSI specification X3.159-1989: “Programming Language C,” ANSI, 1430 Broadway, New York, NY 10018.

Extended Capabilities

C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

• The formatSpec parameter must be constant.

• In formatSpec, hexadecimal numbers must be in the range [0 7F] and octal numbers must be in the range [0 177].

• If fileID has a constant value of 1 or 2 and extrinsic calls are not possible, the code generator produces a C printf call. Extrinsic calls are not possible when extrinsic calls are disabled or when fprintf is called inside a parfor loop.

• The behavior of fprintf in the generated code matches the C compiler behavior instead of the MATLAB behavior in these cases:

  • The format specifier has a corresponding C format specifier, for example, %e or %E.

  • The fprintf call is inside a parfor loop.

  • Extrinsic calls are disabled.

• These options and capabilities are not supported:

  • The n$ position identifier for reordering input values

  • Printing arrays

  • Using subtypes to print a floating-point number as its octal, decimal, or hexadecimal value

• When you call fprintf with the format specifier %s, you cannot put a null character in the middle of the input character vector. To write a null character, use fprintf(fid, '%c', char(0)).

• Input argument types must match their format types. For example, if n is a double, code generation does not allow the following code:

  str = sprintf('%d',n)

  For code generation, first cast n to a signed integer type such as int8.

  str = sprintf('%d',int8(n))

• When you call fprintf with an integer format specifier, the type of the integer argument must be a type that the target hardware can represent as a native C type. For example, if you call fprintf('%d', int64(n)), then the target hardware must have a native C type that supports a 64-bit integer.

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).

Distributed Arrays

Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.

Usage notes and limitations:

• This function operates on distributed arrays, but executes in the client MATLAB.

For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).