The memmapfile Class
The memmapfile Class
In this section...
“Setting Properties” on page 4-7
“Viewing Properties” on page 4-8
MATLAB implements memory-mapping using an object-oriented class called
memmapfile
.The
memmapfile
class has the properties and methods you need
to map to a file, read and write the file via the map, and remove the map from
memory when you are done.
Setting Properties
There are six properties defined for the
memmapfile
class. These are shown in
the table below. These properties control which file is being mapped, where in
the file the mapping is to begin and end, how the contents of the file are to be
formatted, and whether or not the file is writable. One property of the file
contains the file data itself.
Property
Description
Data Type
Default
Data
Contains the data read from the file or to be written
to the file. (See “Reading a Mapped File” on page
4-24 and “Writing to a Mapped File” on page 4-30)
Any of the
numeric
types
None
Filename
Path and name of the file to map into memory. (See
“Selecting the File to Map” on page 4-13)
char
array
None
Format
Format of the contents of the mapped region,
including class, array shape, and variable or field
name by which to access the data. (See “Identifying
the Contents of the Mapped Region” on page 4-14)
char
array
or N-by-3
cell array
uint8
Offset
Number of bytes from the start of the file to the start
of the mapped region. This number is zero-based.
That is, offset 0 represents the start of the file. Must
be a nonnegative integer value. (See “Setting the
Start of the Mapped Region” on page 4-14)
double
0
4-7
Pdf security - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
change pdf document security; copy from locked pdf
Pdf security - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
change security settings pdf reader; pdf secure
4
Memory-Mapping Data Files
Property
Description
Data Type
Default
Repeat
Number of times to apply the specified format to the
mapped region of the file. Must be a positive integer
value or
Inf
.(See “Repeating a Format Scheme” on
page 4-21)
double
Inf
Writable
Type of access allowed to the mapped region. Must
be logical 1 or logical 0. (See “Setting the Type of
Access” on page 4-22)
logical
false
You can set the values for any property except for
Data
at the time you call
the
memmapfile
constructor, or at any time after that while the map is still
valid. Any properties that are not explicitly set when you construct the object
are given their default values as shown in the table above. For information on
calling the constructor, see “Constructing a memmapfile Object” on page 4-10.
Once a
memmapfile
object has been constructed, you can change the value of
any of its properties. Use the
objname.property
syntax in assigning the new
value. For example, to set a new
Offset
value for memory map object
m
,type
m.Offset = 2048;
Note Property names are not case sensitive. For example, MATLAB
considers
m.offset
to be the same as
m.Offset
.
Viewing Properties
To display the value of all properties of a
memmapfile
object, simply type the
object name. For a
memmapfile
object
m
,typing the variable name
m
displays
the following. Note that this example requires the file
records.dat
which
you will create at the beginning of the next section.
m =
Filename: 'records.dat'
Writable: true
Offset: 1024
Format: 'uint32'
Repeat: Inf
4-8
VB.NET PDF Password Library: add, remove, edit PDF file password
RasterEdge XDoc.PDF SDK provides some PDF security settings about password to help protect your PDF document in VB.NET project. Set PDF security level.
pdf security settings; secure pdf
C# PDF Password Library: add, remove, edit PDF file password in C#
Able to change password on adobe PDF document in C#.NET. To help protect your PDF document in C# project, XDoc.PDF provides some PDF security settings.
pdf encryption; decrypt pdf file
The memmapfile Class
Data: 4778x1 uint32 array
To display the value of any individual property, for example the
Writable
property of object
m
,type
m.Writable
ans =
true
Alternatively, use the
disp (memmapfile)
or
get (memmapfile)
methods to
view properties.
4-9
Online Split PDF file. Best free online split PDF tool.
into Multiple ones. You can receive the PDF files by simply clicking download and you are good to go!. Web Security. We have a privacy
pdf security password; copy text from encrypted pdf
Online Remove password from protected PDF file
If we need a password from you, it will not be read or stored. To hlep protect your PDF document in C# project, XDoc.PDF provides some PDF security settings.
decrypt pdf file online; add security to pdf in reader
4
Memory-Mapping Data Files
Constructing a memmapfile Object
In this section...
“How to Run Examples in This Section” on page 4-10
“Constructing the Object with Default Property Values” on page 4-11
“Changing Property Values” on page 4-11
“Selecting the File to Map” on page 4-13
“Setting the Start of the Mapped Region” on page 4-14
“Identifying the Contents of the Mapped Region” on page 4-14
“Mapping of the Example File” on page 4-19
“Repeating a Format Scheme” on page 4-21
“Setting the Type of Access” on page 4-22
How to Run Examples in This Section
Most of the examples in this section use a file named
records.dat
that
contains a 5000-by-1 matrix of double-precision floating point numbers. Use
the following code to generate this file before going on to the next sections
of this documentation.
First, save this function in your current working directory:
function gendatafile(filename, count)
dmax32 = double(intmax('uint32'));
randData = gallery('uniformdata', [count, 1], 0) * dmax32;
fid = fopen(filename, 'w');
fwrite(fid, randData, 'double');
fclose(fid);
Now execute the
gendatafile
function to generate the
records.dat
file
that is referenced in this section. You can use this function at any time
to regenerate the file:
gendatafile('records.dat', 5000);
4-10
C# HTML5 Viewer: Deployment on AzureCloudService
RasterEdge.XDoc.PDF.HTML5Editor.dll. system.webServer> <validation validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
convert locked pdf to word; change security settings on pdf
C# HTML5 Viewer: Deployment on ASP.NET MVC
RasterEdge.XDoc.PDF.HTML5Editor.dll. system.webServer> <validation validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
convert locked pdf to word doc; decrypt pdf with password
Constructing a memmapfile Object
Constructing the Object with Default Property Values
The first step in mapping to any file is to construct an instance of the
memmapfile
class using the class constructor function. You can haveMATLAB
assign default values to each of the new object’s properties, or you can specify
property values yourself in the call to the
memmapfile
constructor.
The simplest and most general way to call the constructor is with one input
argument that specifies the name of the file you want to map. All other
properties are optional and are given their default values. Use the syntax
shown here:
objname = memmapfile(filename)
To construct a map for the file
records.dat
that resides in your current
working directory, type the following:
m = memmapfile('records.dat')
m =
Filename: 'd:\matlab\records.dat'
Writable: false
Offset: 0
Format: 'uint8'
Repeat: Inf
Data: 40000x1 uint8 array
MATLAB constructs an instance of the
memmapfile
class, assigns it to the
variable
m
,and maps the entire
records.dat
file to memory, setting all
object properties to their default values. In this example, the command maps
the entire file as a sequence of unsigned 8-bit integers and gives the caller
read-only access to its contents.
Changing Property Values
You can make the memory map more specific to your needs by including
more information when calling the constructor. In addition to the
filename
argument, there are four other parameters that you can pass to the
constructor. Each of these parameters represents a property of the object, and
each requires an accompanying value to be passed, as well:
objname = memmapfile(filename, prop1, value1, prop2, value2, ...)
4-11
Online Convert PDF to HTML5 files. Best free online PDF html
Web Security. All your PDF and HTML files will be permanently erased from our servers after one hour. Not anyone has access to your
pdf security options; create pdf security
Online Merge PDF files. Best free online merge PDF tool.
We try to make it as easy as possible to merge your PDF files. You don't need to adjust any settings and the conversion only takes a few seconds. Web Security.
convert secure pdf to word; pdf security remover
4
Memory-Mapping Data Files
For example, to construct a map using nondefault values for the
Offset
,
Format
,and
Writable
properties, type the following, enclosing all property
names and string parameter values in quotes:
m = memmapfile('records.dat', ...
'Offset', 1024,
...
'Format', 'double',
...
'Writable', true);
Type the object name to see the current settings for all properties:
m
m =
Filename: 'd:\matlab\records.dat'
Writable: true
Offset: 1024
Format: 'double'
Repeat: Inf
Data: 4872x1 double array
You can also change the value of any property after the object has been
constructed. Use the syntax:
objname.property = newvalue;
For example, to set the format to
uint16
,type the following. (Property names,
like
Format
,are not case sensitive.)
m.format = 'uint16'
m =
Filename: 'd:\matlab\records.dat'
Writable: true
Offset: 1024
Format: 'uint16'
Repeat: Inf
Data: 19488x1 uint16 array
Further read and write operations to the region mapped by
m
now treat the
data in the file as a sequence of unsigned 16-bit integers. Whenever you
change the value of a
memmapfile
property, MATLAB remaps the file to
memory.
4-12
Constructing a memmapfile Object
Selecting the File to Map
filename
is the only required argument when you call the
memmapfile
constructor. When you call the
memmapfile
constructor, MATLAB assigns the
file name that you specify to the
Filename
property of the new object instance.
Specify the file name as a quoted string, (e.g.,
'records.dat'
). It must
be first in the argument list and not specified as a parameter-value pair.
filename
must include a file name extension if the name of the file being
mapped has an extension. The
filename
argument cannot include any
wildcard characters (e.g.,
*
or
?
), and is not case sensitive.
Note Unlike the other
memmapfile
constructor arguments, you must specify
filename
as a single string, and not as a parameter-value pair.
If the file to be mapped resides somewhere on the MATLAB path, you can use
apartial pathname. If the path to the file is not fully specified, MATLAB
searches for the file in your current working directory first, and then on the
MATLAB path.
Once
memmapfile
locates the file, MATLAB stores the absolute path name for
the file internally, and then uses this stored path to locate the file from that
point on. This enables you to work in other directories outside your current
work directory and retain access to the mapped file.
You can change the value of the
Filename
property at any time after
constructing the
memmapfile
object. You might want to do this if:
• You want to use the same
memmapfile
object on more than one file.
• You save your
memmapfile
object to a MAT-file, and then later load it back
into MATLAB in an environment where the mapped file has been moved to
adifferent location. This requires that you modify the path segment of the
Filename
string to represent the new location.
For example, save
memmapfile
object
m
to file
mymap.mat
:
disp(m.Filename)
d:\matlab\records.dat
4-13
4
Memory-Mapping Data Files
save mymat m
Now move the file to another location, load the object back into MATLAB, and
update the path in the
Filename
property:
load mymat m
m.Filename = 'f:\testfiles\oct1\records.dat'
Note You can only map an existing file. You cannot create a new file and map
that file to memory in one operation. Use the MATLAB file I/O functions to
create the file before attempting to map it to memory.
Setting the Start of the Mapped Region
By default, MATLAB begins a memory map at the start of the file. To begin
the mapped region at some point beyond the start of the file, specify an
Offset
parameter in the call to the
memmapfile
constructor:
objname = memmapfile(filename, 'Offset', bytecount)
The
bytecount
value is the number of bytes from the beginning of the file to
the point in the file where you want the memory map to start (a zero-based
offset). To map the file
records.dat
from a point 1024 bytes from the start
and extending to the end of the file, type
m = memmapfile('records.dat', 'Offset', 1024);
You can change the starting position of an existing memory map by setting
the
Offset
property for the associated object to a new value. The following
command sets the offset of
memmapfile
object
m
to be 2,048 bytes from the
start of the mapped file:
m.Offset = 2048;
Identifying the Contents of the Mapped Region
By default, MATLAB considers all the data in a mapped file to be a sequence
of unsigned 8-bit integers. To have the data interpreted otherwise as it is
read or written to in the mapped file, specify a
Format
parameter and value in
your call to the constructor:
4-14
Constructing a memmapfile Object
objname = memmapfile(filename, 'Format', formatspec)
The
formatspec
argument can either be a character string that identifies a
single class used throughout the mapped region, or a cell array that specifies
more than one class.
For example, say that you map a file that is 12 kilobytes in length. Data read
from this file could be treated as a sequence of 6,000 16-bit (2-byte) integers,
or as 1,500 8-byte double-precision floating-point numbers, to name just a
couple of possibilities. Or you could read this data in as a combination of
different types: for example, as 4,000 8-bit (1-byte) integers followed by 1,000
64-bit (8-byte) integers. You determine how MATLAB will interpret the
mapped data by setting the
Format
property of the
memmapfile
object when
you call its constructor.
MATLAB arrays are stored on disk in column-major order. (The sequence
of array elements is column 1, row 1; column 1, row 2; column 1, last row;
column 2, row 1, and so on.) You might need to transpose or rearrange the
order of array elements when reading or writing via a memory map.
For a list of data types supported for the
Format
property, see “Supported
Data Types for the Format Property” on page 4-20.
For more information on format options see these sections:
• “Mapping a Single Data Type” on page 4-15
• “Formatting the Mapped Data to an Array” on page 4-16
• “Mapping Multiple Data Types and Arrays” on page 4-17
Mapping a Single Data Type
If the file region being mapped contains data of only one type, specify the
Format
value as a character string identifying that type:
objname = memmapfile(filename, 'Format', datatype)
The following command constructs a
memmapfile
object for the entire file
records.dat
,and sets the
Format
property for that object to
uint64
. Any
read or write operations made via the memory map will read and write the
file contents as a sequence of unsigned 64-bit integers:
4-15
4
Memory-Mapping Data Files
m = memmapfile('records.dat', 'Format', 'uint64')
Filename: 'd:\matlab\records.dat'
Writable: false
Offset: 0
Format: 'uint64'
Repeat: Inf
Data: 5000x1 uint64 array
You can change the value of the
Format
property at any time after the
memmapfile
object is constructed. Use the
object.property
syntax shown
here in assigning the new value:
m.Format = 'int32';
Further read and write operations to the region mapped by
m
now treat the
data in the file as a sequence of signed 32-bit integers.
Property names, like
Format
,are not case sensitive.
Formatting the Mapped Data to an Array
You can also specify an array shape to be applied to the data read or written to
the mapped file, and a field name to be used in referencing this array. Use a
cell array to hold these values either when calling the
memmapfile
constructor
or when modifying
m.Format
after the object has been constructed. The cell
array contains three elements: the class to be applied to the mapped region,
the dimensions of the array shape that is applied to the region, and a field
name to use in referencing the data:
objname = memmapfile(filename, ...
'Format', {datatype, dimensions, varname})
The following command constructs a
memmapfile
object for a region of
records.dat
such that MATLAB handles the contents of the region as a
4-by-10-by-18 array of unsigned 32-bit integers, which you can reference in
the structure of the returned object using the field name
x
:
m = memmapfile('records.dat',
...
'Offset', 1024,
...
'Format', {'uint32' [4 10 18] 'x'})
m =
4-16
Documents you may be interested
Documents you may be interested